观察者模式+事件委托(JAVA版)

观察者模式

1.定义

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

2.实现

使用JDK工具包实现

具体主题或具体通知者

package com.design.pattern.observer.jdk;

import java.util.Observable;

/**
 * Created by Administrator on 2021/4/14.
 * 具体主题或具体通知者
 */
public class ConcreteSubject extends Observable {
    public void changeState(){
        //改变状态
        this.setChanged();
        //通知所有观察者
        this.notifyObservers();
    }
}

具体观察者

package com.design.pattern.observer.jdk;

import lombok.Data;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;

import java.util.Observable;
import java.util.Observer;

/**
 * Created by Administrator on 2021/4/14.
 * 具体观察者
 */
@RequiredArgsConstructor
@Data
public class ConcreteObserver implements Observer {
    @NonNull
    private String name;
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(String .format("观察者%s收到了更新",name));
    }
}

测试

import org.junit.Test;
import com.design.pattern.observer.jdk.ConcreteSubject;
import com.design.pattern.observer.jdk.ConcreteObserver;

/**
 * Created by Administrator on 2021/4/14.
 */
public class ObserverTest {
    @Test
    public void testJDK(){
        //创建具体主题或具体通知者
        ConcreteSubject observable = new ConcreteSubject();
        //添加张三观察者
        observable.addObserver(new ConcreteObserver("张三"));
        //添加李四观察者
        observable.addObserver(new ConcreteObserver("李四"));
        //具体主题或具体通知者改变状态
        observable.changeState();
    }
}

结果

观察者李四收到了更新
观察者张三收到了更新

自定义实现

主题或抽象通知者

package com.design.pattern.observer.custom;

import java.util.List;
import java.util.Vector;

/**
 * Created by Administrator on 2021/4/14.
 * 主题或抽象通知者
 */
public abstract class CustomSubject {
    private List<CustomObserver> customObservers = new Vector<>();
    //增加观察者
    public synchronized void attach(CustomObserver customObserver){
        if (customObserver == null)
            throw new NullPointerException();
        if (!customObservers.contains(customObserver)) {
            customObservers.add(customObserver);
        }
    }
    //移除观察者
    public synchronized void detach(CustomObserver customObserver){
        customObservers.remove(customObserver);
    }
    //通知
    public void notifyObeservers(){
        for (int i = 0; i < customObservers.size(); i++) {
            CustomObserver customObserver = customObservers.get(i);
            customObserver.update();
        }
    }
}

抽象观察者

package com.design.pattern.observer.custom;

/**
 * Created by Administrator on 2021/4/14.
 * 抽象观察者
 */
public abstract class CustomObserver {
    public abstract void update();
}

具体的主题或通知者

package com.design.pattern.observer.custom;

/**
 * Created by Administrator on 2021/4/14.
 * 具体的主题或通知者
 */
public class ConcreteCustomSubject extends CustomSubject {

}

具体的观察者

package com.design.pattern.observer.custom;

import lombok.NonNull;
import lombok.RequiredArgsConstructor;

/**
 * Created by Administrator on 2021/4/14.
 * 具体的观察者
 */
@RequiredArgsConstructor
public class ConcreteCustomObeserver extends CustomObserver {
    @NonNull
    private String name;
    @NonNull
    private CustomSubject customSubject;
    @Override
    public void update() {
        System.out.println(String.format("观察者%s收到了通知",name));
    }
}

测试

    @Test
    public void testCustom(){
        //创建具体主题或具体通知者
        ConcreteCustomSubject concreteCustomSubject = new ConcreteCustomSubject();
        //添加张三观察者
        concreteCustomSubject.attach(new ConcreteCustomObeserver("张三",concreteCustomSubject));
        //添加李四观察者
        concreteCustomSubject.attach(new ConcreteCustomObeserver("李四",concreteCustomSubject));
        //具体主题或具体通知者通知所有观察者
        concreteCustomSubject.notifyObeservers();
    }

事件委托

1.定义

委托就是一种引用方法的类型。 一旦为委托分配了方法， 委托将与该方法具有完全相同的行为。 委托方法的使用可以像其他任何方法一样， 具有参数和返回值。 委托可以看作是对函数的抽象， 是函数的 ‘类 ’， 委托的实例将代表一个具体的函数。——出处《大话设计模式》
一个委托可以搭载多个方法， 所有方法被依次唤起。 更重要的是， 它可以使得委托对 象所搭载的方法井不需要属于同一个类。
在java中没有事件委托的概念，可以自己实现

2.实现

事件对象

package com.design.pattern.observer.event;

import lombok.Getter;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * Created by Administrator on 2021/4/14.
 * 事件对象，要执行方法的对象需重写hashCode和equals方法
 */
@Getter
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;
        convertParamsToParamTypes(this.params);
        setObject(object);
        setMethodName(methodName);
    }

    private void setMethodName(String methodName) {
        if(methodName==null||methodName.trim().length()==0){
            throw new IllegalArgumentException("methodName must be not null or empty string");
        }
        try {
            Method method=object.getClass().getMethod(methodName, this.getParamTypes());
        } catch (NoSuchMethodException e) {
            try {
                Method method = object.getClass().getDeclaredMethod(methodName, this.getParamTypes());
            } catch (NoSuchMethodException e1) {
                throw new RuntimeException(String.format("对象%s没有该参数类型%s的方法%s,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
            }
            throw new RuntimeException(String.format("对象%s参数类型为%s的%s方法不可访问,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
        }
        this.methodName=methodName.trim();
    }

    private void setObject(Object object) {
        if(object==null){
            throw new IllegalArgumentException("object must be not null");
        }
        this.object=object;
    }

    //根据参数数组生成参数类型数组
    private void convertParamsToParamTypes(Object[] params){
        if(params!=null) {
            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(this.getMethodName(), this.getParamTypes());
            method.invoke(this.getObject(), this.getParams());
        } catch (NoSuchMethodException e) {
            System.out.println(String.format("对象%s没有该参数类型%s的方法%s,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
        } catch (IllegalAccessException e) {
            System.out.println(String.format("对象%s参数类型为%s的%s方法不可访问,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
        } catch (InvocationTargetException e) {
            System.out.println(String.format("对象%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.getObject().equals(object)){
            return false;
        }
        if(!objEvent.getMethodName().equals(methodName)){
            return false;
        }
        Class[] objParamTypes = objEvent.getParamTypes();
        Object[] objParams = objEvent.getParams();
        return areParametersEqual(objParamTypes, objParams);
    }

    private boolean areParametersEqual(Class[] objParamTypes, Object[] objParams) {
        if(paramTypes==null){
            if(objParamTypes!=null) {
                return false;
            }
            return true;
        }
        if(objParamTypes ==null|| paramTypes.length!=objParamTypes.length){
            return false;
        }
        for (int i = 0; i < paramTypes.length; i++) {
            if(!paramTypes[i].getName().equals(objParamTypes[i].getName())){
                return false;
            }
        }
        //类型是根据传递的方法参数自动创建的，所以空和参数个数都是一致的，不需再判断
        for (int i = 0; i < params.length; i++) {
            if(!params[i].equals(objParams[i])){
                return false;
            }
        }
        return true;
    }

    @Override
    public int hashCode(){
        int h = object.hashCode() + methodName.hashCode();
        if(params!=null&&params.length>0){
            for (int i = 0; i < params.length; i++) {
                if(params[i]!=null){
                    h += params[i].hashCode();
                }
            }
        }
        return h;
    }
}

事件处理对象

package com.design.pattern.observer.event;

import java.util.*;

/**
 * Created by Administrator on 2021/4/14.
 * 事件处理对象
 */
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 (int i = 0; i < events.size(); i++) {
                events.get(i).invoke();
            }
        }
    }
}

抽象主题或通知

package com.design.pattern.observer.event;

/**
 * Created by Administrator on 2021/4/15.
 * 抽象主题或通知
 */
public abstract class AbstractSubject {
    private EventHandle eventHandle=new EventHandle();
    public void attatch(Object obj,String methodName,Object...args){
        eventHandle.addEvent(new Event(obj,methodName,args));
    }
    public void detach(Object obj,String methodName,Object...args){
        eventHandle.removeEvent(new Event(obj,methodName,args));
    }
    public void notifyObservers(){
        eventHandle.notifyEvents();
    }
}

具体主题或通知

package com.design.pattern.observer.event;

import lombok.NonNull;
import lombok.RequiredArgsConstructor;

/**
 * Created by Administrator on 2021/4/15.
 * 具体主题或者具体通知类
 */
@RequiredArgsConstructor
public class SubjectOne extends AbstractSubject {
    @NonNull
    private String name;
}

观察者1

package com.design.pattern.observer.event;

import lombok.*;

/**
 * Created by Administrator on 2021/4/15.
 * 具体观察者1,重写hashCode和equals方法
 */
@RequiredArgsConstructor
@EqualsAndHashCode
@ToString
public class ObserverOne {
    @NonNull
    private String name;
    public void oneUpdate(){
        System.out.println("通知到观察者"+name+"，观察者"+name+"的oneUpdate方法执行了");
    }
}

观察者2

package com.design.pattern.observer.event;

import lombok.EqualsAndHashCode;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.ToString;

/**
 * Created by Administrator on 2021/4/15.
 * 具体观察者2,重写hashCode和equals方法
 */
@RequiredArgsConstructor
@EqualsAndHashCode
@ToString
public class ObserverTwo {
    @NonNull
    private String name;
    public void twoUpdate(String str){
        System.out.println("通知到观察者"+name+"，观察者"+name+"的twoUpdate方法执行了,接收到的参数为:"+str);
    }
}

测试

    @Test
    public void testEventDelegation(){
        //创建具体主题或具体通知者
        SubjectOne subject = new SubjectOne("通知者1");
        //添加观察者张三
        ObserverOne objOne = new ObserverOne("张三");
        subject.attatch(objOne,"oneUpdate");
        subject.attatch(objOne,"oneUpdate");
        subject.attatch(new ObserverOne("张三"),"oneUpdate");
        //添加观察者李四
        ObserverTwo objTwo = new ObserverTwo("李四");
        subject.attatch(objTwo,"twoUpdate","你好");
        //具体主题或具体通知者通知所有观察者
        subject.notifyObservers();
        subject.detach(new ObserverOne("张三"),"oneUpdate");
        //subject.detach(new ObserverTwo("李四"),"twoUpdate");
        subject.notifyObservers();
    }

通知到观察者张三，观察者张三的oneUpdate方法执行了
通知到观察者李四，观察者李四的twoUpdate方法执行了,接收到的参数为:你好
通知到观察者李四，观察者李四的twoUpdate方法执行了,接收到的参数为:你好