/**
* 消息传递机制（同步回调，异步回调）
* 作者:Ai
* 时间:2018年4月29日13:12:39——2018年4月29日23:56:42
* 注释：在多线程和观察者模式的基础上，系统中使用消息传递(类似广播的方式
* 消息机制是面向对象中一种重要的编程思想
* 我们每次点击鼠标，敲击键盘都相当于给操作系统一个消息，让操作系统或软件对我们的消息进行回应
*/
import callback.Manager;
import callback.Programmer;
import message.IMessageProcess;
import message.Message;
import message.MessageType;
import message.Windos;
import java.util.Queue;
import java.util.Timer;
import java.util.concurrent.ArrayBlockingQueue;
public class Start {
public static void main(String[] args){
//region 1.消息机制
//消息队列：以队列（先进先出）存储消息
//消息循环:不断的将位于队首的消息分发出去
//消息处理:根据不同的消息类型做不同的处理
//创建一个容量为10的消息队列
Queue<Message> queue=new ArrayBlockingQueue<Message>(10);
//创建一个窗体
Windos windos=new Windos(queue);
//为消息队列添加消息
queue.add(new Message(windos, MessageType.系统事件,"系统启动"));
queue.add(new Message(windos, MessageType.键盘事件,"键盘输入"));
queue.add(new Message(windos, MessageType.鼠标事件,"鼠标点击"));
//消息循环
Message message=null;
while ((message=queue.poll())!=null){
((IMessageProcess)message.getSource()).doMsg(message);
}
//endregion
//region 2.同步回调，异步回调，
/**
* 回调方法:就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法
* 假如我们现在有老板，组长，员工三个角色
* 老板让组长去调查市场上的手机的使用率和电脑的使用率，方便下一个产品发布在那个平台
* 组长当然不用自己亲自去调查，他可以让员工去调查
*/
//假如说我们就是老板
Manager manager=new Manager(new Programmer());
//执行我下达的命令
manager.entrust(Programmer.CallType.同步);
//这样我们已经完成了回调，但是这样我们发现只有等员工完成调研后组长才会进行别的工作（同步回调）
//在正常情况下，组长在安排好事情后就会去做其他事，只需员工在完成后通知他就行（异步回调)
manager.entrust(Programmer.CallType.异步);
//endregion
}
}
message空间
package message;
/**
* 处理消息接口
*/
public interface IMessageProcess {
void doMsg(Message message);
}
package message;
/**
* 消息类
*/
public class Message {
private Object source;//来源
private MessageType messageType;//类型
private String info;//消息
//region get/set
public Object getSource() {
return source;
}
public void setSource(Object source) {
this.source = source;
}
public MessageType getMessageType() {
return messageType;
}
public void setMessageType(MessageType messageType) {
this.messageType = messageType;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
//endregion
public Message(Object source, MessageType messageType, String info){
this.source=source;
this.messageType=messageType;
this.info=info;
}
}
package message;
public enum MessageType {
键盘事件,
鼠标事件,
系统事件
}
package message;
import java.util.Queue;
/**
* 模拟窗体类
*/
public class Windos implements IMessageProcess {
//消息队列
private Queue<Message> messageQueue;
public Windos(Queue<Message> messageQueue){
this.messageQueue=messageQueue;
}
//重写处理方法
@Override
public void doMsg(Message message) {
switch (message.getMessageType()){
case 系统事件:
onSystem(message);
break;
case 键盘事件:
onKeybord(message);
break;
case 鼠标事件:
onMouse(message);
break;
}
}
/**
* 系统事件
*/
private static void onSystem(Message message){
System.out.println("系统事件");
System.out.println("消息:"+message.getInfo());
}
/**
* 键盘事件
* @param message
*/
private static void onKeybord(Message message){
System.out.println("键盘事件");
System.out.println("消息:"+message.getInfo());
}
/**
* 鼠标事件
* @param message
*/
private static void onMouse(Message message){
System.out.println("鼠标事件");
System.out.println("消息:"+message.getInfo());
}
}
callback 空间
package callback;
public class Boss {
}
package callback;
/**
* 回调接口
*/
public interface ICallback {
boolean check(int result);
}
package callback;
/**
* 组长类
*/
public class Manager implements ICallback {
//要指派的员工
private Programmer programmer;
public Manager(Programmer programmer){
this.programmer=programmer;
}
/**
* 用于 Boss 下达的委托
*/
public void entrust(Programmer.CallType type) {
arrange(type);
}
// 进行安排下属进行 study 工作
private void arrange(Programmer.CallType type) {
System.out.println("Manager 正在为 Programmer 安排工作");
programmer.study(Manager.this,type);
System.out.println("为 Programmer 安排工作已经完成，Manager 做其他的事情去了。");
}
@Override
public boolean check(int result) {
if (result == 5) {
return true;
}
return false;
}
}
package callback;
/**
* 员工类
*/
public class Programmer {
public enum CallType {
同步,
异步
}
/**
* 调研
* @param callback
* @param type
*/
public void study(ICallback callback,CallType type) {
if (type==CallType.同步){
int result = 0;
do {
result++;
System.out.println("第 " + result + " 次研究的结果");
} while (!callback.check(result));
System.out.println("调研任务结束");
}
else {
//异步回调
new StudyThread(callback).start();
}
}
}
package callback;
/**
* 调研线程
*/
public class StudyThread extends Thread {
ICallback callback;
public StudyThread(ICallback callback){
this.callback=callback;
}
@Override
public void run() {
int result = 0;
do {
result++;
System.out.println("第 " + result + " 次研究的结果");
} while (!callback.check(result));
System.out.println("调研任务结束");
}
}
以前写的，若有时间会增加详细说明
