异步非阻塞的观察者模式框架实现---EventBus

一.普通版本的观察者模式

以下是观察者模式的模板，这里就不展开解释了

public interface Observer {
    void print(String msg);
}
//被观察者1
public class ConcreteObserverOne implements Observer {
    public void print(String msg) {
        System.out.println(this.getClass().getName() + " say: " + msg);
    }
}
//被观察者2
public class ConcreteObserverTwo implements Observer {
    public void print(String msg) {
        System.out.println(this.getClass().getName() + " say: " + msg);
    }
}
//被观察者3
public class ConcreteObserverThree implements Observer {
    @Override
    public void print(String msg) {
        System.out.println(this.getClass().getName() + " say: " + msg);
    }
}

public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notify(String msg);
}
//观察者
public class ConcreteSubject implements Subject{
    HashSet<Observer> set = new HashSet<>();
    @Override
    public void attach(Observer observer) {
        set.add(observer);
    }
    @Override
    public void detach(Observer observer) {
        set.remove(observer);
    }
    @Override
    public void notify(String msg) {
        for (Observer observer : set) {
            observer.print(msg);
        }
    }
}
//测试
public class Demo {
    public static void main(String[] args) {
        Subject concreteSubject = new ConcreteSubject();
        concreteSubject.attach(new ConcreteObserverOne());
        concreteSubject.attach(new ConcreteObserverTwo());
        concreteSubject.attach(new ConcreteObserverThree());
        concreteSubject.notify("hello!!!");
    }
}
//输出
ConcreteObserverTwo say: hello!!!
ConcreteObserverOne say: hello!!!
ConcreteObserverThree say: hello!!!

二.需求分析

1.基本需求

根据上述的基本模板，可以归纳出观察者模式的几个基本需求：

（1）attach（）或者是register（），注册被观察者的动作

（2）notify（）或者是post（），通知被观察者的动作

（3）注册表，存储所有被观察者的数据结构

（4）观察者类，包含1、2两个动作和3的数据结构的类

基于上述的需求，其实就是ConcreteSubject的实现

 

2.进阶需求

现在在上述基本需求的基础上提出进阶的需求：

（1）register（）的粒度细化到方法，而不是对象

（2）异步非阻塞的通知

 

3.需求分析

别看只有一个进阶需求，但是要改的地方真的不少：

（1）注册的时候，怎么标识哪些方法需要注册？

答：可以使用自定义注解标注

 

（2）post（）的实现中可以看到是对统一接口的调用（因为所有子类都继承了父类的print方法），但是当注册的粒度细化到方法，如何统一调用这些方法？

答：根据入参类型判断，post的入参传递给所有方法入参是其类或者父类的方法，这么说有些拗口，举个例子

register（）注册了两个方法，method1（Bclass b）和method2（Cclass c），method1和method2的入参分别是Bclass和Cclass。

post（Aclass a）方法的入参类型是Aclass，且Aclass是Bclass的子类。

那么入参a最终会调用method1而不会调用method2。

 

（3）注册表不仅仅存储对象

答：它的数据结构应该是这样的Map<ParamType, <Object, Method>>

其中ParamType就是入参类型，Object是注册对象，Method是注册方法

 

（4）关于异步非阻塞的问题其实很好解决，只需要开辟一个线程池异步进行方法调用即可

 

三.进阶版本的观察者模式

（1）首先是自定义注解，其实这只是一个标识，没有什么别的作用

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Bean
public @interface Subscribe {}

（2）注册表的设计

private ConcurrentMap<Class<?>, CopyOnWriteArraySet<ObserverAction>> registry = new ConcurrentHashMap<>();
public class ObserverAction {
    private Object target;
    private Method method;

    public ObserverAction(Object target, Method method) {
        this.target = Preconditions.checkNotNull(target);
        this.method = method;
        this.method.setAccessible(true);
    }

    public void execute(Object event) { // event是method方法的参数
        try {
            method.invoke(target, event);
        } catch (InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

（3）register的设计

public class ObserverRegistry {
    private ConcurrentMap<Class<?>, CopyOnWriteArraySet<ObserverAction>> registry = new ConcurrentHashMap<>();

    public void register(Object observer) {
        Map<Class<?>, Collection<ObserverAction>> observerActions = findAllObserverActions(observer);
        for (Map.Entry<Class<?>, Collection<ObserverAction>> entry : observerActions.entrySet()) {
            Class<?> eventType = entry.getKey();
            Collection<ObserverAction> eventActions = entry.getValue();
            CopyOnWriteArraySet<ObserverAction> registeredEventActions = registry.get(eventType);
            if (registeredEventActions == null) {
                registry.putIfAbsent(eventType, new CopyOnWriteArraySet<>());
                registeredEventActions = registry.get(eventType);
            }
            registeredEventActions.addAll(eventActions);
        }
    }
    
    //构建类的注册表
    private Map<Class<?>, Collection<ObserverAction>> findAllObserverActions(Object observer) {
        Map<Class<?>, Collection<ObserverAction>> observerActions = new HashMap<>();
        Class<?> clazz = observer.getClass();
        for (Method method : getAnnotatedMethods(clazz)) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            Class<?> eventType = parameterTypes[0];
            if (!observerActions.containsKey(eventType)) {
                observerActions.put(eventType, new ArrayList<>());
            }
            observerActions.get(eventType).add(new ObserverAction(observer, method));
        }
        return observerActions;
    }
    
    //获取类的注解方法
    private List<Method> getAnnotatedMethods(Class<?> clazz) {
        List<Method> annotatedMethods = new ArrayList<>();
        for (Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(Subscribe.class)) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                Preconditions.checkArgument(parameterTypes.length == 1,
                        "Method %s has @Subscribe annotation but has %s parameters."
                                + "Subscriber methods must have exactly 1 parameter.",
                        method, parameterTypes.length);
                annotatedMethods.add(method);
            }
        }
        return annotatedMethods;
    }
}

（3）post的设计

public class EventBus {
    private Executor executor;
    private ObserverRegistry registry = new ObserverRegistry();

    public EventBus() {
        this(MoreExecutors.directExecutor());
    }

    protected EventBus(Executor executor) {
        this.executor = executor;
    }

    public void register(Object object) {
        registry.register(object);
    }

    public void post(Object event) {
        List<ObserverAction> observerActions = registry.getMatchedObserverActions(event);
        for (ObserverAction observerAction : observerActions) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    observerAction.execute(event);
                }
            });
        }
    }
}

（4）测试

public class Fish {
    @Subscribe
    public void bubble(Integer a){
        System.out.println("fish:" + a);
    }
}
public class Dog {
    @Subscribe
    public void wang(String a){
        System.out.println("dog:" + a);
    }
}
public class Cat {
    @Subscribe
    public void miao(String a){
        System.out.println("cat:" + a);
    }
}
public class Demo {
    public static void main(String[] args) {
        EventBus eventBus = new AsyncEventBus(Executors.newFixedThreadPool(10));
        eventBus.register(new Dog());
        eventBus.register(new Cat());
        eventBus.register(new Fish());

        eventBus.post("test");
    }
}
//结果（因为post的入参是String，而只有Cat和Dog的方法入参是String）
dog:test
cat:test

 

参考资料：《设计模式之美》---王争