设计模式学习（四）- 观察者模式

1.观察者模式表现形式

观察者模式又叫做发布-订阅（Publish/Subscribe）模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

2.观察者模式UML图

3.观察者模式实例

3.1 观察者抽象类

public abstract class ObServer {
    public abstract void update();
}

3.2 通知者抽象类

public abstract class Subject {

    private final List<ObServer> list = new LinkedList<>();

    public void attach(ObServer obServer) {
        list.add(obServer);
    }
    public void detach(ObServer obServer) {
        list.remove(obServer);
    }
    public void notifyObServer() {
        for (ObServer obServer : list) {
            obServer.update();
        }
    }
}

3.3 通知者实现类

public class ConcreteSubject extends Subject {
    private String subjectState;

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }
}

3.4 观察者实现类

public class ConcreteObServer extends ObServer {

    private String name;
    private String observerState;
    private ConcreteSubject concreteSubject;

    public ConcreteObServer(ConcreteSubject concreteSubject, String name) {
        this.name = name;
        this.concreteSubject = concreteSubject;
    }

    @Override
    public void update() {
        this.observerState = concreteSubject.getSubjectState();
        System.out.printf("观察者%s的新状态是%s%n", this.name, this.observerState);
    }
}

3.5 调用方法

public class TestOb {
    public static void main(String[] args) {
        ConcreteSubject concreteSubject = new ConcreteSubject();
        ConcreteObServer concreteObServer1 = new ConcreteObServer(concreteSubject, "A");
        ConcreteObServer concreteObServer2 = new ConcreteObServer(concreteSubject, "B");
        ConcreteObServer concreteObServer3 = new ConcreteObServer(concreteSubject, "C");
        concreteSubject.attach(concreteObServer1);
        concreteSubject.attach(concreteObServer2);
        concreteSubject.attach(concreteObServer3);
        concreteSubject.setSubjectState("哈哈哈");
        concreteSubject.notifyObServer();
    }
}

4.事件委托

此处引用文章https://blog.csdn.net/weixin_42794011/article/details/115694934
单纯的观察者模式，所影响的范围比较小，而且要求观察者必须存在同一个接口方法，所以为加强该模式，引入事件委托概念，通知者传递消息到委托方，委托方调用观察者方法
一个委托可以搭载多个方法， 所有方法被依次唤起。 更重要的是， 它可以使得委托对 象所搭载的方法井不需要属于同一个类。

4.1 自定义委托类

public class Event {
    // 要执行方法的对象
    private Object object;
    // 要执行的方法名称
    private String methodName;
    // 要执行方法的参数
    private Object[] params;
    // 要执行方法的参数类型
    private Class[] paramTypes;

    public Event(Object object, String methodName, Object...args) {
        this.params = args;
        this.object = object;
        convertParamsToParamsType();
        setMethodName(methodName);
    }

    private void setMethodName(String methodName) {
        if (methodName == null) {
            throw new IllegalArgumentException("method name err");
        }
        try {
            this.object.getClass().getMethod(methodName, this.paramTypes);
        } catch (NoSuchMethodException e) {
            try {
                this.object.getClass().getDeclaredMethod(methodName, this.paramTypes);
            } catch (NoSuchMethodException e1) {
                throw new RuntimeException(String.format("对象%s没有该参数类型%s的方法%s,e:%s",object.toString(), Arrays.toString(paramTypes),methodName,e));
            }
        }
        this.methodName = methodName;
    }

    private void convertParamsToParamsType() {
        if (this.params != null) {
            this.paramTypes = new Class[this.params.length];
            for (int i = 0; i < this.params.length; i++) {
                this.paramTypes[i] = this.params[i].getClass();
            }
        }
    }

    public void invoke() {
        try {
            Method method = this.object.getClass().getMethod(this.methodName, this.paramTypes);
            method.invoke(this.object, this.params);
        } catch (NoSuchMethodException e) {
            System.out.printf("对象%s没有该参数类型%s的方法%s,e:%s%n",object.toString(),Arrays.toString(paramTypes),methodName, e);
        } catch (IllegalAccessException e) {
            System.out.printf("对象%s参数类型为%s的%s方法不可访问,e:%s",object.toString(),Arrays.toString(paramTypes),methodName, e);
        } catch (InvocationTargetException e) {
            System.out.printf("对象%s参数类型为%s的%s方法执行错误,e:%s",object.toString(),Arrays.toString(paramTypes),methodName, e);
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Event)) {
            return false;
        }
        Event objEvent = (Event) obj;
        if (!objEvent.object.equals(this.object)) {
            return false;
        }
        if (!objEvent.methodName.equals(this.methodName)) {
            return false;
        }
        Class[] paramTypes = objEvent.paramTypes;
        Object[] params = objEvent.params;
        return parameterEquals(paramTypes, params);
    }

    private boolean parameterEquals(Class[] paramTypes, Object[] params) {
        if (this.paramTypes == null) {
            return paramTypes == null;
        }
        if (paramTypes == null || this.paramTypes.length != paramTypes.length) {
            return false;
        }
        for (int i = 0; i < this.paramTypes.length; i++) {
            if (!this.paramTypes[i].getName().equals(paramTypes[i].getName())) {
                return false;
            }
        }
        for (int i = 0; i < this.params.length; i++) {
            if (!this.params[i].equals(params[i])) {
                return false;
            }
        }
        return true;
    }

    @Override
    public int hashCode() {
        int h = this.object.hashCode() + this.methodName.hashCode();
        if (this.params != null && this.params.length > 0) {
            for (Object param : this.params) {
                if (param != null) {
                    h += param.hashCode();
                }
            }
        }
        return h;
    }
}

4.2 委托处理类

public class EventHandle {
    List<Event> events = new Vector<>();

    public synchronized void addEvent(Event event) {
        if (!events.contains(event)) {
            events.add(event);
        }
    }

    public synchronized void removeEvent(Event event) {
        events.remove(event);
    }

    public void notifyEvents() {
        if (events != null) {
            for (Event event : events) {
                event.invoke();
            }
        }
    }
}

4.3 通知抽象类

public abstract class EventSubject {

    private EventHandle eventHandle = new EventHandle();

    public void attach(Object obj, String methodName, Object...args) {
        Event event = new Event(obj, methodName, args);
        eventHandle.addEvent(event);
    }

    public void detach(Object obj, String methodName, Object...args) {
        Event event = new Event(obj, methodName, args);
        eventHandle.removeEvent(event);
    }

    public void notifyObservers() {
        eventHandle.notifyEvents();
    }
}

4.4 通知实现类

public class ConcreteEventSubject extends EventHandle {
    private String name;

    public ConcreteEventSubject(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

4.5 观察者实体类

public class SubjectOne {
    private String name;
    private ConcreteEventSubject concreteEventSubject;

    public SubjectOne(String name, ConcreteEventSubject concreteEventSubject) {
        this.name = name;
        this.concreteEventSubject = concreteEventSubject;
    }

    public void oneUpdate(String str) {
        System.out.println("通知者" + this.concreteEventSubject.getName() + "，观察者" + this.name + "的oneUpdate方法执行了,接收到的参数为:" + str);
    }
}

public class SubjectTwo {
    private String name;
    private ConcreteEventSubject concreteEventSubject;

    public SubjectTwo(String name, ConcreteEventSubject concreteEventSubject) {
        this.name = name;
        this.concreteEventSubject = concreteEventSubject;
    }

    public void twoUpdate(String str) {
        System.out.println("通知者" + this.concreteEventSubject.getName() + "，观察者" + this.name + "的twoUpdate方法执行了,接收到的参数为:" + str);
    }
}

4.6 调用类

public class TestEventOb {
    public static void main(String[] args) {
        ConcreteEventSubject concreteEventSubject = new ConcreteEventSubject("通知者米米");
        SubjectOne subjectOne = new SubjectOne("观察者1", concreteEventSubject);
        Event event = new Event(subjectOne, "oneUpdate", "喳喳");
        concreteEventSubject.addEvent(event);
        SubjectTwo subjectTwo = new SubjectTwo("观察者2", concreteEventSubject);
        Event event2 = new Event(subjectTwo, "twoUpdate", "你好菜吗");
        concreteEventSubject.addEvent(event2);
        concreteEventSubject.notifyEvents();
    }
}