浅谈spring中的监听器

1.一般实现和注解方式实现

package com.dc.esb.MyEvent;

import lombok.extern.slf4j.Slf4j;
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.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
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;


/**
 * @auther zhanggt
 */
@Configuration
@Slf4j
public class MyCusListener {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyCusListener.class);
        context.getBean(MyEventControllerTest.class).Event();

    }

    @Component
    public class MyEventControllerTest {
        @Autowired
        ApplicationEventPublisher publisher;

        public void Event() {
            log.info("主业务开始执行。。。。。。");
            //监听事件开始发短信和发邮件
            publisher.publishEvent(new EventDemo("param"));
        }
    }

    @Component
    public class EmailService {
        @EventListener
        public void onApplicationEvent(EventDemo eventDemo) {
            log.info("发邮件业务开始执行。。。。。。");
        }
    }

    @Component
    public class SmService implements ApplicationListener<EventDemo> {
        @Override
        public void onApplicationEvent(EventDemo eventDemo) {
            log.info("发短信业务开始执行。。。。。。");
        }
    }

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

    @Bean
    public ThreadPoolTaskExecutor executors() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        int core = Runtime.getRuntime().availableProcessors();
        executor.setCorePoolSize(core);
        executor.setMaxPoolSize(core * 10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("cus-pool-");
        executor.setQueueCapacity(10000);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor executors) {
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        multicaster.setTaskExecutor(executors);
        return multicaster;

    }

}

2.自定义注解实现

package com.dc.esb.MyEvent;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.*;
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.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadPoolExecutor;


/**
 * @auther zhanggt
 */
@Configuration
@Slf4j
public class MyCusListenerAnno {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyCusListenerAnno.class);
        context.getBean(MyEventControllerTest.class).Event();
        context.close();

    }

    @Bean
    public SmartInitializingSingleton smartInitializingSingleton(ConfigurableApplicationContext context) {
        return new SmartInitializingSingleton() {

            @Override
            public void afterSingletonsInstantiated() {
                for (String name : context.getBeanDefinitionNames()) {
                    Object bean = context.getBean(name);
                    Method[] methods = bean.getClass().getMethods();
                    for (Method method : methods) {
                        if (method.isAnnotationPresent(DemoListener.class)) {
                            ApplicationListener applicationListener = new ApplicationListener() {
                                @Override
                                public void onApplicationEvent(ApplicationEvent applicationEvent) {
                                    Class<?> parameterType = method.getParameterTypes()[0];
                                    if (parameterType.isAssignableFrom(applicationEvent.getClass())) {
                                        try {

                                            method.invoke(bean,applicationEvent);
                                        } catch (IllegalAccessException e) {
                                            e.printStackTrace();
                                        } catch (InvocationTargetException e) {
                                            e.printStackTrace();
                                        }
                                    }

                                }
                            };
                            context.addApplicationListener(applicationListener);
                        }
                    }
                }
            }
        };

    }

    @Component
    public class MyEventControllerTest {
        @Autowired
        ApplicationEventPublisher publisher;

        public void Event() {
            log.info("主业务开始执行。。。。。。");
            //监听事件开始发短信和发邮件
            publisher.publishEvent(new EventDemoD("param"));
        }
    }

    @Component
    public class EmailService {
        @DemoListener
        public void onApplicationEvent(EventDemoD eventDemo) {
            log.info("发邮件业务开始执行。。。。。。");
        }
    }

    @Component
    public class SmService {
        @DemoListener
        public void onApplicationEvent(EventDemoD eventDemo) {
            log.info("发短信业务开始执行。。。。。。");
        }
    }

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

    @Bean
    public ThreadPoolTaskExecutor executors() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        int core = Runtime.getRuntime().availableProcessors();
        executor.setCorePoolSize(core);
        executor.setMaxPoolSize(core * 10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("cus-pool-");
        executor.setQueueCapacity(10000);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @interface DemoListener {

    }

}

3.自定义实现

package com.dc.esb.MyEvent;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
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.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.EventListener;
import org.springframework.context.event.GenericApplicationListener;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.ResolvableType;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadPoolExecutor;


/**
 * @auther zhanggt
 */
@Configuration
@Slf4j
public class MyCusListenerDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyCusListenerDemo.class);
        context.getBean(MyEventControllerTest.class).Event();
        context.close();

    }

    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor executors, ApplicationContext context) {
        return new AbstractCusApplicationEventMulticaster() {
            List<GenericApplicationListener> listenerList = new ArrayList<>();

            //添加事件
            @Override
            public void addApplicationListenerBean(String s) {

                ApplicationListener listener = context.getBean(s, ApplicationListener.class);
                ResolvableType type = ResolvableType.forClass(listener.getClass()).getInterfaces()[0].getGeneric(0);
                GenericApplicationListener genericApplicationListener = new GenericApplicationListener() {
                    @Override
                    public void onApplicationEvent(ApplicationEvent applicationEvent) {
                        listener.onApplicationEvent(applicationEvent);
                    }

                    @Override
                    public boolean supportsEventType(ResolvableType resolvableType) {

                        return type.isAssignableFrom(resolvableType);
                    }
                };
                listenerList.add(genericApplicationListener);

            }

            //发布事件
            @Override
            public void multicastEvent(ApplicationEvent applicationEvent, ResolvableType resolvableType) {
                for (GenericApplicationListener listener : listenerList) {
                    if (listener.supportsEventType(resolvableType.forClass(applicationEvent.getClass()))) {
                        executors.submit(() -> {
                            listener.onApplicationEvent(applicationEvent);
                        });
                    }
                }
            }
        };

    }

    @Component
    public class MyEventControllerTest {
        @Autowired
        ApplicationEventPublisher publisher;

        public void Event() {
            log.info("主业务开始执行。。。。。。");
            //监听事件开始发短信和发邮件
            publisher.publishEvent(new EventDemoD("param"));
        }
    }

    @Component
    public class EmailService implements ApplicationListener<EventDemoD> {
        @Override
        public void onApplicationEvent(EventDemoD eventDemo) {
            log.info("发邮件业务开始执行。。。。。。");
        }
    }

    @Component
    public class SmService implements ApplicationListener<EventDemoD> {
        @Override
        public void onApplicationEvent(EventDemoD eventDemo) {
            log.info("发短信业务开始执行。。。。。。");
        }
    }

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

    @Bean
    public ThreadPoolTaskExecutor executors() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        int core = Runtime.getRuntime().availableProcessors();
        executor.setCorePoolSize(core);
        executor.setMaxPoolSize(core * 10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("cus-pool-");
        executor.setQueueCapacity(10000);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

    abstract class AbstractCusApplicationEventMulticaster implements ApplicationEventMulticaster {

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

        }

        @Override
        public void addApplicationListenerBean(String s) {

        }

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

        }

        @Override
        public void removeApplicationListenerBean(String s) {

        }

        @Override
        public void removeAllListeners() {

        }

        @Override
        public void multicastEvent(ApplicationEvent applicationEvent) {

        }

        @Override
        public void multicastEvent(ApplicationEvent applicationEvent, ResolvableType resolvableType) {

        }
    }

}

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一人荡江湖@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值