Spring 的 IoC和 DI 详解：从零开始理解与实践
一、IoC（控制反转）
1、什么是 IoC？
IoC 是一种设计思想，它的核心是将对象的创建和管理权从开发者手中转移到外部容器（如 Spring 容器）。通过这种方式，开发者不再需要手动创建对象和管理它们之间的依赖关系，而是将这些任务交给 Spring 容器来完成。
举个例子：
在传统的开发中，如果你需要一个 BookService 来调用 BookDao 的方法，你可能会直接在 BookService 中通过 new BookDao() 创建 BookDao 的实例。这种方式虽然简单，但会导致代码的耦合度很高，难以维护和扩展。
而使用 IoC 后，BookDao 的实例会由 Spring 容器创建，并自动注入到 BookService 中。开发者只需关注业务逻辑，无需关心对象的创建和依赖关系。
2、 IoC 的实现原理
IoC 的实现基于 Spring 容器。Spring 容器负责创建对象、管理对象的生命周期以及对象之间的依赖关系。开发者通过配置文件（如 XML 文件）或注解的方式，将类交给 Spring 容器管理。
3、示例代码
3.1创建类
package dao;
public interface BookDao {
void save();
}
package dao.impl;
import dao.BookDao;
public class BookDaoImpl implements BookDao {
@Override
public void save() {
System.out.println("BookDao save...");
}
}
package service;
import dao.BookDao;
public interface BookService {
void save();
}
package service.impl;
import service.BookService;
import dao.BookDao;
public class BookServiceImpl implements BookService {
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
@Override
public void save() {
System.out.println("BookService save...");
bookDao.save();
}
}
3.2 配置 Spring 容器
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="bookService" class="service.impl.BookServiceImpl">
<property name="bookDao" ref="bookDao"></property>
</bean>
<bean id="bookDao" class="dao.impl.BookDaoImpl"></bean>
</beans>
3.3 运行程序
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.BookService;
public class Main {
public static void main(String[] args) {
// 创建 Spring 容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从容器中获取 BookService 对象
BookService bookService = (BookService) applicationContext.getBean("bookService");
// 调用 save 方法
bookService.save();
}
}
4、运行效果
运行程序后，控制台会输出以下内容：
BookService save...
BookDao save...
运行效果讲解：
- Spring 容器会根据
applicationContext.xml文件中的配置，创建BookServiceImpl和BookDaoImpl的实例。 BookDaoImpl的实例由 Spring 容器创建并通过setBookDao方法注入到BookServiceImpl中。
二、DI（依赖注入）
1、什么是 DI？
DI 是 IoC 的一种实现方式，通过外部注入依赖对象，而不是在类内部创建依赖对象。这种方式使得依赖关系更加清晰，便于维护和测试。
2、DI 的实现方式
DI 的实现方式主要有以下几种：
构造函数注入：通过构造函数传递依赖对象。
Setter 注入：通过 Setter 方法注入依赖对象。
字段注入：直接在字段上注入依赖对象（需要使用注解）。
3、示例代码
3.1 使用 Setter 注入
package service.impl;
import dao.BookDao;
public class BookServiceImpl implements BookService {
private BookDao bookDao;
// 通过 Setter 方法注入依赖
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
@Override
public void save() {
System.out.println("BookService save...");
bookDao.save();
}
}
3.2 配置 Spring 容器
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="bookService" class="service.impl.BookServiceImpl">
<property name="bookDao" ref="bookDao"></property>
</bean>
<bean id="bookDao" class="dao.impl.BookDaoImpl"></bean>
</beans>
3.3 运行程序
运行方式与 IoC 示例相同，代码如下：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.BookService;
public class Main {
public static void main(String[] args) {
// 创建 Spring 容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从容器中获取 BookService 对象
BookService bookService = (BookService) applicationContext.getBean("bookService");
// 调用 save 方法
bookService.save();
}
}
4 运行效果
运行程序后，控制台会输出以下内容：
BookService save...
BookDao save...
运行效果讲解：
BookDaoImpl的实例由 Spring 容器创建并通过setBookDao方法注入到BookServiceImpl中。- 依赖关系由容器管理，
BookServiceImpl不再直接依赖BookDaoImpl的具体实现。
三、Bean 的类型
1、Bean 的基础类型
1.1 name
可以设置别名，相当于 id 的作用，可以设置多个，后面的 ref 也可以引用 name 中的名字。
<bean id="bookdao" name="dao book se" class="dao.impl.BookDaoImpl"/>
1.2 scope
单例和非单例的设置，具体表现在重新创建时是否会刷新一个新的地址（默认为单例）。
<bean id="bookService" class="service.impl.BookServiceImpl" scope="prototype"/>
2、Bean 的实例化
2.1、构造方法实例化
通过反射的原理(直接通过class类进行)直接进行访问构造函数，无论是公共还是私有都能强制进行访问，不能设置实参，会报错
注：没有任何改变，系统自带就有，但不能添加一个有实参的构造，这样系统不会自动生成会报错
2.2、静态方法实例化
factory是一个中转站，通过改变xml中的获取方式类获取到factory中的new方法，本质还是在获取new中的对象
public static bookdao getOrderDao(){
return new bookdaoimpl();
}
方式二：静态方法实例化
<bean id="bookfactory" class="factory.factory1" factory-method="getOrderDao"></bean>
factory-method用于获取类中的这个方法
2.3、动态工厂
方法三：动态方法实例化
<bean id="bookfactory" class="factory.factory2"></bean>
<bean id="dao" factory-method="getOrderDao" factory-bean="bookfactory"></bean>
第一步先实例化对象，也就是第二行代码
第二部调用实例化的对象， factory-bean获取第一部的id名
2.4、factorybean
通过接口来实例化一些方法，减少xml中的操作
public class factory3 implements FactoryBean<bookdao>{
@Override
public boolean isSingleton() {
return true;
}
@Override
public bookdao getObject() throws Exception {
return new bookdaoimpl();
}
@Override
public Class<?> getObjectType() {
return bookdao.class;
}
}
isSingleton()设置是否单例
getObject() 获取返回对象
Type设置继承类型
方法四：factoryBean实例化
<bean id="factoryBean" class="factory.factory3"></bean>
3、Bean 的生命周期（两种方法）
3.1、直接创建
public void service(){
System.out.println("book dao save.......");
}
public void init(){
System.out.println("init");
}
public void destory(){
System.out.println("destory");
}
需要在xml中加参数
<bean id="bookdao" name="dao book se" class="dao.impl.bookdaoimpl" init-method="init" destroy-method="destory"/>
init-method="init"设置初始化
destroy-method="destory"设置销毁
销毁的执行需要程序中进行close关闭后才能运行
ClassPathXmlApplicationContext cts = new ClassPathXmlApplicationContext("application.xml");
bookdao bookdao = (bookdao)cts.getBean("bookdao");
bookdao.service();
cts.close();
更改了ApplicationContext为ClassPathXmlApplicationContext
增加了cts.close();
3.2、接口创建实现
public class bookdaoimpl implements dao.bookdao, InitializingBean, DisposableBean {
public void service(){
System.out.println("book dao save.......");
}
@Override
public void destroy() throws Exception {
System.out.println("destory.........");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("init........");
}
}
实现了
InitializingBean, DisposableBean 两个接口
四、注入类型
1、Setter 注入
1.1 引用类型
通过 Setter 方法注入引用类型
public class BookServiceImpl {
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
}
<bean id="bookService" class="service.impl.BookServiceImpl">
<property name="bookDao" ref="bookDao"></property>
</bean>
ref用于设置这里的名字，name跟类中的名字相同
1.2 简单类型
通过 Setter 方法注入简单类型。
public class BookDaoImpl {
private String databaseName;
private int connectionNum;
public void setDatabaseName(String databaseName) {
this.databaseName = databaseName;
}
public void setConnectionNum(int connectionNum) {
this.connectionNum = connectionNum;
}
}
<bean id="bookDao" class="dao.impl.BookDaoImpl">
<property name="databaseName" value="mysql"></property>
<property name="connectionNum" value="666"></property>
</bean>
value设置里面的值，没有顺序之分
2、构造器注入
2.1 引用类型
通过构造函数注入引用类型。
public class BookServiceImpl {
private BookDao bookDao;
public BookServiceImpl(BookDao bookDao) {
this.bookDao = bookDao;
}
}
<bean id="bookService" class="service.impl.BookServiceImpl">
<constructor-arg name="bookDao" ref="bookDao"></constructor-arg>
</bean>
2.2 简单类型
通过构造函数注入简单类型。
public class BookDaoImpl {
private String databaseName;
private int connectionNum;
public BookDaoImpl(String databaseName, int connectionNum) {
this.databaseName = databaseName;
this.connectionNum = connectionNum;
}
}
<bean id="bookDao" class="dao.impl.BookDaoImpl">
<constructor-arg name="databaseName" value="mysql"></constructor-arg>
<constructor-arg name="connectionNum" value="666"></constructor-arg>
</bean>
2.3命名的其他操作
name的命名可能耦合度过高
1、采取type=“” 类型来进行确定
2、采取index=""位置来进行确定
3、自动注入
在xml中进行配置直接进行注入
<bean class="com.itheima.dao.impl.BookDaoImpl"/>
<!--autowire属性：开启自动装配，通常使用按类型装配-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
autowire一般情况使用bytype按类型
当有两个名字的情况进行按名字，名字取决于dao中的private类型
注意：setter类型不能够忘记，不然会报错
4、集合注入
通过 XML 配置注入集合类型。
public class BookDaoImpl {
private int[] array;
private List<String> list;
private Set<String> set;
private Map<String, String> map;
private Properties properties;
// Getter 和 Setter 方法
}
<bean id="bookDao" class="dao.impl.BookDaoImpl">
<property name="array">
<array>
<value>100</value>
<value>200</value>
<value>300</value>
</array>
</property>
<property name="list">
<list>
<value>itcast</value>
<value>itheima</value>
</list>
</property>
<property name="set">
<set>
<value>itcast</value>
<value>itheima</value>
</set>
</property>
<property name="map">
<map>
<entry key="country" value="china"/>
<entry key="province" value="henan"/>
</map>
</property>
<property name="properties">
<props>
<prop key="country">china</prop>
<prop key="province">henan</prop>
</props>
</property>
</bean>
五、总结
IoC 和 DI 是 Spring 框架的核心概念，它们的主要作用是降低代码的耦合度，提高代码的灵活性和可维护性。
- IoC：通过将对象的创建和管理交给 Spring 容器，开发者只需关注业务逻辑。
- DI：通过依赖注入的方式，使得依赖关系更加清晰，便于维护和测试。
在实际开发中，合理使用 IoC 和 DI 能够显著提高代码的质量和可维护性。希望这篇博客能够帮助你更好地理解和应用 Spring 的 IoC 和 DI！
