Spring Bean后处理器详细介绍
靖康之耻 人气:0常见Bean后处理器的作用：
public static void main(String[] args) {
// ⬇️GenericApplicationContext 是一个【干净】的容器 干净:没有额外的添加bean工厂处理器,bean处理器,消除一些干拢
GenericApplicationContext context = new GenericApplicationContext();
// ⬇️用原始方法注册三个 bean
context.registerBean("bean1", Bean1.class);
context.registerBean("bean2", Bean2.class);
context.registerBean("bean3", Bean3.class);
// ⬇️初始化容器
context.refresh(); // 执行beanFactory后处理器, 添加bean后处理器, 初始化所有单例
// ⬇️销毁容器
context.close();
}Bean1
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 + '\'' +
'}';
}输出结果：
可以看出，打印的都是spring的日志信息，Bean1里面的注解打印信息，都没有打印出来，说明没有对其进行解析。
那么，我们将如何让注解解析，并打印信息呢？使用Bean的后处理器来完成。
//注册bean context.registerBean(AutowiredAnnotationBeanPostProcessor.class); //解析 @Autowired @Value注解 依赖注入阶段解析
这时候运行，会报错
为什么会报错呢？是因为在作值注入，解析字符串的值的时候，还需要一个类去获取getValue里面的值的，默认情况下没有这个功能，所以报错
//默认解析器不能解析值注入
//获取@Autowired的注入
context.getDefaultListableBeanFactory().setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());这时候运行，@Autowired和@value注解就被解析，打印信息了
@value 生效：D:\tools\jdk1.8 @Autowired 生效：com.tangyuan.ao4.Bean2@59d016c9
我们可以看到，bean生命周期的方法没有解析，所以我们要再加Bean后处理器：
context.registerBean(CommonAnnotationBeanPostProcessor.class); // @Resource @PostConstruct @PreDestroy 依赖注入 初始化前 销毁前
彩蛋：springBoot中的后处理器-----属性绑定
有一个bean，加了@ConfigurationProperties注解，并且给了一个prefix 前缀，将来会根据前缀配合我们的属性名称，去匹配我们配置文件中的信息，匹配到了就进行绑定
例如：
/*
java.home=
java.version=
*/
@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 + '\'' +
'}';
}
}前缀是java，所以匹配配置信息文件中，以java开头的 java.home，java.version，将值返回给属性名称
所以，我们下面演示spring中的后处理器来解析@ConfigurationProperties注解：
在上面的代码中，对bean4进行注册：
context.registerBean("bean4", Bean4.class);ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory()); 初始化前 @ConfigurationProperties 属性绑定
继续讲bean重要的后处理器------AutowiredAnnotationBeanPostProcessor ，解析 @Autowired @Value注解 ，所以我们在这里对它的运行过程进行分析：
// AutowiredAnnotationBeanPostProcessor 运行分析
public class DigInAutowired {
public static void main(String[] args) throws Throwable {
//创建 beanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
//注册两个单例
beanFactory.registerSingleton("bean2", new Bean2()); // 缺点：认为bean是成熟的bean,bean工厂不会执行创建过程,依赖注入,初始化
beanFactory.registerSingleton("bean3", new Bean3());
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); // @Value
beanFactory.addEmbeddedValueResolver(new StandardEnvironment()::resolvePlaceholders); // ${} 的解析器
// 1. 查找哪些属性、方法加了 @Autowired, 这称之为 InjectionMetadata
//创建后处理器对象
AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
//bean后处理器会间接用到beanFactory根据类型找bean
processor.setBeanFactory(beanFactory);
//实例化bean1
Bean1 bean1 = new Bean1();
// System.out.println(bean1);
// processor.postProcessProperties(null, bean1, "bean1"); // 执行依赖注入 @Autowired @Value 参数：是否需要自动装配，被注入的目标，bean的名字
// System.out.println(bean1);
// Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
// findAutowiringMetadata.setAccessible(true);
// InjectionMetadata metadata = (InjectionMetadata) findAutowiringMetadata.invoke(processor, "bean1", Bean1.class, null);// 获取 Bean1 上加了 @Value @Autowired 的成员变量，方法参数信息
后处理器的对象，bean的名字，类型，PropertyValue
// System.out.println(metadata);
// 2. 调用 InjectionMetadata 来进行依赖注入, 注入时按类型查找值
// metadata.inject(bean1, "bean1", null);
// System.out.println(bean1);
// 3. 如何按类型查找值
//获取bean3类中的加了@Autowired注解的成员变量
Field bean3 = Bean1.class.getDeclaredField("bean3");
//封装成对象 false---->可选的
DependencyDescriptor dd1 = new DependencyDescriptor(bean3, false);
//根据成员变量去找要注入哪里
Object o = beanFactory.doResolveDependency(dd1, null, null, null);
System.out.println(o);
//获取bean3类中的加了@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);
//获取bean3类中的加了@Autowired注解的参数的值注入方法
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);
}
//Bean3
@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 生效");
}加载全部内容