容器与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(); } }