Spring框架学习-Spring Boot

7.注解@Autowired装配低层

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver;
import org.springframework.context.annotation.Lazy;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;

import java.util.Optional;

/
 * 测试Spring中依赖注入
 *
 * @author lzlg
 * 2023/4/9 21:02
 */
@Configuration
public class TestSpringDependencyInject {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                TestSpringDependencyInject.class);
        // 获取Bean工厂
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
        // 1.字段依赖注入: 通过resolveDependency方法进行依赖解析并注入
        DependencyDescriptor dd1 = new DependencyDescriptor(Bean1.class.getDeclaredField("bean2"), false);
        Object bean1 = beanFactory.resolveDependency(dd1, "bean1", null, null);
        System.out.println(bean1);
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 2.setter方法依赖注入: 通过MethodParameter
        DependencyDescriptor dd2 = new DependencyDescriptor(
                new MethodParameter(Bean1.class.getMethod("setBean2", Bean2.class), 0),
                false);
        Object bean2 = beanFactory.resolveDependency(dd2, "bean1", null, null);
        System.out.println(bean2);
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 3.Optional依赖注入
        DependencyDescriptor dd3 = new DependencyDescriptor(Bean1.class.getDeclaredField("optional"), false);
        // 如果是Optional类,则提示一级内嵌解析
        if (dd3.getDependencyType() == Optional.class) {
            dd3.increaseNestingLevel();
        }
        // 如果直接调用则返回的是Optional
        Object bean3 = beanFactory.resolveDependency(dd3, "bean1", null, null);
        System.out.println(bean3);
        Optional<Object> optional = Optional.ofNullable(bean3);
        System.out.println(optional);
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 4.ObjectFactory依赖注入
        DependencyDescriptor dd4 = new DependencyDescriptor(Bean1.class.getDeclaredField("objectFactory"), false);
        // 如果是ObjectFactory类,则提示一级内嵌解析
        if (dd4.getDependencyType() == ObjectFactory.class) {
            dd4.increaseNestingLevel();
        }
        // 如果直接调用则返回的是ObjectFactory,可封装成ObjectFactory,在调用Object方法时才进行依赖解析
        ObjectFactory objectFactory = new ObjectFactory() {
            @Override
            public Object getObject() throws BeansException {
                return beanFactory.resolveDependency(dd4, "bean1", null, null);
            }
        };
        System.out.println(objectFactory.getObject());
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 5.@Lazy注解会产生代理对象
        DependencyDescriptor dd5 = new DependencyDescriptor(Bean1.class.getDeclaredField("bean3"), false);
        // 需要通过ContextAnnotationAutowireCandidateResolver来进行代理对象的处理
        ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
        resolver.setBeanFactory(beanFactory);
        // 如果加了@Lazy注解则会返回代理对象
        Object proxy = resolver.getLazyResolutionProxyIfNecessary(dd5, "bean1");
        System.out.println(proxy);
        // 可以看到已经被CGLIB增强了
        System.out.println(proxy.getClass());

        context.close();
    }

    static class Bean1 {
        @Autowired
        private Bean2 bean2;

        @Autowired
        @Lazy
        private Bean2 bean3;

        @Autowired
        public void setBean2(Bean2 bean2) {
            this.bean2 = bean2;
        }

        @Autowired
        private Optional<Bean2> optional;

        @Autowired
        private ObjectFactory<Bean2> objectFactory;
    }

    @Component
    static class Bean2 {

    }
}

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/
 * 测试Spring中依赖注入选择原理
 *
 * @author lzlg
 * 2023/4/9 21:48
 */
@Configuration
public class TestSpringDependencyInjectSelect {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                TestSpringDependencyInjectSelect.class);
        // Bean工厂
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();

        System.out.println("1.数组类型的依赖注入>>>>>>>>>>>>>>>>>>>>>>>>>");
        testArray(beanFactory);

        System.out.println("2.List类型的依赖注入>>>>>>>>>>>>>>>>>>>>>>>>>");
        testList(beanFactory);

        System.out.println("3.ApplicationContext类型的依赖注入>>>>>>>>>>>>>>>>>>>>>>>>>");
        // 在容器refresh方法中的prepareBeanFactory阶段就把ApplicationContext注入了
        // beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        // beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        // beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        // beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        testApplicationContext(beanFactory);

        System.out.println("4.Dao泛型类型的依赖注入>>>>>>>>>>>>>>>>>>>>>>>>>");
        testDaoGeneric(beanFactory);

        System.out.println("5.@Qualifier注解的依赖注入>>>>>>>>>>>>>>>>>>>>>>>>>");
        testQualifier(beanFactory);

        context.close();
    }


    /
     * 注解@Qualifier的依赖注入
     */
    private static void testQualifier(DefaultListableBeanFactory beanFactory) throws NoSuchFieldException {
        // 获取依赖描述信息
        DependencyDescriptor dd = new DependencyDescriptor(Target.class.getDeclaredField("service"), true);
        // 获取需要注入的类型
        Class<?> type = dd.getDependencyType();
        // 需要借助ContextAnnotationAutowireCandidateResolver
        ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
        resolver.setBeanFactory(beanFactory);
        // 根据类型获取Bean名称,注意此时有多个
        for (String name : BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, type)) {
            // 根据名称获取Bean定义信息,注意使用getMergedBeanDefinition
            BeanDefinition bd = beanFactory.getMergedBeanDefinition(name);
            // isAutowireCandidate里会根据注解Qualifier判断是否是需要注入的类型
            if (resolver.isAutowireCandidate(new BeanDefinitionHolder(bd, name), dd)) {
                System.out.println(name);
                // 然后获取Bean
                Object bean = dd.resolveCandidate(name, type, beanFactory);
                System.out.println(bean);
            }
        }
    }

    /
     * Dao泛型类型的依赖注入
     */
    private static void testDaoGeneric(DefaultListableBeanFactory beanFactory) throws NoSuchFieldException {
        // 获取依赖描述信息
        DependencyDescriptor dd = new DependencyDescriptor(Target.class.getDeclaredField("dao"), true);
        // 这里dd.getDependencyType()返回的只是Dao接口的类型
        Class<?> type = dd.getDependencyType();
        // 需要借助ContextAnnotationAutowireCandidateResolver
        ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
        resolver.setBeanFactory(beanFactory);
        // 根据Dao接口类型获取Bean名称,注意此时有多个
        for (String name : BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, type)) {
            // 根据名称获取Bean定义信息
            BeanDefinition bd = beanFactory.getBeanDefinition(name);
            // 判断是否是需要注入的泛型类型
            if (resolver.isAutowireCandidate(new BeanDefinitionHolder(bd, name), dd)) {
                System.out.println(name);
                // 然后获取Bean
                Object bean = dd.resolveCandidate(name, type, beanFactory);
                System.out.println(bean);
            }
        }
    }

    /
     * ApplicationContext类型的依赖注入
     */
    @SuppressWarnings("unchecked")
    private static void testApplicationContext(DefaultListableBeanFactory beanFactory) throws Exception {
        // 获取依赖描述信息
        DependencyDescriptor dd = new DependencyDescriptor(Target.class.getDeclaredField("applicationContext"), true);
        // 通过反射调用获取ApplicationContext存放的Map集合:resolvableDependencies
        Field field = DefaultListableBeanFactory.class.getDeclaredField("resolvableDependencies");
        field.setAccessible(true);
        Map<Class<?>, Object> dependencies = (Map<Class<?>, Object>) field.get(beanFactory);
        // 遍历集合
        for (Map.Entry<Class<?>, Object> entry : dependencies.entrySet()) {
            System.out.println(entry.getKey());
            // 判断dd的类型是否能够是entry.getKey()类型的衍生类型
            if (entry.getKey().isAssignableFrom(dd.getDependencyType())) {

                // 如果是则value就是ApplicationContext
                System.out.println(entry.getValue());
                break;
            }
        }
    }

    /
     * List类型的依赖注入
     */
    private static void testList(DefaultListableBeanFactory beanFactory) throws NoSuchFieldException {
        // 获取依赖描述信息
        DependencyDescriptor dd = new DependencyDescriptor(Target.class.getDeclaredField("serviceList"), true);
        // 判断是否是List类型
        if (dd.getDependencyType() == List.class) {
            // 获取List中泛型的类型信息
            Class<?> type = dd.getResolvableType().getGeneric().resolve();
            // 获取该类型下的,容器中的Bean名称列表
            String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, type);
            // 通过resolveCandidate从容器中获取Bean,本质上还是调用beanFactory.getBean(beanName)
            List<Object> list = Arrays.stream(beanNames)
                    .map(name -> dd.resolveCandidate(name, type, beanFactory))
                    .collect(Collectors.toList());
            // 进行类型转换,返回结果
            Object result = beanFactory.getTypeConverter().convertIfNecessary(list, dd.getDependencyType());
            System.out.println(result);
        }
    }

    /
     * 数组类型的依赖注入
     */
    private static void testArray(DefaultListableBeanFactory beanFactory) throws NoSuchFieldException {
        // 获取依赖描述信息
        DependencyDescriptor dd = new DependencyDescriptor(Target.class.getDeclaredField("serviceArray"), true);
        // 判断是否是数组类型
        if (dd.getDependencyType().isArray()) {
            // 获取数组中元素的类型
            Class<?> type = dd.getDependencyType().getComponentType();
            // 获取该类型下的,容器中的Bean名称列表
            String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, type);
            // 根据名称从容器中获取Bean
            Object[] beans = new Object[beanNames.length];
            for (int i = 0; i < beanNames.length; i++) {
                // 通过resolveCandidate从容器中获取Bean,本质上还是调用beanFactory.getBean(beanName)
                beans[i] = dd.resolveCandidate(beanNames[i], type, beanFactory);
            }
            // 进行类型转换,返回结果
            Object result = beanFactory.getTypeConverter().convertIfNecessary(beans, dd.getDependencyType());
            System.out.println(result);
        }
    }

    static class Target {
        @Autowired
        private Service[] serviceArray;
        @Autowired
        private List<Service> serviceList;
        @Autowired
        private ConfigurableApplicationContext applicationContext;
        @Autowired
        private Dao<Teacher> dao;
        @Autowired
        @Qualifier("service2")
        private Service service;
    }

    interface Dao<T> {

    }

    @Component("dao1")
    static class Dao1 implements Dao<Student> {
    }

    @Component("dao2")
    static class Dao2 implements Dao<Teacher> {
    }

    static class Student {

    }

    static class Teacher {

    }

    interface Service {

    }

    @Component("service1")
    static class Service1 implements Service {

    }

    @Component("service2")
    static class Service2 implements Service {

    }

    @Component("service3")
    static class Service3 implements Service {

    }
}

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

/
 * 测试Spring中依赖注入的其余方式
 * 1.通过注解@Primary来确定需要注入的bean
 * 2.通过字段的名称和bean的名称匹配来注入
 *
 * @author lzlg
 * 2023/4/9 21:50
 */
@Configuration
public class TestSpringIOCElse {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestSpringIOCElse.class);
        // Bean工厂
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();

        // 1.通过@Primary注解选定需要注解的类型
        testPrimary(beanFactory);
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 2.通过字段的名称来确定注入的Bean
        testDefaultByFieldName(beanFactory);

        context.close();
    }

    /
     * 通过字段的名称来确定注入的Bean
     */
    private static void testDefaultByFieldName(DefaultListableBeanFactory beanFactory) throws NoSuchFieldException {
        // 2.通过字段的名称来确定注入的Bean
        DependencyDescriptor dd = new DependencyDescriptor(Target2.class.getDeclaredField("service3"), true);
        // 获取类型信息
        Class<?> type = dd.getDependencyType();
        for (String name : BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, type)) {
            // 通过比对Bean名称和依赖项字段的名称来确定
            if (name.equals(dd.getDependencyName())) {
                System.out.println(name);
                // 获取Bean
                System.out.println(dd.resolveCandidate(name, type, beanFactory));
            }
        }
    }

    /
     * 注解@Primary确定注入的bean
     */
    private static void testPrimary(DefaultListableBeanFactory beanFactory) throws NoSuchFieldException {
        // 1.通过@Primary注解选定需要注解的类型
        DependencyDescriptor dd = new DependencyDescriptor(Target1.class.getDeclaredField("service"), true);
        // 获取类型信息
        Class<?> type = dd.getDependencyType();
        for (String name : BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, type)) {
            // 通过bean定义信息中primary属性判断加了@Primary的类
            if (beanFactory.getMergedBeanDefinition(name).isPrimary()) {
                System.out.println(name);
                // 获取Bean
                System.out.println(dd.resolveCandidate(name, type, beanFactory));
            }
        }
    }

    static class Target1 {
        @Autowired
        private Service service;
    }

    static class Target2 {
        @Autowired
        private Service service3;
    }

    interface Service {

    }

    @Component("service1")
    static class Service1 implements Service {

    }

    @Primary
    @Component("service2")
    static class Service2 implements Service {

    }

    @Component("service3")
    static class Service3 implements Service {

    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/
 * 测试Spring事件监听器原理
 * 通过两种方式实现事件发布
 * 1.实现ApplicationListener接口,并加入到context中
 * 2.使用注解@EventListener
 *
 * @author lzlg
 * 2023/4/10 20:04
 */
@Configuration
public class TestSpringEventListener {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                TestSpringEventListener.class);
        MyService myService = context.getBean(MyService.class);
        myService.doBusiness();

        context.close();
    }

    /
     * 自定义事件
     */
    static class MyEvent extends ApplicationEvent {

        public MyEvent(Object source) {
            // source是事件消息
            super(source);
        }
    }

    @Component
    static class MyService {

        @Autowired
        // 容器refresh()方法中的prepareBeanFactory方法已经加入到容器中,故可注入
        private ApplicationEventPublisher publisher;

        /
         * 业务方法
         */
        public void doBusiness() {
            System.out.println("执行业务方法: doBusiness()...");
            publisher.publishEvent(new MyEvent("开始执行发送短信/邮件的业务..."));
//            System.out.println("发送短信...");
//            System.out.println("发送邮件...");
        }
    }

    /
     * 发送短信的监听器
     */
    @Component
    static class SmsListener implements ApplicationListener<MyEvent> {

        @Override
        public void onApplicationEvent(MyEvent event) {
            System.out.println(event.getSource());
            System.out.println("发送短信...");
        }
    }

    /
     * 发送邮件的监听器
     */
    @Component
    static class EmailListener implements ApplicationListener<MyEvent> {

        @Override
        public void onApplicationEvent(MyEvent event) {
            System.out.println(event.getSource());
            System.out.println("发送邮件...");
        }
    }

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.EventListener;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.concurrent.ThreadPoolExecutor;

/
 * 测试Spring事件监听器原理
 * 通过两种方式实现事件发布
 * 1.实现ApplicationListener接口,并加入到context中
 * 2.使用注解@EventListener
 *
 * @author lzlg
 * 2023/4/10 20:04
 */
@Configuration
public class TestSpringAnnotationEventListener {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                TestSpringAnnotationEventListener.class);
        MyService myService = context.getBean(MyService.class);
        myService.doBusiness();

        context.close();
    }

    /
     * 自定义线程池
     */
    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        // 自定义线程池
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(20);
        // 任务超出极限的处理策略,调用线程池的线程处理
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    /
     * Spring Boot中的默认事件发布器,方法名需为applicationEventMulticaster
     */
    @Bean
    public SimpleApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor taskExecutor) {
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        // 配置线程池
        multicaster.setTaskExecutor(taskExecutor);
        return multicaster;
    }


    /
     * 自定义事件
     */
    static class MyEvent extends ApplicationEvent {

        public MyEvent(Object source) {
            // source是事件消息
            super(source);
        }
    }

    @Component
    static class MyService {

        @Autowired
        // 容器refresh()方法中的prepareBeanFactory方法已经加入到容器中,故可注入
        private ApplicationEventPublisher publisher;

        /
         * 业务方法
         */
        public void doBusiness() {
            System.out.println("执行业务方法: doBusiness()...");
            publisher.publishEvent(new MyEvent("开始执行发送短信/邮件的业务..."));
//            System.out.println("发送短信...");
//            System.out.println("发送邮件...");
        }
    }

    /
     * 发送短信的监听器
     */
    @Component
    static class SmsService {
        @EventListener
        public void sms(MyEvent myEvent) {
            System.out.println(Thread.currentThread().getName() + "\t" + myEvent.getSource());
            System.out.println(Thread.currentThread().getName() + "\t" + "发送短信...");
        }
    }

    /
     * 发送邮件的监听器
     */
    @Component
    static class EmailService {
        @EventListener
        public void email(MyEvent myEvent) {
            System.out.println(Thread.currentThread().getName() + "\t" + myEvent.getSource());
            System.out.println(Thread.currentThread().getName() + "\t" + "发送邮件...");
        }
    }

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.GenericApplicationListener;
import org.springframework.core.ResolvableType;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/
 * 测试Spring中的事件发布器
 *
 * @author lzlg
 * 2023/4/10 20:47
 */
@Configuration
public class TestSpringEventPublisher {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                TestSpringEventPublisher.class);
        // 调用业务方法
        MyService myService = context.getBean(MyService.class);
        myService.doBusiness();
        context.close();
    }

    /
     * 注入自己定义的事件发布器
     */
    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster(ConfigurableApplicationContext context,
                                                                   ThreadPoolTaskExecutor taskExecutor) {
        return new AbstractApplicationEventMulticaster() {
            // 监听器的集合
            private List<GenericApplicationListener> listeners = new ArrayList<>();

            // 添加监听器的方法
            @Override
            public void addApplicationListenerBean(String listenerBeanName) {
                // Spring会把所有实现ApplicationListener接口的监听器的名称返回
                System.out.println(listenerBeanName);
                // 根据Bean名称获取监听器
                ApplicationListener listener = context.getBean(listenerBeanName, ApplicationListener.class);
                // 获取Bean实例的接口中的泛型(事件类型)
                ResolvableType type = ResolvableType.forClass(listener.getClass())
                        .getInterfaces()[0].getGeneric();
                System.out.println(type);

                // 将ApplicationListener封装为GenericApplicationListener,更好通过事件类型进行调用
                GenericApplicationListener genericListener = new GenericApplicationListener() {
                    /
                     * 判断是否是支持的事件类型
                     */
                    @Override
                    public boolean supportsEventType(ResolvableType eventType) {

                        // 如果右边的类型可赋给监听器中的泛型事件类型,则此监听器生效
                        return type.isAssignableFrom(eventType);
                    }

                    /
                     * 事件处理方法
                     */
                    @Override
                    public void onApplicationEvent(ApplicationEvent event) {
                        // 异步执行调用
                        taskExecutor.execute(() -> listener.onApplicationEvent(event));

                    }
                };
                listeners.add(genericListener);
            }

            // 调用监听器的方法
            @Override
            public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {
                // 遍历所有的监听器
                for (GenericApplicationListener listener : listeners) {
                    // 判断是否支持的事件类型,通过事件event的类型
                    if (listener.supportsEventType(ResolvableType.forClass(event.getClass()))) {
                        // 是支持的事件类型才进行回调
                        listener.onApplicationEvent(event);
                    }
                }
            }
        };
    }

    @Component
    static class MyService {
        @Autowired
        private ApplicationEventPublisher publisher;

        public void doBusiness() {
            System.out.println(Thread.currentThread().getName() + "\t" + "执行主线业务");
            // 发布事件
            publisher.publishEvent(new MyEvent("开始执行发送短信/邮件的业务..."));
        }
    }

    @Component
    static class SmsApplicationListener implements ApplicationListener<MyEvent> {
        @Override
        public void onApplicationEvent(MyEvent event) {
            System.out.println(Thread.currentThread().getName() + "\t" + event.getSource());
            System.out.println(Thread.currentThread().getName() + "\t" + "发送短信...");
        }
    }

    @Component
    static class EmailApplicationListener implements ApplicationListener<MyEvent> {
        @Override
        public void onApplicationEvent(MyEvent event) {
            System.out.println(Thread.currentThread().getName() + "\t" + event.getSource());
            System.out.println(Thread.currentThread().getName() + "\t" + "发送邮件...");
        }
    }

    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        return executor;
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }

}

import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;

/
 * 实现自定义的事件监听器
 *
 * @author lzlg
 * 2023/4/10 20:27
 */
@Configuration
public class TestSpringMyEventListener {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                TestSpringMyEventListener.class);

        // 测试只在一个监听类上的监听方法
//        testSmsListener(context);

        // 测试所有的监听器
//        testAllEventListener(context);

        // 调用业务方法
        MyService myService = context.getBean(MyService.class);
        myService.doBusiness();
        context.close();
    }

    /
     * 将监听器的逻辑封装在SmartInitializingSingleton中,这样通过后置处理器可调用到
     * 是EventListenerMethodProcessor
     * 在bean初始化完成后进行调用的
     */
    @Bean
    public SmartInitializingSingleton smartInitializingSingleton(ConfigurableApplicationContext context) {
        return () -> {
            // 遍历所有的Bean
            for (String beanName : context.getBeanDefinitionNames()) {
                // 获取Bean对象
                Object bean = context.getBean(beanName);
                // 遍历Bean上的所有方法
                for (Method method : bean.getClass().getMethods()) {
                    // 看方法上是否有注解@MyEventListener
                    if (method.isAnnotationPresent(MyEventListener.class)) {
                        // 如果有,则创建监听器,并加入到Spring容器中
                        ApplicationListener listener = event -> {
                            // 需要分辨事件是否是需要监听的事件
                            Class<?> parameterClass = method.getParameterTypes()[0];
                            // 如果参数上的类能和event中的类匹配,才进行反射调用
                            if (parameterClass.isAssignableFrom(event.getClass())) {
                                // 反射调用监听方法
                                try {
                                    method.invoke(bean, event);
                                } catch (Exception e) {
                                    throw new RuntimeException(e);
                                }
                            }

                        };
                        context.addApplicationListener(listener);
                    }
                }
            }
        };
    }

    /
     * 测试所有的监听器
     */
    private static void testAllEventListener(AnnotationConfigApplicationContext context) {
        // 遍历所有的Bean
        for (String beanName : context.getBeanDefinitionNames()) {
            // 获取Bean对象
            Object bean = context.getBean(beanName);
            // 遍历Bean上的所有方法
            for (Method method : bean.getClass().getMethods()) {
                // 看方法上是否有注解@MyEventListener
                if (method.isAnnotationPresent(MyEventListener.class)) {
                    // 如果有,则创建监听器,并加入到Spring容器中
                    ApplicationListener listener = event -> {
                        // 需要分辨事件是否是需要监听的事件
                        Class<?> parameterClass = method.getParameterTypes()[0];
                        // 如果参数上的类能和event中的类匹配,才进行反射调用
                        if (parameterClass.isAssignableFrom(event.getClass())) {
                            // 反射调用监听方法
                            try {
                                method.invoke(bean, event);
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }

                    };
                    context.addApplicationListener(listener);
                }
            }
        }
    }

    /
     * 测试只在一个监听类上的监听方法
     */
    private static void testSmsListener(AnnotationConfigApplicationContext context) {
        // 遍历SmsService上的所有方法
        for (Method method : SmsService.class.getMethods()) {
            // 看方法上是否有注解@MyEventListener
            if (method.isAnnotationPresent(MyEventListener.class)) {
                SmsService service = context.getBean(SmsService.class);
                // 如果有,则创建监听器,并加入到Spring容器中
                ApplicationListener listener = new ApplicationListener() {
                    @Override
                    public void onApplicationEvent(ApplicationEvent event) {
                        // 需要分辨事件是否是需要监听的事件
                        Class<?> parameterClass = method.getParameterTypes()[0];
                        System.out.println(parameterClass);
                        // 如果参数上的类能和event中的类匹配,才进行反射调用
                        if (parameterClass.isAssignableFrom(event.getClass())) {
                            // 反射调用监听方法
                            try {
                                method.invoke(service, event);
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }

                    }
                };
                context.addApplicationListener(listener);
            }
        }
    }

    @Component
    static class MyService {
        @Autowired
        private ApplicationEventPublisher publisher;

        public void doBusiness() {
            System.out.println(Thread.currentThread().getName() + "\t" + "执行业务方法...");
            publisher.publishEvent(new MyEvent("开始执行发送短信/邮件的业务..."));
        }
    }

    @Component
    static class SmsService {

        @MyEventListener
        public void sms(MyEvent myEvent) {
            System.out.println(Thread.currentThread().getName() + "\t" + myEvent.getSource());
            System.out.println(Thread.currentThread().getName() + "\t" + "发送短信...");
        }
    }

    @Component
    static class EmailService {

        @MyEventListener
        public void email(MyEvent myEvent) {
            System.out.println(Thread.currentThread().getName() + "\t" + myEvent.getSource());
            System.out.println(Thread.currentThread().getName() + "\t" + "发送邮件...");
        }
    }

    /
     * 自定义事件监听器注解
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyEventListener {

    }

    /
     * 自定义事件
     */
    static class MyEvent extends ApplicationEvent {

        public MyEvent(Object source) {
            super(source);
        }
    }
}

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.core.ResolvableType;

import java.util.function.Predicate;

/
 * 抽象的事件发布器
 *
 * @author lzlg
 * 2023/4/10 20:58
 */
public class AbstractApplicationEventMulticaster implements ApplicationEventMulticaster {

    @Override
    public void addApplicationListener(ApplicationListener<?> listener) {

    }

    @Override
    public void addApplicationListenerBean(String listenerBeanName) {

    }

    @Override
    public void removeApplicationListener(ApplicationListener<?> listener) {

    }

    @Override
    public void removeApplicationListenerBean(String listenerBeanName) {

    }

    @Override
    public void removeApplicationListeners(Predicate<ApplicationListener<?>> predicate) {

    }

    @Override
    public void removeApplicationListenerBeans(Predicate<String> predicate) {

    }

    @Override
    public void removeAllListeners() {

    }

    @Override
    public void multicastEvent(ApplicationEvent event) {

    }

    @Override
    public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {

    }
}