当前位置：首页 > news >正文

SpringIoC和DI

news 2025/4/3 7:25:36

文章目录

- OCP开闭原则
- DIP(依赖倒置原则)
- IOC(控制反转)
- 依赖注入DI
- - 基于XML配置Bean
  - - set注入
    - 构造注入
  - 使用注解存储bean
  - - @Controller
    - 方法注解@Bean
    - 扫描路径
    - 依赖注入
    - 三种注入方式优缺点分析

引入

当我们写了一个程序，遵循SpringMVC三层架构，表现层调用业务逻辑层，业务逻辑层调用持久层，持久层返回数据给Dao层，最后返回到表现层，层与层之间接口，降低耦合度，我们通过new对象调用方法

如果我们需求改变就需要改动原来运行没问题的程序，如果是银行业务，涉及到钱的，后面需要对系统扩展，新增业务，需要改动，改完就需要测试，是很麻烦的事情，违背了OCP开闭原则和DIP原则

OCP开闭原则

OCP是软件七大开发原则中最基本的一个原则：开闭原则

开：对扩展开放

闭：对修改关闭

OCP是七大开发中最基本，最核心的，其他的六个原则都是为这个原则服务的

OCP的核心是什么？

只要在扩展系统功能时，没有修改以前写好的代码，那么就是符合OCP原则的

反之，进行系统功能扩展时，修改了之前的程序，之前所有的程序都需要进行改动，违背了OCP原则

DIP(依赖倒置原则)

像上面的图片

UserController依赖了具体的UserServiceImplForMySQL

UserServiceImplForMySQL依赖了具体的UserDaolmplForMySQL

目前来说：上是依赖下的。

凡是上依赖下的，都违背了依赖倒置原则。

举例子：造⼀辆车

传统的设计思路是先根据轮子大小设计底盘，根据底盘设计车身，再根据车身设计整个汽车

上依赖下，不符合依赖倒置原则，一旦需求发生变化，需要改动整个调用链上的所有代码

什么叫做符合依赖倒置原则？

上不再依赖下了，表示符合依赖倒置原则。

依赖倒置的原则的核心是什么？

倡导面向接口编程，面向抽象编程，不要面向具体编程。比如说new对象new了具体的实现类，我们希望的是存在接口类，而不需要具体的实现类，具体的是写死的

目的：降低程序的耦合度，提高扩展力

怎么解决上面的问题呢？

控制反转思想入场

IOC(控制反转)

什么是控制反转？

把对象创建的控制权交出去，把对象和对象之间的维护权交出去

通过这种思想，我们造车创建对象的顺序是以下这种方式

那么谁去管理呢？

Spring框架

Spring框架实现了控制反转IoC思想

Spring是一个实现了IoC思想的容器

依赖注入DI是控制反转思想的具体体现

Spring官方介绍

Spring是一个轻量级的控制反转(loC)和面向切面(AOP)的容器框架。
Spring最初的出现是为了解决EJB臃肿的设计，以及难以测试等问题。
Spring为简化开发而生，让程序员只需关注核心业务的实现，尽可能的不再关注非业务逻辑代码（事务控制，安全日志等）。

Spring是怎么实例化对象的？

默认情况下，Spring会通过反射机制，调用类的无参构造方法来实例化对象

实现原理是

Class clazz = Class. forName(“//类路径”);

Object obj = clazz. newInstance();

Spring把创建好的Bean存储到什么数据结构中？

Map<String,Object>

Spring 会管理很多Bean对象，id里的是唯一表示，bean的id不能重复，class里的是类的路径，value对应的是存储的类的对象

SpringIoC的底层是怎么实现的？

ApplicationContext接口的超级父接口是：BeanFactory（翻译为Bean工厂，就是能够生产Bean对象的一个工厂对象）定义了获取Bean的方法，而具体的实现类如DefaultListableBeanFactory负责实际的创建过程。ApplicationContext在此基础上增加了更多的企业级功能，比如事件传播、资源访问等。

ApplicationContext是一次性加载并初始化所有的Bean对象，而BeanFactory是需要那个才去加载那个，因此更加轻量

BeanFactory是IoC容器的顶级接口。

Spring的IoC容器底层实际上使用了：工厂模式。

什么是工厂模式？

工厂模式是一种创建型设计模式，用于将对象的创建逻辑封装起来，客户端无需直接实例化具体对象，从而提高代码的灵活性和降低了代码的耦合度

Spring底层的IoC是怎么实现的?

总结：XML解析 +工厂模式 +反射机制

依赖注入DI

注入的常见两种方式

set注入：执行set方法给属性赋值
构造方法注入：执行构造方法给属性赋值

对于依赖注入的理解：对象A和对象B之间的关系，通过注入的手段来维护

基于XML配置Bean

set注入

必须提供一个set方法。

添加依赖

<properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target>
</properties>
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.2.3</version></dependency><!--        Junit依赖单元测试--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.19.0</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j2-impl</artifactId><version>2.19.0</version></dependency>
</dependencies>

配置XML文件

<?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">
</beans>

定义类

package service;
import dao.UserDao;public class UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void printUser(){userDao.print();}
}

Spring容器会调用这个set方法，来给userDao属性赋值。

自己写一个set方法，不使用IDEA工具生成的。不符合javabean规范。

命名规范：使用IDEA生成的setter方法

package impl;import dao.UserDao;public class UserDaoImpl implements UserDao {@Overridepublic void print() {System.out.println("打印UserDaoImpl的信息");}
}

package dao;public interface UserDao {void print();
}

xml配置Bean

<?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"><!--定义userDao--><bean id="userDao" class="impl.UserDaoImpl"/><!--定义userService--><bean id="userService" class="service.UserService"><property name="userDao" ref="userDao"/></bean>
</beans>

bean标签的两个重要属性：

id：是这个bean的身份证号，不能重复，是唯一的标识。

class：必须填写类的全路径，全限定类名。（带包名的类名）

想让Spring调用对应的set方法，需要配置property标签

property标签 :Setter方法注入，支持简单类型或引用类型

name属性怎么指定？去掉set，把剩下的单词首字母变小写

ref为引用，ref后面指定的是要注入的bean的id

Test类

public class UserDaoTest {@Testpublic void test(){ApplicationContext context=new ClassPathXmlApplicationContext("userDao.xml");UserService userService = context.getBean("userService", UserService.class);userService.printUser();}
}

ApplicationContext 为应用上下文—Spring容器。

ApplicationContext 是一个接口。

ApplicationContext 接口下有很多实现类。其中有一个实现类叫做：ClassPathXmlApplicationContext

ClassPathXmLApplicationContext 专门从类路径当中加载spring配置文件的一个Spring上下文对象。

ApplicationContext context=new ClassPathXmlApplicationContext(“userDao.xml”);

这行代码只要执行：就相当于启动了Spring容器，解析userDao. xml文件，并且实例化所有的bean对象，放到spring容器当中。

输出信息

构造注入

提供构造方法

public class UserService {private UserDao userDao;public UserService() {}public UserService(UserDao userDao) {this.userDao = userDao;}public void printUser(){userDao.print();}
}

xml配置

<bean id="userService" class="service.UserService"><constructor-arg index="0" ref="userDao"/></bean>

constructor-arg标签注入依赖 ref指定要注入的bean的id

当构造方法有多个参数，可以使用index下标

<?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"><!--定义userDao--><bean id="userDao" class="impl.UserDaoImpl"/><!--定义bookDao--><bean id="bookDao" class="impl.BookDaoImpl"/><!--定义userService--><bean id="userService" class="service.UserService"><constructor-arg index="0" ref="userDao"/><constructor-arg index="1" ref="bookDao"/></bean>
</beans>

也可以使用name

<constructor-arg name="userDao" ref="userDao"/>
<constructor-arg name="bookDao" ref="bookDao"/>

要注意构造方法对应的参数名字不要写错

注意：使用构造注入，类中一定要有个无参构造方法，如果没有会报错。必须按照类中定义的顺序进行注入，否则会抛出BeanCreationException类型不匹配异常

注入内部Bean

在property标签中嵌套bean标签——内部Bean

<!--   声明bean--><bean id="orderDaoBean" class="dao.OrderDao"></bean><bean id="orderDaoService" class="service.OrderService"><!--内部bean--><property name="orderDao"><bean class="dao.OrderDao"></bean></property></bean>

注入简单类型

使用value属性

创建实体类

public class User {private int age;private String username;public void setUsername(String username) {this.username = username;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "User{" +"age=" + age +", username='" + username + '\'' +'}';}
}

<bean id="userBean" class="model.user"><property name="username" value="zhangsan"/><property name="age" value="15"/>
</bean>

注入集合类型

Spring框架支持注入集合类型的注入

假设我们的实体类包括数组类型、List类型、Map类型、Set类型等

Book类

@Data
@AllArgsConstructor//有参构造
@NoArgsConstructor//无参构造
public class Book {private String bookName;private String author;private Integer price;
}

添加lombok依赖

<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.36</version>
</dependency>

Student类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {private String UserName;private Book[] books;private List<Book> bookList;private Map<String,Book> bookMap;
}

XML配置

<bean id="book1" class="model.Book"></bean>
<bean id="book2" class="model.Book"></bean>
<bean id="book3" class="model.Book"></bean>
<bean id="book4" class="model.Book"></bean>
<bean id="student" class="model.Student"><property name="userName" value="zhangsan"></property><!--数组注入--><property name="books"><array><ref bean="book1"></ref><ref bean="book2"></ref><ref bean="book3"></ref><ref bean="book4"></ref></array></property><!--List注入--><property name="bookList"><list><ref bean="book1"></ref><ref bean="book2"></ref></list></property><!--set注入--><property name="bookSet"><set><ref bean="book3"></ref><ref bean="book4"></ref></set></property><!--Map注入--><property name="bookMap"><map><entry key="01" value-ref="book1"></entry><entry key="02" value-ref="book2"></entry><entry key="03" value-ref="book3"></entry><entry key="04" value-ref="book4"></entry></map></property>
</bean>

测试类

public class StudentTest {@Testpublic void test(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("set.xml");Student student =(Student) applicationContext.getBean("student");System.out.println(student);}
}

使用注解存储bean

把对象交给Spring IOC容器管理，可以加上类注解@Controller、@Service、@Repository、@Component、@Configuration.

• @Controller：控制层,接收请求,对请求进行处理,并进行响应.

• @Servie：业务逻辑层,处理具体的业务逻辑.

• @Repository：数据访问层，也称为持久层.负责数据访问操作

• @Configuration：配置层.处理项目中的⼀些配置信息.

程序应用分层调用流程：

使用@Bean获取对象

@Controller

使用@Controller存储bean

@Controller
public class HController {public void print(){System.out.println("do HController");}
}

通过ApplicationContext上下文管理Bean

@SpringBootApplication
public class IocDemoApplication {public static void main(String[] args) ApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);HController hController=context.getBean(HController.class);hController.print();
}

HController类

@Controller
public class HController {public void print(){System.out.println("do HController");}
}

不加@Controller会报找不到bean的cuow

Bean的命名规范：命名约定使用Java标准约定作为实例字段名

bean名称以小写字母开头，然后使用驼峰式大小写.

特殊情况,当有多个字符并且第一个和第二个字符都是大写时,将保留原始的大小写.比如HController

@Service、@Repository、@Component、@Configuration使用方法类似

注意：使用@Service注解时应不能发起请求，报404

未加 @Servie注解

未加 @Component注解

未加 @Configuration注解

未加 @Repository注解

方法注解@Bean

类注解是添加到某个类上的，但是存在两个问题:

1. 使用外部包里的类,没办法添加类注解

2. ⼀个类,需要多个对象,比如多个数据源

方法注解的使用

Spring框架的设计中，方法注解 @Bean 要配合类注解才能将对象正常的存储到Spring容器中

@Bean注解的bean,bean的名称就是它的方法名

定义多个对象

@Component
public class StrudentComponent {@Beanpublic Student s1(){return new Student("zhangsan",10);}@Bean()public Student s2(){return new Student("lisi",10);}
}

期望只有⼀个匹配,结果发现了两个

设置name属性给Bean对象进⾏重命名操作

扫描路径

通过注解@ComponentScan 来配置扫描路径.（不推荐使用）

推荐做法: 把启动类放在我们希望扫描的包的路径下,这样我们定义的bean就都可以被扫描到

依赖注入

使用@Autowired 实现的

属性注入

@Autowired
private UserService userService;//属性注入

构造器注入

@Autowired
public HelloController(UserService userService, UserConfig userConfig) {this.userService = userService;this.config = userConfig;}

setter方法注入

@Autowired
public void setUserService(UserService userService) {this.userService = userService;
}

使用@Value
注入基本类型、字符串或配置文件中的属性

@Value("${app.timeout:100}")
private int timeout;

@Resource（按名称注入)

@Component
public class StrudentComponent {@Bean("s5")public Student s2(){return new Student("lisi",10);}
}

@Service
public class UserService {@Resource(name="s5")private Student s3;
}

Test类

@SpringBootApplication
public class IocDemoApplication {public static void main(String[] args) {ApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);Student bean=(Student)context.getBean("s5");System.out.println(bean);}
}

当存在多个同类型 Bean 时，按名称指定具体 Bean

使用注解@Qualifier

@Component
public class StrudentComponent {@Beanpublic Student s1(){return new Student("zhangsan",10);}@Bean("s5")public Student s2(){return new Student("lisi",10);}}

@Service
public class UserService {@Qualifier("s5")@Autowiredprivate Student s3;
}

使用@Primary注解：当存在多个相同类型的Bean注入时，加上@Primary注解，来确定默认的实现.

@Component
public class StrudentComponent {@Primary@Beanpublic Student s1(){return new Student("zhangsan",10);}@Beanpublic Student s2(){return new Student("lisi",10);}