如何实现Application event，观察者模式

spring 事件为bean 与 bean之间传递消息。一个bean处理完了希望其余一个接着处理.这时我们就需要其余的一个bean监听当前bean所发送的事件.

spring事件使用步骤如下:

1.先自定义事件：你的事件需要继承 ApplicationEvent

2.定义事件监听器: 需要实现 ApplicationListener

3.使用容器对事件进行发布

首先定义一个事件

/**
 * @Title:
 * @Auther: hangyu
 * @Date: 2019/3/13
 * @Description
 * @Version:1.0
 */
public class TestEvent extends ApplicationEvent {

    private String name;

    private String msg;

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

    public TestEvent(Object source, String name, String msg) {
        super(source);
        this.name = name;
        this.msg = msg;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

其次定义事件监听

/**
 * @Title:
 * @Auther: hangyu
 * @Date: 2019/3/13
 * @Description
 * @Version:1.0
 */
@Component
public class TestEventListener implements ApplicationListener<TestEvent> {

    @Async
    @Override
    public void onApplicationEvent(TestEvent testEvent) {
        System.out.println("姓名："+testEvent.getName()+"得到消息："+testEvent.getMsg());
    }
}

使用容器发布事件


/**
 * @Title:
 * @Auther: hangyu
 * @Date: 2019/3/13
 * @Description
 * @Version:1.0
 */
@Component
public class TestEventPublisher {

    @Autowired
    private ApplicationContext applicationContext;

    public void pushlish(String name, String msg){
        applicationContext.publishEvent(new TestEvent(this, name,msg));
    }
}

测试事件是否能够生效

/**
 * @Title:
 * @Auther: hangyu
 * @Date: 2019/3/13
 * @Description
 * @Version:1.0
 */
@Configuration
@ComponentScan("cn.*.event")
public class EventConfig {
}



/**
 * @Title:
 * @Auther: hangyu
 * @Date: 2019/3/13
 * @Description
 * @Version:1.0
 */
public class TestMain {

    private static AnnotationConfigApplicationContext context;

    public static void main(String[] args) {
        start();
    }

    private static void start() {
        if (context == null) {
             context=new AnnotationConfigApplicationContext(EventConfig.class);
        }
        context.getBean(TestEventPublisher.class).pushlish("hangyu","申请退款！");
    }
}

输出打印结果

最后有一个思考：ApplicationEvent事件执行部分和起一个TaskExecutor去执行有啥区别吗？反正都是异步。

可以这样实现；

 @Autowired
 private AsyncExecutor asyncExecutor;

Executor executor = asyncExecutor.getAsyncExecutor();
executor.execute(
           //具体业务
});


@Configuration
@EnableAsync
public class AsyncExecutor implements AsyncConfigurer {

// 日志
static final Logger logger = LoggerFactory.getLogger(AsyncExecutor.class);

public Executor getAsyncExecutor() {

ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();

taskExecutor.setCorePoolSize(5);

taskExecutor.setMaxPoolSize(10);

taskExecutor.setQueueCapacity(20000);

taskExecutor.setKeepAliveSeconds(120);

taskExecutor.setAllowCoreThreadTimeOut(true);

taskExecutor.initialize();

return taskExecutor;
}
}

还可以这样实现；

    <!-- 异步线程池 -->
    <bean id="taskExecutor"
          class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 核心线程数 -->
        <property name="corePoolSize" value="3" />
        <!-- 最大线程数 -->
        <property name="maxPoolSize" value="10" />
        <!-- 队列最大长度 >=mainExecutor.maxSize -->
        <property name="queueCapacity" value="25" />
        <!-- 线程池维护线程所允许的空闲时间 -->
        <property name="keepAliveSeconds" value="300" />
        <!-- 线程池对拒绝任务(无线程可用)的处理策略 ThreadPoolExecutor.CallerRunsPolicy策略 ,调用者的线程会执行该任务,如果执行器已关闭,则丢弃.  -->
        <property name="rejectedExecutionHandler">
            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
        </property>
    </bean>

 @Resource
 private TaskExecutor taskExecutor;

 taskExecutor.execute(new Runnable() {
            @Override
            public void run() {
              //具体业务
            }
}

这就是注解方式和直接引用方式，本质是一样的

我的思考：ApplicationEvent是观察者设计模式，这种设计模式使得主题和观察者之间的耦合度降低，松耦合是面向对象设计中很重要的一个原则，最终也是使用@Async来实现异步。而TaskExecutor则是启动一个线程池任务异步执行任务，两者效果一样，但原理不同。

通过我的思考，又带来一个疑问：那观察者模式是不是就是我们MQ中的发布订阅模式呢？只不过观察者模式是进程内的，而MQ是跨进程的？就这唯一的区别吗？

经过一些资料的查阅：大多数地方观察者模式约等于发布订阅模式，但是观察者模式是由具体目标调度的，而发布/订阅模式是统一由调度中心调的，所以观察者模式的订阅者与发布者之间是存在依赖的，而发布/订阅模式则不会。
所以说观察者模式是小米加步枪，发布订阅模式是95式自动步枪，是它的进化版！