Spring的IOC的事件的使用

Spring 的事件机制是使用了观察者模式

观察者模式

定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

主题和观察者定义了一对多的关系。观察者依赖于主题，只要主题状态一有改变，观察者就会被通知。根据通知的风格，观察者可能因此被新值而更新。

松耦合的威力。

当两个对象之间松耦合，它们依然可以交互，但是不太清除彼此的细节。观察者模式提供了一种对象设计，让主题和观察者之间松耦合。关于观察者的一切，主题只知道观察者实现了某个接口。主题不需要知道观察者的具体类是谁、做了什么或其他任何细节。

任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时增加观察者。同样的，也可以在任何时候删除观察者。

在Spring IOC事件中，事件的发布中心就是主题，事件的监听器就是观察者，导致主题发生改变的就是事件。

当向(主题)事件发布中心注册事件后，主题就会通知观察者事件监听器更新。事件发布中心可以添加事件监听器。

package com.zghw.spring.demo.demo.event;

/**
* 消息Bean
* @author zghw
*
*/
public class Message {
private String message;
private String phone;

public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}

}

1.定义事件

package com.zghw.spring.demo.demo.event;

import org.springframework.context.ApplicationEvent;
/**
* 定义一个发送短信的事件
* 实现了ApplicationEvent
* @author zghw
*
*/
public class SendMessageEvent extends ApplicationEvent {
private static final long serialVersionUID = 1L;
//消息对象
private Message message;

//source代表了发布该事件的发布源
public SendMessageEvent(Object source,Message message) {
super(source);
this.message = message;
}

public Message getMessage() {
return message;
}

public void setMessage(Message message) {
this.message = message;
}

}

2.定义监听器 观察者

package com.zghw.spring.demo.demo.event;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
/**
* 发送短信监听器，监听到事件就开始发送。
* 实现ApplicationListener
* @author zghw
*
*/
@Component
public class SendMessageListenter implements ApplicationListener<SendMessageEvent>{

/**
* 监听事件SendMessage，当有事件发生则调用该方法
*/
public void onApplicationEvent(SendMessageEvent event) {
Message message = event.getMessage();
String msg=message.getMessage();
String phone = message.getPhone();
try {
System.out.println("开始向手机"+phone+"发送短信，短信内容为："+msg);
Thread.sleep(1000);
System.out.println("发送短信成功！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

3.定义事件注册中心及发布事件 主题

package com.zghw.spring.demo.demo.event;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;

/**
* 实现ApplicationEventPublisherAware让容器ApplicationContext作为事件发布中心，
* 因为ApplicationContext实现了ApplicationEventPublisher
* @author zghw
*
*/
@Service
public class UserService implements ApplicationEventPublisherAware{
private ApplicationEventPublisher publisher;

public void registerUser(String name,String phone) throws InterruptedException{
System.out.println("注册用户中");
Thread.sleep(300);
System.out.println("注册完成！");

Message message=new Message();
message.setMessage("你好，"+name+" 你中了1000W");
message.setPhone(phone);
SendMessageEvent event=new SendMessageEvent(this,message);
//发布中心发布事件
publisher.publishEvent(event);
}

/**
* 实现ApplicationEventPublisherAware的方法，spring在使用时UserServicebean对象时会自动帮我们注入
* ApplicationEventPublisher的实现
*/
public void setApplicationEventPublisher(
ApplicationEventPublisher applicationEventPublisher) {
this.publisher = applicationEventPublisher;
}
}

4.测试结果

package com.zghw.spring.demo.demo.event;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
* 测试发送短信事件
* @author zghw
*
*/
@Configuration
@ComponentScan
public class TestEvent {
public static void main(String[] args) throws InterruptedException {
ApplicationContext ctx = new AnnotationConfigApplicationContext(TestEvent.class);
UserService us=(UserService)ctx.getBean("userService");
us.registerUser("zghw", "13699120345");
}

}

注册用户中

注册完成！

开始向手机13699120345发送短信，短信内容为：你好，zghw 你中了1000W

发送短信成功！