容器与Bean（二）-阿里云开发者社区

容器与Bean（一）https://developer.aliyun.com/article/1469469

BeanFactory 后处理器

BeanFactory 后处理器的作用

ConfigurationClassPostProcessor 可以解析

@ComponentScan
@Bean
@Import
@ImportResource

MapperScannerConfigurer 可以解析

Mapper 接口

@ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器（即 BeanFactory）的扩展功能
这些扩展功能由不同的 BeanFactory 后处理器来完成，其实主要就是补充了一些 bean 定义

@ComponentScan底层实现过程

扫描指定包路径下的类文件。在启动Spring应用程序时，会通过ClassLoader加载应用程序的类，并扫描指定包路径下的所有类文件。Spring框架会使用ClassPathBeanDefinitionScanner类来扫描类路径，并使用ClassPathResource类来表示类路径中的资源文件。
解析类文件中的注解信息。扫描完类文件之后，Spring框架会解析类文件中的注解信息，包括@Component、@Service、@Repository等等。根据注解的不同，生成相应的Bean定义对象。
注册BeanDefinition对象。生成BeanDefinition对象之后，Spring框架会将它们注册到Bean工厂中，从而使它们成为可用的Bean对象。在这个过程中，Spring框架会使用BeanDefinitionRegistry接口来注册BeanDefinition对象，并使用BeanDefinitionReaderUtils类来加载Bean定义信息。
初始化Bean对象。当Spring框架完成Bean定义的注册之后，会自动初始化所有的Bean对象。在这个过程中，Spring框架会自动处理Bean之间的依赖关系，通过自动装配来实现依赖注入。此外，还会调用所有的@PostConstruct方法来完成Bean的初始化工作。

@Bean底层实现过程

@Bean注解是Spring框架中的一个核心注解，它用于声明一个Bean对象，并将这个对象纳入Spring容器的管理范畴。底层的具体实现过程包括以下几个步骤：

扫描@Configuration注解。当Spring容器启动时，它会扫描所有的@Configuration注解，这些注解通常用于指定配置类，也就是包含@Bean注解的类。
解析@Bean注解。在扫描到@Configuration注解后，Spring容器会解析其中的@Bean注解，检查注解中是否指定了Bean的名称。如果没有指定名称，Spring容器会使用方法名作为Bean的名称。
执行@Bean注解的方法。在解析@Bean注解后，Spring容器会执行其中的方法，并将方法返回的对象作为Bean对象注册到容器中。如果方法有参数，Spring容器会尝试自动装配这些参数，如果无法自动装配，则会抛出异常。如果有多个Bean对象匹配到了同一个参数类型，则会抛出异常。
处理Bean对象。在执行完所有的@Bean注解的方法后，Spring容器会处理这些Bean对象，包括初始化、依赖注入等操作。具体的处理过程取决于Bean对象的作用域、生命周期等属性。
注册Bean对象。在处理完所有的Bean对象后，Spring容器会将它们注册到容器中，并且为每个Bean对象分配一个唯一的ID，这个ID通常是一个字符串。我们可以使用这个ID来获取Bean对象，或者使用@Autowired注解来注入Bean对象。

Mapper 接口在Spring框架中的底层实现

在Spring框架中，MyBatis的Mapper接口底层实现主要通过动态代理实现。

MyBatis的Mapper接口主要是定义了数据访问的方法，通过Spring框架和MyBatis框架的结合，我们可以通过Mapper接口的定义，使用Spring提供的动态代理机制来自动生成Mapper接口的实现类。

具体实现过程如下：

在Spring配置文件中，需要配置MapperScannerConfigurer来扫描Mapper接口。

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.example.mapper"/>
</bean>

MapperScannerConfigurer(这是一个BeanFactory的后置处理器）会扫描指定包下的Mapper接口，然后将这些接口交给SqlSessionFactoryBean（这个类实现了FactoryBean接口，getObject方法中返回了SqlSessionFactoryBean）管理，通过动态代理生成实现类。

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean {
    private SqlSessionFactoryBean sqlSessionFactoryBean;
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 获取指定包下的所有Mapper接口，并将MapperFactoryBean注册为BeanDefinition
        for (Class<?> mapperClass : this.mapperScanner.scan()) {
            RootBeanDefinition beanDefinition = new RootBeanDefinition(MapperFactoryBean.class);
            beanDefinition.getPropertyValues().add("mapperInterface", mapperClass);
            beanDefinition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactoryBean.getObject());
            registry.registerBeanDefinition(mapperClass.getName(), beanDefinition);
        }
    }
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(this.sqlSessionFactoryBean, "Property 'sqlSessionFactory' is required");
        Assert.notNull(this.mapperScanner, "Property 'mapperScanner' is required");
    }
    // Setter for sqlSessionFactoryBean
    public void setSqlSessionFactoryBean(SqlSessionFactoryBean sqlSessionFactoryBean) {
        this.sqlSessionFactoryBean = sqlSessionFactoryBean;
    }
}

MapperFactoryBean是Mapper接口的工厂类，负责生成Mapper接口的实例。

public class MapperFactoryBean<T> implements FactoryBean<T> {
    private Class<T> mapperInterface;
    private SqlSession sqlSession;
    public T getObject() throws Exception {
        //返回具体Mapper接口的代理实现类对象，注册到IoC容器中
        return this.sqlSession.getMapper(this.mapperInterface);
    }
    public Class<T> getObjectType() {
        return this.mapperInterface;
    }
    // Setter for sqlSession
    public void setSqlSession(SqlSession sqlSession) {
        this.sqlSession = sqlSession;
    }
    // Setter for mapperInterface
    public void setMapperInterface(Class<T> mapperInterface) {
        this.mapperInterface = mapperInterface;
    }
}

最后，我们就可以在业务逻辑中，直接使用@Autowired注解注入Mapper接口的实例，然后调用接口中的方法，实现对数据的访问。

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }
}

以上就是Mapper接口在Spring框架中的底层实现过程。通过动态代理，我们可以轻松地实现Mapper接口的定义和使用，使得数据访问变得更加简单和方便。

Aware 接口和 InitializingBean 接口

Aware 接口提供了一种【内置】的注入手段，例如

BeanNameAware 注入 bean 的名字
BeanFactoryAware 注入 BeanFactory 容器
ApplicationContextAware 注入 ApplicationContext 容器
EmbeddedValueResolverAware 注入 ${} 解析器

InitializingBean 接口提供了一种【内置】的初始化手段
对比

内置的注入和初始化不受扩展功能的影响，总会被执行
而扩展功能受某些情况影响可能会失效
因此 Spring 框架内部的类常用内置注入和初始化

代码演示

public class MyBean implements BeanNameAware, ApplicationContextAware, InitializingBean {
    private static final Logger log = LoggerFactory.getLogger(MyBean.class);
    //接口BeanNameAware重写的方法
    @Override
    public void setBeanName(String name) {
        log.debug("当前bean " + this + " 名字叫:" + name);
    }
    //接口ApplicationContextAware重写的方法
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.debug("当前bean " + this + " 容器是:" + applicationContext);
    }
    //接口InitializingBean重写的方法
    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("当前bean " + this + " 初始化");
    }
    @Autowired
    public void aaa(ApplicationContext applicationContext) {
        log.debug("当前bean " + this + " 使用@Autowired 容器是:" + applicationContext);
    }
    @PostConstruct
    public void init() {
        log.debug("当前bean " + this + " 使用@PostConstruct 初始化");
    }
}

配置类 @Autowired 失效分析

Java 配置类不包含 BeanFactoryPostProcessor 的情况

Java 配置类包含 BeanFactoryPostProcessor 的情况，因此要创建其中的 BeanFactoryPostProcessor 必须提前创建 Java 配置类，而此时的 BeanPostProcessor 还未准备好，导致 @Autowired 等注解失效

对应代码

@Configuration
public class MyConfig1 {
    private static final Logger log = LoggerFactory.getLogger(MyConfig1.class);
    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) {
        log.debug("注入 ApplicationContext");
    }
    @PostConstruct
    public void init() {
        log.debug("初始化");
    }
    @Bean //  ⬅️ 注释或添加 beanFactory 后处理器对应上方两种情况
    public BeanFactoryPostProcessor processor1() {
        return beanFactory -> {
            log.debug("执行 processor1");
        };
    }
}

注意

解决方法：

用内置依赖注入和初始化取代扩展依赖注入和初始化

Bean的初始化与销毁

Spring 提供了多种初始化手段，除了课堂上讲的 @PostConstruct，@Bean(initMethod) 之外，还可以实现 InitializingBean 接口来进行初始化，如果同一个 bean 用了以上手段声明了 3 个初始化方法，那么它们的执行顺序是

@PostConstruct 标注的初始化方法
InitializingBean 接口的初始化方法
@Bean(initMethod) 指定的初始化方法

与初始化类似，Spring 也提供了多种销毁手段，执行顺序为

@PreDestroy 标注的销毁方法
DisposableBean 接口的销毁方法
@Bean(destroyMethod) 指定的销毁方法

Scope

在当前版本的 Spring 和 Spring Boot 程序中，支持五种 Scope

singleton，容器启动时创建（未设置延迟），容器关闭时销毁
prototype，每次使用时创建，不会自动销毁，需要调用 DefaultListableBeanFactory.destroyBean(bean) 销毁
request，每次请求用到此 bean 时创建，请求结束时销毁
session，每个会话用到此 bean 时创建，会话结束时销毁
application，web 容器用到此 bean 时创建，容器停止时销毁

singleton 注入其它 scope 失效

但要注意，如果在 singleton 注入其它 scope 都会有问题，解决方法有

@Lazy
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
ObjectFactory 或者 Provider
ApplicationContext.getBean

三种具体解决方法

@Lazy

关于@Lazy的介绍具体见这篇文章：https://www.yuque.com/weiyikai/framework/lb8lnxo0watlztqt

实现原理：

以单例注入多例为例

有一个单例对象 E

@Component
public class E {
    private static final Logger log = LoggerFactory.getLogger(E.class);
    private F f;
    public E() {
        log.info("E()");
    }
    @Autowired
    public void setF(F f) {
        this.f = f;
        log.info("setF(F f) {}", f.getClass());
    }
    public F getF() {
        return f;
    }
}

要注入的对象 F 期望是多例

@Component
@Scope("prototype")
public class F {
    private static final Logger log = LoggerFactory.getLogger(F.class);
    public F() {
        log.info("F()");
    }
}

测试

E e = context.getBean(E.class);
F f1 = e.getF();
F f2 = e.getF();
System.out.println(f1);
System.out.println(f2);

输出

com.itheima.demo.cycle.F@6622fc65
com.itheima.demo.cycle.F@6622fc65

发现它们是同一个对象，而不是期望的多例对象

对于单例对象来讲，依赖注入仅发生了一次，后续再没有用到多例的 F，因此 E 用的始终是第一次依赖注入的 F

解决

使用 @Lazy生成代理(就是说加上@Lazy注解，注入的对象便是代理对象)
代理对象虽然还是同一个，但当每次使用代理对象的任意方法时，由代理创建新的 f 对象

@Component
public class E {
    @Autowired
    @Lazy
    public void setF(F f) {
        this.f = f;
        log.info("setF(F f) {}", f.getClass());
    }
    // ...
}

注意

@Lazy也可以加在成员变量上，但加在 set 方法上的目的是可以观察输出，加在成员变量上就不行了
@Autowired 加在 set 方法的目的类似

输出

E: setF(F f) class com.itheima.demo.cycle.F$$EnhancerBySpringCGLIB$$8b54f2bc
F: F()
com.itheima.demo.cycle.F@3a6f2de3
F: F()
com.itheima.demo.cycle.F@56303b57

从输出日志可以看到调用 setF 方法时，f 对象的类型是代理类型

ApplicationContext.getBean

在单例 Bean 中注入多例 Bean 时，通过在单例 Bean 中使用 ApplicationContext 的 getBean() 方法获取多例 Bean，而不是通过注入的方式，可以解决多例 Bean 变成单例 Bean 的问题。因为每次获取多例 Bean 都会创建一个新的实例，而不是复用之前创建的实例。

@Service
public class SingletonService {
    @Autowired
    private ApplicationContext context;
    public PrototypeService getPrototypeService() {
        return context.getBean(PrototypeService.class);
    }
}

ObjectFactory 或者 Provider

使用 ObjectFactory 或者 Provider 接口获取多例 Bean，同样可以避免多例 Bean 变成单例 Bean 的问题。因为 ObjectFactory 和 Provider 接口都是延迟加载多例 Bean，每次调用 get() 方法都会创建一个新的实例。

@Service
public class SingletonService {
    @Autowired
    private ObjectFactory<PrototypeService> prototypeServiceObjectFactory;
    public PrototypeService getPrototypeService() {
        return prototypeServiceObjectFactory.getObject();
    }
}

@Service
public class SingletonService {
    @Autowired
    private Provider<PrototypeService> prototypeServiceProvider;
    public PrototypeService getPrototypeService() {
        return prototypeServiceProvider.get();
    }
}

容器与Bean（二）