Java消息传递机制

/**
 * 消息传递机制（同步回调，异步回调）
 * 作者: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("调研任务结束");
    }
}

---

以前写的，若有时间会增加详细说明