【Spring】IoC容器

分手后的思念是犯贱 2024-03-24 06:21 14阅读 0赞

*  ### 控制反转（IoC） ###

控制反转是一种思想，控制反转是为了降低程序耦合度，提高程序扩展力。

控制反转，反转的是什么？

将对象的创建权利交出去，交给第三方容器负责。

将对象和对象之间关系的维护权交出去，交给第三方容器负责。

控制反转这种思想如何实现呢？

DI（Dependency Injection）：依赖注入实现了控制反转的思想。指Spring创建对象的过程中，将对象依赖属性通过配置进行注入

--------------------

**依赖注入常见的实现方式包括两种：**

第一种：set注入

第二种：构造注入

所以结论是：IOC 就是一种控制反转的思想， 而 DI 是对IoC的一种具体实现。

**Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。**

--------------------

*  ### IoC容器在Spring的实现 ###

Spring 的 IoC 容器就是 IoC思想的一个落地的产品实现。IoC容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IoC 容器。Spring 提供了IoC 容器的两种实现方式：

**1、BeanFactory**

这是 IoC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

**2、ApplicationContext**

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

**3、ApplicationContext的主要实现类**

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ClassPathXmlApplicationContext</td> 
   <td>通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象</td> 
  </tr> 
  <tr> 
   <td>FileSystemXmlApplicationContext</td> 
   <td>通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象</td> 
  </tr> 
  <tr> 
   <td>ConfigurableApplicationContext</td> 
   <td>ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。</td> 
  </tr> 
  <tr> 
   <td>WebApplicationContext</td> 
   <td>专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。</td> 
  </tr> 
 </tbody> 
</table>

--------------------

#### 一、基于注解管理Bean（☆） ####

从 Java 5 开始，Java 增加了对注解（Annotation）的支持，它是代码中的一种特殊标记，可以在编译、类加载和运行时被读取，执行相应的处理。开发人员可以通过注解在不改变原有代码和逻辑的情况下，在源代码中嵌入补充信息。

Spring 从 2.5 版本开始提供了对注解技术的全面支持，我们可以使用注解来实现自动装配，简化 Spring 的 XML 配置。

Spring 通过注解实现自动装配的步骤如下：

1.  引入依赖
2.  开启组件扫描
3.  使用注解定义 Bean
4.  依赖注入

#### 1、搭建子模块 spring6-ioc-annotation ####

**1.1、搭建模块**

搭建方式如：spring6-ioc-xml

**1.2、引入配置文件**

<dependencies>
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>6.0.3</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
            </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>

#### 1.3、开启组件扫描 ####

Spring 默认不使用注解装配 Bean，因此我们需要在 Spring 的 XML 配置中，通过 context:component-scan 元素开启 Spring Beans的自动扫描功能。开启此功能后，Spring 会自动从扫描指定的包（base-package 属性设置）及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    
        
    
        
        <context:component-scan base-package="com.cj.spring6"></context:component-scan>
        
    </beans>

**ps：**在使用 context:component-scan 元素开启自动扫描功能前，首先需要在 XML 配置的一级标签 <beans> 中添加 context 相关的约束。

**情况一：最基本的扫描方式**

<context:component-scan base-package="com.cj.spring6"></context:component-scan>

**情况二：指定要排除的组件**

<context:component-scan base-package="com.cj.spring6">
            
            
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
            
        </context:component-scan>

**情况三：仅扫描指定组**

<context:component-scan base-package="com.cj" use-default-filters="false">
            
            
            
            
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
            
        </context:component-scan>

#### **1.4、使用注解定义 Bean** ####

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Component</td> 
   <td>该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。</td> 
  </tr> 
  <tr> 
   <td>@Repository</td> 
   <td>该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。</td> 
  </tr> 
  <tr> 
   <td>@Service</td> 
   <td>该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。</td> 
  </tr> 
  <tr> 
   <td>@Controller</td> 
   <td>该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。</td> 
  </tr> 
 </tbody> 
</table>

--------------------

#### 场景一：@Autowired注入 ####

单独使用@Autowired注解，**默认根据类型装配**。【默认是byType】

package org.springframework.beans.factory.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired {
        boolean required() default true;
    }

--------------------

源码中有两处需要注意：

第一处：该注解可以标注在哪里？构造方法上、方法上、形参上、属性上、注解上

第二处：该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

#### 场景一：属性注入 ####

创建UserDao接口

package com.atguigu.spring6.dao;
    
    public interface UserDao {
    
        public void print();
    }

创建UserService接口

package com.atguigu.spring6.service;
    
    public interface UserService {
    
        public void out();
    }

创建UserServiceImpl实现类

package com.atguigu.spring6.service.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDao userDao;
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

创建UserController类

package com.atguigu.spring6.controller;
    
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

**测试：**

package com.atguigu.spring6.bean;
    
    import com.atguigu.spring6.controller.UserController;
    import org.junit.jupiter.api.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class UserTest {
    
        private Logger logger = LoggerFactory.getLogger(UserTest.class);
    
        @Test
        public void testAnnotation(){
            ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
            UserController userController = context.getBean("userController", UserController.class);
            userController.out();
            logger.info("执行成功");
        }
    
    
    }

测试结果：

![357140cd809d417196d2c998fd383877.png][]

以上构造方法和setter方法都没有提供，经过测试，仍然可以注入成功。

--------------------

#### 场景二：set注入 ####

修改UserServiceImpl类

package com.atguigu.spring6.service.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        private UserDao userDao;
    
        @Autowired
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

####  ####

修改UserController类

package com.atguigu.spring6.controller;
    
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
    
        private UserService userService;
    
        @Autowired
        public void setUserService(UserService userService) {
            this.userService = userService;
        }
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

--------------------

#### 场景三：构造方法注入 ####

修改UserServiceImpl类

package com.atguigu.spring6.service.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        private UserDao userDao;
    
        @Autowired
        public UserServiceImpl(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

修改UserController类

package com.atguigu.spring6.controller;
    
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
    
        private UserService userService;
    
        @Autowired
        public UserController(UserService userService) {
            this.userService = userService;
        }
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

--------------------

#### 场景四：形参上注入 ####

修改UserServiceImpl类

package com.atguigu.spring6.service.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        private UserDao userDao;
    
        public UserServiceImpl(@Autowired UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

修改UserController类

package com.atguigu.spring6.controller;
    
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
    
        private UserService userService;
    
        public UserController(@Autowired UserService userService) {
            this.userService = userService;
        }
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

--------------------

#### 场景五：只有一个构造函数，无注解 ####

修改UserServiceImpl类

package com.atguigu.spring6.service.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDao userDao;
    
        public UserServiceImpl(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

ps：当有参数的构造方法只有一个时，@Autowired注解可以省略。

说明：有多个构造方法时呢？大家可以测试（再添加一个无参构造函数），测试报错

--------------------

#### 场景六：@Autowired注解和@Qualifier注解联合 ####

添加dao层实现

package com.atguigu.spring6.dao.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class UserDaoRedisImpl implements UserDao {
    
        @Override
        public void print() {
            System.out.println("Redis Dao层执行结束");
        }
    }

测试：测试异常。

错误信息中说：不能装配，UserDao这个Bean的数量等于。

**ps：**怎么解决这个问题呢？当然要byName，根据名称进行装配了。

解决方案：

修改UserServiceImpl类

package com.atguigu.spring6.service.impl;
    
    import com.atguigu.spring6.dao.UserDao;
    import com.atguigu.spring6.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        @Qualifier("userDaoImpl") // 指定bean的名字
        private UserDao userDao;
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

#### **总结** ####

@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。

当带参数的构造方法只有一个，@Autowired注解可以省略。

@Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。

[357140cd809d417196d2c998fd383877.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3e0b99878aae45d2b70ad56338cab8c9.png