设计模式-观察者模式与事件委托

一. 观察者模式

1.定义观察者

/**
 * 观察者接口
 * @author ck
 */
abstract class Observer{
    /** 观察者名称 */
    private String name;
    /** 构造函数，初始化观察者名称 */
    public Observer(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    /**
     * 观察者更新状态
     * @param subject 通知者
     * @param event 事件信息
     */
    public abstract void update(Subject subject, Object event);
}

/**
 * 具体观察者：打游戏的观察者
 * @author ck
 */
class GamingObserver extends Observer{
    /** 构造函数，初始化打游戏的观察者 */
    public GamingObserver(String name) {
        super(name);
    }
    /** 更新状态 */
    @Override
    public void update(Subject subject, Object event) {
        System.out.println(subject.getName()+":"+this.getName()+","+event+"别玩游戏了");
    }
}

/**
 * 具体的观察者：睡觉的观察者
 * @author ck
 */
class SleepObserver extends Observer{
    /** 构造函数，初始化睡觉的观察者名称 */
    public SleepObserver(String name) {
        super(name);
    }
    /** 更新状态 */
    @Override
    public void update(Subject subject, Object event) {
        System.out.println(subject.getName()+":"+this.getName()+","+event+",别睡觉了");
    }
}

2.定义通知者

/**
 * 通知者接口
 * @author ck
 */
abstract class Subject{
    /** 通知者名称 */
    private String name;
    /** 构造函数，初始化通知者名称 */
    public Subject(String name) {
        this.name = name;
    }
    /**
     * 添加观察者
     * @param observer 观察者
     */
    public abstract void addObserver(Observer observer);
    /**
     * 移除观察者
     * @param observer 观察者
     */
    public abstract void removeObserver(Observer observer);
    /**
     * 通知所有观察者
     * @param event 事件信息
     */
    public abstract void notifyAll(Object event);
    /**
     * 通知某一个观察者
     * @param event 事件信息
     * @param observer 观察者
     */
    public abstract void notify(Object event, Observer observer);

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

/**
 * 具体通知者
 * @author ck
 */
class ConcreteSubject extends Subject{
    /** 构造函数，初始化通知者名称 */
    public ConcreteSubject(String name) {
        super(name);
    }

    /** 观察者列表 */
    private List<Observer> observerList = new ArrayList<Observer>();

    /** 添加观察者 */
    @Override
    public void addObserver(Observer observer) {
        if(observer==null) new NullPointerException("添加的观察者不能为空！");
        if(!observerList.contains(observer)) observerList.add(observer);
    }

    /** 移除观察者 */
    @Override
    public void removeObserver(Observer observer) {
        observerList.remove(observer);
    }

    /** 通知所有观察者 */
    @Override
    public void notifyAll(Object event) {
        for (Observer observer : observerList) {
            observer.update(this, event);
        }
    }

    /** 通知某一个观察者 */
    @Override
    public void notify(Object event, Observer observer) {
        if(observer!=null) observer.update(this, event);
    }
}

3.运行测试

/**
 * 观察者模式
 * @author ck
 */
public class AbserverPattern {
    public static void main(String[] args) {
        //通知者
        ConcreteSubject concreteSubject = new ConcreteSubject("前台mm");
        //添加观察者
        concreteSubject.addObserver(new GamingObserver("小明"));
        concreteSubject.addObserver(new SleepObserver("大鹏"));
        concreteSubject.notifyAll("老板来了");
    }
}

4.运行结果

前台mm:小明,老板来了别玩游戏了
前台mm:大鹏,老板来了,别睡觉了

二. 事件委托
1.定义通知者

/**
 * 通知者
 * @author ck
 */
abstract class Notifier {
    /** 事件处理器 */
    private EventHandler eventHandler = new EventHandler();
    public EventHandler getEventHandler() {
        return eventHandler;
    }

    /**
     * 添加事件监听
     * @param object 执行的对象
     * @param methodName 执行方法的方法名
     * @param args 执行方法的参数
     */
    public abstract void addListener(Object object, String methodName, Object... args);
    /**
     * 通知所有观察者
     */
    public abstract void notifyX();
    /**
     * 通知某一个观察者
     * @param object
     */
    public abstract void notifySomeone(Object object);
}

/**
 * 具体的通知者
 * @author ck
 */
class GoodNotifier extends Notifier{
    @Override
    public void addListener(Object object, String methodName, Object... args) {
        EventHandler eventHandler = this.getEventHandler();
        eventHandler.addEvent(object, methodName, args);
    }

    @Override
    public void notifyX() {
        this.getEventHandler().notifyX();
    }

    @Override
    public void notifySomeone(Object object) {
        this.getEventHandler().notifySomeone(object);
    }
}

2.事件处理器

/**
 * 事件处理器
 * @author ck
 */
class EventHandler{
    /** 事件列表 */
    private List<Event> events;
    /** 构造函数，初始化事件处理器 */
    public EventHandler() {
        events = new ArrayList<Event>();
    }

    /**
     * 添加事件
     * @param object 观察者
     * @param methodName 观察者的更新方法
     * @param args  观察者更新方法的参数
     */
    public void addEvent(Object object, String methodName, Object... args){
        events.add(new Event(object, methodName, args));
    }

    /**
     * 通知所有观察者
     */
    public void notifyX(){
        for (Event event : events) {
            event.invoke();
        }
    }

    /**
     * 通知某一观察者
     * @param object
     */
    public void notifySomeone(Object object){
        for (Event event : events) {
            Object obj = event.getObject();
            if(obj.equals(object)){
                event.invoke();
            }
        }
    }
}

/**
 * 事件
 * @author ck
 */
class Event{
    /** 观察者 */   
    private Object object;   
    /** 观察者的更新方法 */   
    private String methodName;   
    /** 观察者更新方法的参数 */   
    private Object[] params;   
    /** 观察者更新方法的参数类型 */   
    private Class[] paramTypes;
    public Event(){   
    }   
    /** 构造函数 */
    public Event(Object object,String methodName,Object...args){   
        this.object=object;   
        this.methodName=methodName;   
        this.params=args;   
        contractParamTypes(this.params);   
    }   

    /** 根据参数数组生成参数类型数组 */
    private void contractParamTypes(Object[] params){ 
        if(params!=null && params.length>0){
            this.paramTypes=new Class[params.length];   
            for(int i=0;i<params.length;i++){   
                this.paramTypes[i]=params[i].getClass();   
            }   
        }
    }   

    /**
     * 通过反射执行方法
     */
    public void invoke() {
        try {
            Method method = object.getClass().getMethod(methodName, paramTypes);
            if(method!=null) method.invoke(object, params);
        } catch (Exception e) {
            e.printStackTrace();
        } 

    }

    /** 获取观察者 */
    public Object getObject() {
        return object;
    }
}

3.定义观察者

/**
 * 打游戏的观察者
 * @author ck
 */
class GamingListener{
    public void stopGaming(){
        System.out.println("关闭游戏，开始工作");
    }
}

/**
 * 睡觉的观察者
 * @author ck
 */
class SleepListener{
    public void wakeup(){
        System.out.println("醒过来，上个厕所，继续工作");
    }
}

4.运行测试

/**
 * 事件委托
 * @author ck
 */
public class EventNotifier {
    public static void main(String[] args) {
        //创建通知者
        GoodNotifier goodNotifier = new GoodNotifier();
        //创建观察者
        GamingListener gamingListener = new GamingListener();
        SleepListener sleepListener = new SleepListener();
        //指定观察者更新方法
        goodNotifier.addListener(gamingListener, "stopGaming");
        goodNotifier.addListener(sleepListener, "wakeup");
        //通知
        goodNotifier.notifySomeone(gamingListener);
        goodNotifier.notifySomeone(sleepListener);
//      goodNotifier.notifyX();
    }
}

5.运行结果

关闭游戏，开始工作
醒过来，上个厕所，继续工作

三.总结
未完待续…