Spring注解驱动

文章目录

SpringBoot注解驱动
- SpringBoot的事件监听
- 关于Spring *PostProcessor的总结
- 几种*Aware反注入的实现

SpringBoot注解驱动

SpringBoot的事件监听

事件监听三大步。首先创建一个事件，然后创建一个监听器，再创建一个事件发布类。
事件的监听是在bean创建完成之后执行的，refresh()的最后一步执行：
事件类：事件类要继承ApplicationEvent这个抽象类，抽象类可以通过匿名内部类实现（如果没有抽象方法则大括号可以为空）

package com.hxh.event;import org.springframework.context.ApplicationEvent;import javax.validation.constraints.NotNull;/*** @author Hanxiaohan* @date 2021/03/19 15:32* @since 1.0* <p>Copyright: Copyright (c) 2021</p>*/
public class SelfEvent extends ApplicationEvent {/*** Create a new {@code ApplicationEvent}.** @param source the object on which the event initially occurred or with*               which the event is associated (never {@code null})*/private static final long serialVersionUID = 1L;private String message;public SelfEvent(@NotNull Object source, String message) {super(source);this.message=message;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}
}

创建监听类：监听类继承ApplicationListener，泛型指定固定类型。
默认的Object source只有getSource()方法。可以添加其他属性（比如message）。

/*** @author Hanxiaohan* @date 2021/03/19 15:46* @since 1.0* <p>Copyright: Copyright (c) 2021</p>*/
@Component
public class SignalListener implements ApplicationListener<SelfEvent> {@Overridepublic void onApplicationEvent(SelfEvent event) {System.out.println("test#####  " + event.getMessage());}
}

发布事件：事件的发布需要调用容器ApplicationContext，通过其publishEvent()，参数可以是ApplicationEvent或者自己设定的其他Event类。

/*** @author Hanxiaohan* @date 2021/03/19 15:50* @since 1.0* <p>Copyright: Copyright (c) 2021</p>*/
@Component
public class EventPublisher {@Resourceprivate Ginger ginger;@AutowiredApplicationContext applicationContext;public void publish(String message){applicationContext.publishEvent(new SelfEvent(ginger,ginger.toString()+ message));}}

本示例使用了一个普通bean作为source

@Component
public class Ginger {@Value("China")private String local;@Value("3.14159")private Double price;@Overridepublic String toString() {return "Ginger{" +"local='" + local + '\'' +", price=" + price +'}';}public String getLocal() {return local;}public void setLocal(String local) {this.local = local;}public Double getPrice() {return price;}public void setPrice(Double price) {this.price = price;}
}

测试调用：

@SpringBootTest
class ExtendsApplicationTests03 {@Autowiredprivate EventPublisher eventPublisher;@Testvoid contextLoads() {eventPublisher.publish("卖生姜啦，预防脱发很有效！");}}

运行结果：

test#####  Ginger{local='China', price=3.14159}卖生姜啦，预防脱发很有效！

ps：上面的监听使用了自己创建的SelfEvent event类型，如果使用ApplicationEvent，会把系统的事件也监听出来。

使用注解监听事件：@EventListener，可以添加多个class
但是监听方法只能有一个参数。

@Component
public class WoFe {@EventListener({ApplicationEvent.class})public void listten(ApplicationEvent event){if(event.getSource().getClass() == Ginger.class){System.out.println("注解实现：：：    " + ((SelfEvent)event).getMessage());}else{System.out.println("注解实现：：：   而我在等你"+event.getSource());}}

 。。。
注解实现：：：   而我在等你[DefaultTestContext@2e3967ea testClass = ExtendsApplicationTests03,
注解实现：：：    Ginger{local='China', price=3.14159}卖生姜啦，预防脱发很有效！
注解实现：：：   而我在等你[DefaultTestContext@2e3967ea testClass = ExtendsApplicationTests03,
。。。

关于Spring *PostProcessor的总结

/**
* bean的生命周期：
* bean存在注册信息（ImportBeanDefinitionRegistrar）-->被加载到beanfactory-->被创建实例
* -->属性赋值（populate）-（BeanPostProcessor，*Aware）->初始化-->销毁
*
* beanfactory历程：
* spring首先创建beanfactory，然后标准初始化beanfactory。。
* 然后执行BeanFactoryPostProcessor（包含两个接口）
*
* BeanFactoryPostProcessor及其子接口
* BeanDefinitionRegistryPostProcessor
* 根据实现PriorityOrder接口执行子接口先。
* 再然后执行“注册BeanPostProcessor”。
*
* ApplicationContextAware：属性赋值之后，初始化之前
* BeanPostProcessor：在属性赋值之后，初始化之前
* BeanNameAware：同上，可修改beanname；
* BeanFactoryAware：在属性赋值之后，初始化之前** BeanPostProcessor：Bean后置处理器，在bean对象初始化前后进行拦截工作。* 1，BeanFactoryPostProcessor*   在beanfactory标准初始化之后调用：所有的bean的定义已经加载到beanFactory但是还没有被*   创建实例。可覆盖属性赋值。** 2，BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor* postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)* 在所以bean定义信息将要被加载，bean实例还未被创建的时候执行。*/

测试BeanDefinitionRegistryPostProcessor：

/*** registries that hold bean definitions** BeanDefinitionRegistry 为bean定义的存储中心；以后BeanFactory就是* 按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例。**/
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("postProcessBeanDefinitionRegistry...bean的数量："+registry.getBeanDefinitionCount()+"!");RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Student.class);registry.registerBeanDefinition("mmp",rootBeanDefinition);AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Student.class).getBeanDefinition();registry.registerBeanDefinition("mmlgb",beanDefinition);}@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量："+beanFactory.getBeanDefinitionCount()+"!");}
}

测试BeanFactoryPostProcessor
一个函数式接口，使用lambda表达式。

@Configuration
@Import({MyImportBeanDefinitionRegistrar.class})
public class MainConfig {@Beanpublic BeanFactoryPostProcessor beanFactoryPostProcessor1(){return ele -> {int beanDefinitionCount = ele.getBeanDefinitionCount();String[] beanDefinitionNames = ele.getBeanDefinitionNames();System.out.println("当前beanfactory中有"+beanDefinitionCount+"个bean！");System.out.println(Arrays.asList(beanDefinitionNames));};}
}

测试ImportBeanDefinitionRegistrar，使用注解导入bean：@Import({MyImportBeanDefinitionRegistrar.class})

/*** AnnotationMetadata: 当前类的注解信息* BeanDefinitionRegistry：* 注册类把所有需要添加到容器中的bean* 调用registerBeanDefinitions手工注册进来*/
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry){boolean mmb1 = registry.containsBeanDefinition("mmp");boolean mmb2 = registry.containsBeanDefinition("mmlgb");if(!mmb1 && !mmb2){registry.registerBeanDefinition("goodbye", new RootBeanDefinition(Student.class));System.out.println("注册进去goodbye");}}
}

测试BeanPostProcessor

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object o, String s) throws BeansException {if(o.getClass()==Lp.class){System.out.println("3+6= 9");}return o;}@Overridepublic Object postProcessAfterInitialization(Object o, String s) throws BeansException {if(s.equals("mmp")){System.out.println("-3-6= -9");}return o;}
}

几种*Aware反注入的实现

运行在bean实例化之后，初始化方法执行之前：

/*** @author Hanxiaohan* @date 2021/03/16 10:04* @since 1.0.1* <p>Copyright: Copyright (c) 2021</p>*/
@Component
public class NiuPi implements ApplicationContextAware , BeanNameAware, EmbeddedValueResolverAware, EnvironmentAware {@Autowiredprivate Lp lb;private StringValueResolver stringValueResolver;@Overridepublic String toString() {return "NiuPi{" +"lb=" + lb +'}';}private ApplicationContext application;@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.application=applicationContext;for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {System.out.println(beanDefinitionName);}}@Overridepublic void setBeanName(String name) {System.out.println(name);}@Overridepublic void setEmbeddedValueResolver(StringValueResolver stringValueResolver) {this.stringValueResolver=stringValueResolver;System.out.println(stringValueResolver.resolveStringValue("#{7.8*75*0.35}"));}@Overridepublic void setEnvironment(Environment environment) {System.out.println(environment.getProperty("os.name"));}
}

@Primary与@Scope 注解含义

@Configuration
public class Cai {//    @Scope("prototype")@Primary@Bean("mmp")public Lv lv1(){Lv lv = new Lv();lv.setAge(100);return lv;}}