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
发送短信成功！