文章目录
- Bean后置处理器与注解的关系
- 详解Bean后置处理器生效的过程
- BeanFactory后置处理器与注解关系
- 详解BeanFactory后置处理器生效的过程
- @ComponentScan
- @Bean
- @Mapper
Bean后置处理器与注解的关系
首先以一个没有添加额外的后置处理器来说明：️GenericApplicationContext
GenericApplicationContext context = new GenericApplicationContext();
public class Bean1 {
private static final Logger log = LoggerFactory.getLogger(Bean1.class);
private Bean2 bean2;
@Autowired
public void setBean2(Bean2 bean2) {
log.debug("@Autowired 生效: {}", bean2);
this.bean2 = bean2;
}
@Autowired
private Bean3 bean3;
@Resource
public void setBean3(Bean3 bean3) {
log.debug("@Resource 生效: {}", bean3);
this.bean3 = bean3;
}
private String home;
@Autowired
public void setHome(@Value("${JAVA_HOME}") String home) {
log.debug("@Value 生效: {}", home);
this.home = home;
}
@PostConstruct
public void init() {
log.debug("@PostConstruct 生效");
}
@PreDestroy
public void destroy() {
log.debug("@PreDestroy 生效");
}
@Override
public String toString() {
return "Bean1{" +
"bean2=" + bean2 +
", bean3=" + bean3 +
", home='" + home + '\'' +
'}';
}
}
public class Bean2 {
}
public class Bean3 {
}
// ⬇️用原始方法注册三个 bean
context.registerBean("bean1", Bean1.class);
context.registerBean("bean2", Bean2.class);
context.registerBean("bean3", Bean3.class);
context.refresh(); // 执行beanFactory后处理器, 添加bean后处理器, 初始化所有单例运行发现，bean1 bean2 bean3 并没有被注册成功！
通过分析原因是因为 bean1 中得 @Autowired 和 @ value并没有生效，那么接下来启用它
// 自动装配候选者的解析器
context.getDefaultListableBeanFactory().setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
context.registerBean(AutowiredAnnotationBeanPostProcessor.class); // @Autowired @Value此时 bean 中的 @Autowired 和 @Value 就被注入了
[DEBUG] 21:07:55.642 [main] com.itheima.a04.Bean1 - @Value 生效: C:\Program Files\Java\jdk1.8.0_231
[DEBUG] 21:07:55.647 [main] com.itheima.a04.Bean1 - @Autowired 生效: com.itheima.a04.Bean2@120f102b而如果想要@Resource @PostConstruct @PreDestroy 也被注入，需要 启动这个
context.registerBean(CommonAnnotationBeanPostProcessor.class); // @Resource @PostConstruct @PreDestroy效果如下：
[DEBUG] 21:12:03.082 [main] com.itheima.a04.Bean1 - @Resource 生效: com.itheima.a04.Bean3@37858383
[DEBUG] 21:12:03.093 [main] com.itheima.a04.Bean1 - @Autowired 生效: com.itheima.a04.Bean2@59af0466
[DEBUG] 21:12:03.102 [main] com.itheima.a04.Bean1 - @Value 生效: C:\Program Files\Java\jdk1.8.0_231
[DEBUG] 21:12:03.102 [main] com.itheima.a04.Bean1 - @PostConstruct 生效
[DEBUG] 21:12:03.186 [main] com.itheima.a04.Bean1 - @PreDestroy 生效通过上述其实可以看到， @Autowired 等注解的解析 属于 bean 生命周期阶段 （依赖注入，初始化）的扩展功能，而这些扩展功能由bean的后处理器完成。
并且仔细观察输出的结果可以发现，先 @Resource 后 @Autowired，这是其源码的执行顺序有关，其@Resource逻辑判断在@Autowired之前。
以上是加载一些 普通类，但是对于加载配置类 其实还是不行的
@ConfigurationProperties(prefix = "java")
public class Bean4 {
private String home;
private String version;
public String getHome() {
return home;
}
public void setHome(String home) {
this.home = home;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
@Override
public String toString() {
return "Bean4{" +
"home='" + home + '\'' +
", version='" + version + '\'' +
'}';
}
}
context.registerBean("bean4", Bean4.class);
System.out.println(context.getBean(Bean4.class));发现其配置类中并没有成功加载上对应的home 和 version
Bean4{home='null', version='null'}其实在这里还是需要添加一个新的后置处理器：
ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory());其实到这里，本质就是说明了常用注解 与 后置处理器之间的关系，需要加入对应的后置处理器，才会让这些注解生效。
详解Bean后置处理器生效的过程
还是以上面的代码举例：
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
beanFactory.registerSingleton("bean2", new Bean2()); // 创建过程,依赖注入,初始化
beanFactory.registerSingleton("bean3", new Bean3());
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); // @Value实际上刚才让 @Autowired 和 @Value 起作用的是AutowiredAnnotationBeanPostProcessor.class
那么接下来就进入内部来看看具体的实现流程吧。
// 查找哪些属性、方法加了 @Autowired, 这称之为 InjectionMetadata
AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
processor.setBeanFactory(beanFactory);
// 自己创建的，依赖注入等都不会生效
Bean1 bean1 = new Bean1();
System.out.println(bean1);
processor.postProcessProperties(null, bean1, "bean1"); // 执行依赖注入 @Autowired @Value
System.out.println(bean1);输出：
Bean1{bean2=null, bean3=null, home='null'}
[DEBUG] 21:32:35.864 [main] com.itheima.a04.Bean1 - @Value 生效: ${JAVA_HOME}
[DEBUG] 21:32:35.873 [main] com.itheima.a04.Bean1 - @Autowired 生效: com.itheima.a04.Bean2@4562e04d
Bean1{bean2=com.itheima.a04.Bean2@4562e04d, bean3=com.itheima.a04.Bean3@2a65fe7c, home='${JAVA_HOME}'}其实可以发现，当processor.postProcessProperties(null, bean1, “bean1”); 之后，实际上bean1已经被注入了
而后进入到postProcessProperties方法查看
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
metadata.inject(bean, beanName, pvs);
return pvs;
} catch (BeanCreationException var6) {
throw var6;
} catch (Throwable var7) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
}
}可以看到，发现发现findAutowiringMetadata 其实也就是那些属性，那些方法参数上由Autowired注解，找到以后，封装到InjectionMetadata中，然后Inject进去。
进入findAutowiringMetadata里面查看发现：
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
InjectionMetadata metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized(this.injectionMetadataCache) {
metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
metadata = this.buildAutowiringMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}其是private，那么我们首先用反射的方式获取到这个方法：
// 拿到私有方法
Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
findAutowiringMetadata.setAccessible(true);// 这行代码其实就是去执行了findAutowiringMetadata，分析bean1这个类中，有那个有autowire修饰 解析器收集起来
InjectionMetadata metadata = (InjectionMetadata) findAutowiringMetadata.invoke(processor, "bean1", Bean1.class, null);// 获取 Bean1 上加了 @Value @Autowired 的成员变量，方法参数信息
// 由于有些方法并没有重写toString，所以需要加 断点来测试
System.out.println(metadata);断点如图所示：
此时其实就是找到了所有的@Autowired
此时调用 InjectionMetadata 来进行依赖注入, 注入时按类型查找值
metadata.inject(bean1, "bean1", null);
System.out.println(bean1);而inject做了什么呢？首先通过反射获取到成员变量或者方法
Field bean3 = Bean1.class.getDeclaredField("bean3");
DependencyDescriptor dd1 = new DependencyDescriptor(bean3, false);
// 根据成员变量的信息得到类型
Object o = beanFactory.doResolveDependency(dd1, null, null, null);
System.out.println(o);这段代码其实也就是inject的本质了，首先通过反射API来获取Bean1类中名为“bean3”的成员变量的Field对象，然后Spring内部封装了一个DependencyDescriptor 对象来描述bean3成员变量的依赖，最后，会调用doResolveDependency（）方法来解析 bean3的依赖，这意味着Spring会尝试查找并注入名为“bean3”的成员变量所需的Bean，然后打印返回值，这主要是 “bean3”的依赖，也就是所需要的 Bean的实例。
而@Autowired的方法也大同小异：
Method setBean2 = Bean1.class.getDeclaredMethod("setBean2", Bean2.class);
DependencyDescriptor dd2 =
new DependencyDescriptor(new MethodParameter(setBean2, 0), true);
Object o1 = beanFactory.doResolveDependency(dd2, null, null, null);
System.out.println(o1);
Method setHome = Bean1.class.getDeclaredMethod("setHome", String.class);
DependencyDescriptor dd3 = new DependencyDescriptor(new MethodParameter(setHome, 0), true);
Object o2 = beanFactory.doResolveDependency(dd3, null, null, null);
System.out.println(o2);BeanFactory后置处理器与注解关系
还是以一个例子来讲解吧
GenericApplicationContext context = new GenericApplicationContext();
context.registerBean("config", Config.class);
@Configuration
@ComponentScan("com.itheima.a05.component")
public class Config {
@Bean
public Bean1 bean1() {
return new Bean1();
}
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean;
}
@Bean(initMethod = "init")
public DruidDataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource;
}
}
public class Bean1 {
private static final Logger log = LoggerFactory.getLogger(Bean1.class);
public Bean1() {
log.debug("我被 Spring 管理啦");
}
}
context.refresh();
for (String name : context.getBeanDefinitionNames()) {
System.out.println(name);
}实际上输出只会打印出来config，并没有其他的，结合Bean后置处理器与注解的关系，我们可以轻易的想到，一定是缺少了什么后置处理器，所以导致其他的输出不出来。
context.registerBean(ConfigurationClassPostProcessor.class); // @ComponentScan @Bean @Import @ImportResource发现输出结果和我们预期的是一致的：
[DEBUG] 22:07:04.915 [main] com.itheima.a05.component.Bean2 - 我被 Spring 管理啦
[DEBUG] 22:07:04.919 [main] com.itheima.a05.component.Bean3 - 我被 Spring 管理啦
[DEBUG] 22:07:04.928 [main] com.itheima.a05.Bean1 - 我被 Spring 管理啦
[INFO ] 22:07:05.039 [main] c.a.druid.pool.DruidDataSource - {dataSource-1} inited
config
org.springframework.context.annotation.ConfigurationClassPostProcessor
bean2
bean3
bean1
sqlSessionFactoryBean
dataSource
[INFO ] 22:07:05.107 [main] c.a.druid.pool.DruidDataSource - {dataSource-1} closing ...
[INFO ] 22:07:05.108 [main] c.a.druid.pool.DruidDataSource - {dataSource-1} closed以上其实就将我们的beanFactory 配置好了，config里面的配置都被注册成了bean，用过Mybatis的都知道，最终我们使用的是Mapper接口，如果我们配置了Mapper接口，那么是否会被注册进来呢？
@Mapper
public interface Mapper1 {
}
@Mapper
public interface Mapper2 {
}测试发现并没有，所以还需要配置另一种后置处理器
context.registerBean(MapperScannerConfigurer.class, bd -> { // @MapperScanner 自动配置间接的用到了这个
bd.getPropertyValues().add("basePackage", "com.itheima.a05.mapper");
});此时在结果中可以看到，mapper1 mapper2都被注册进来了。
通过上文可以看到@ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器(即 BeanFactory)的扩展功能，这些扩展功能由不同的 BeanFactory 后处理器来完成, 其实主要就是补充了一些 bean 定义。
详解BeanFactory后置处理器生效的过程
@ComponentScan
public class ComponentScanPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override // context.refresh 这个方法在所有的bean定义都已经被加载并且bean实例化之前调用。它允许你在实例化之前对bean工厂进行后置处理操作
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
// 模拟解析
@Override // 这个方法在所有的bean定义被加载，但是还未实例化之前调用。它允许你对注册的bean定义进行修改、添加或删除。
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
try {
// 扫描Config类里面的ComponentScan注解
ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
if (componentScan != null) {
// 便利包结构
for (String p : componentScan.basePackages()) {
System.out.println(p);
// com.itheima.a05.component -> classpath*:com/itheima/a05/component/**/*.class
String path = "classpath*:" + p.replace(".", "/") + "/**/*.class";
System.out.println(path);
// 读取类的原信息
CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
// 根据指定的路径来获取所有符合条件的资源文件
Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
// 用于生成Bean名称的策略类
AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
for (Resource resource : resources) {
// System.out.println(resource);
// 读取每一个class
MetadataReader reader = factory.getMetadataReader(resource);
// System.out.println("类名:" + reader.getClassMetadata().getClassName());
// 得到类上的注解信息
AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
// System.out.println("是否加了 @Component:" + annotationMetadata.hasAnnotation(Component.class.getName()));
// System.out.println("是否加了 @Component 派生:" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));
if (annotationMetadata.hasAnnotation(Component.class.getName())
|| annotationMetadata.hasMetaAnnotation(Component.class.getName())) {
/**
创建一个通用的Bean定义实例，该实例基于提供的类名（reader.getClassMetadata().getClassName()）创建。
具体来说，它会为给定的类名创建一个RootBeanDefinition实例，该实例包含了类的元数据信息。
*/
AbstractBeanDefinition bd = BeanDefinitionBuilder
.genericBeanDefinition(reader.getClassMetadata().getClassName())
.getBeanDefinition();
/**
然后，使用generateBeanName()方法生成一个唯一的Bean名称。这个方法会根据给定的Bean定义
和Bean工厂的规则来生成一个合适的名称。生成的名称通常会基于类名，并在名称冲突时添加序号以保证唯一性。
*/
String name = generator.generateBeanName(bd, beanFactory);
/**
最后，通过beanFactory.registerBeanDefinition()方法将生成的Bean定义注册到Bean工厂中，
使得该Bean能够被Spring容器管理和使用。
*/
beanFactory.registerBeanDefinition(name, bd);
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
context.registerBean(ComponentScanPostProcessor.class); // 解析 @ComponentScan其实本质上就是读取@ComponentScan 注解里面的包结构，然后遍历每一个包路径里面所有的资源，如果对应的资源有@Component 或者器 派生类的话，就将其注入进去即可。
输出：
com.itheima.a05.component
classpath*:com/itheima/a05/component/**/*.class
[DEBUG] 22:18:26.118 [main] com.itheima.a05.component.Bean2 - 我被 Spring 管理啦
[DEBUG] 22:18:26.121 [main] com.itheima.a05.component.Bean3 - 我被 Spring 管理啦
config
com.itheima.a05.ComponentScanPostProcessor
bean2
bean3@Bean
上面的输出其实并没有把config里面的三个bean也注入进去，所以还需要完善bean的注入：
public class AtBeanPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
/**
优化点： 路径 和 配置类写死了
理论上先找到所有的配置类，然后对配置类在进行操作
*/
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
try {
CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/itheima/a05/Config.class"));
Set<MethodMetadata> methods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
for (MethodMetadata method : methods) {
System.out.println(method);
// 解析都是类似的
String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
// 定义config里面的工厂方法
builder.setFactoryMethodOnBean(method.getMethodName(), "config");
// 自动装配，因为sqlSessionFactoryBean 有参数，需要将dataSource 装配进来
// 构造方法的参数，工厂方法的参数，自动装配，选择装配模式AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR
builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
if (initMethod.length() > 0) {
/**
builder.setInitMethodName(initMethod) 方法的作用是将初始化方法名称设置到 BeanDefinitionBuilder 中，
让 Spring 容器在创建 bean 实例之后，自动调用这个指定的初始化方法。
具体而言，当使用 BeanDefinitionBuilder 构建一个 BeanDefinition 对象时，可以通过该方法来设置创建的 bean
需要执行的初始化方法名称，从而在创建 bean 实例时自动调用这个方法。
*/
builder.setInitMethodName(initMethod);
}
AbstractBeanDefinition bd = builder.getBeanDefinition();
beanFactory.registerBeanDefinition(method.getMethodName(), bd);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
context.registerBean(AtBeanPostProcessor.class); // 解析 @Bean本质上的解析其实也都是类似的，不用的在于，没有遍历包路径这一层，只需要遍历指定 config.class里面的方法即可。
此时其实打印输出就可以看到里面的bean也被注入了。
@Mapper
mapper接口其实和前两个还不太一样，比如将其注册在BeanFactory中：
@Bean
public MapperFactoryBean<Mapper1> mapper1(SqlSessionFactory sqlSessionFactory) {
MapperFactoryBean<Mapper1> factory = new MapperFactoryBean<>(Mapper1.class);
factory.setSqlSessionFactory(sqlSessionFactory);
return factory;
}
@Bean
public MapperFactoryBean<Mapper2> mapper2(SqlSessionFactory sqlSessionFactory) {
MapperFactoryBean<Mapper2> factory = new MapperFactoryBean<>(Mapper2.class);
factory.setSqlSessionFactory(sqlSessionFactory);
return factory;
}这样mapper其实也是能被注入的，但是如果手动的将 mapper包下的所有接口都这样注入，岂不是要麻烦死，而且也不符合自动注入的思想对吧？那么可以这样：
public class MapperPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
try {
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
Resource[] resources = resolver.getResources("classpath:com/itheima/a05/mapper/**/*.class");
AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
for (Resource resource : resources) {
MetadataReader reader = factory.getMetadataReader(resource);
ClassMetadata classMetadata = reader.getClassMetadata();
// 判断是接口 还是 实现类
if (classMetadata.isInterface()) {
/**
@Bean
public MapperFactoryBean<Mapper2> mapper2(SqlSessionFactory sqlSessionFactory) {
MapperFactoryBean<Mapper2> factory = new MapperFactoryBean<>(Mapper2.class);
factory.setSqlSessionFactory(sqlSessionFactory);
return factory;
}
*/
AbstractBeanDefinition bd = BeanDefinitionBuilder.genericBeanDefinition(MapperFactoryBean.class)
.addConstructorArgValue(classMetadata.getClassName())
.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)
.getBeanDefinition();
AbstractBeanDefinition bd2 = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();
/**
如果直接使用bd 来生成名字，由于 MapperFactoryBean.class 所以 两个mapper 都是 叫 MapperFactoryBean
所以参考spring源码 以classMetadata.getClassName() 作为名字生成bean
*/
String name = generator.generateBeanName(bd2, beanFactory);
beanFactory.registerBeanDefinition(name, bd);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
}
}其实本质上还是和前两种是一样的，但是在这里有一个坑，就是命名上，如果直接使用bd 来生成名字，由于 MapperFactoryBean.class是唯一的 所以 两个mapper 都是 叫 MapperFactoryBean，所以在这里，参考Spring源码，用第二个AbstractBeanDefinition 以classMetadata.getClassName() 作为名字生成bean。这样就不会出现重名的问题了。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
