观察者模式 + 中介者模式

定义为组合关系的产品和工厂，保证一个对象只能由固定的对象初始化的方法叫做Single Call，两者有相同的生命期：
Product 产品类

 // 带工厂的构建方法 
public Product(Factory, xxx...) {
    /* 工厂能否生产指定product的布尔值属性
    判断逻辑在product里定义，产品和工厂同时决定是否有生产权限，这种方式叫Single Call
    普通的工厂模式，可能只是工厂单方面授权生产产品
    */
   if (factory.canCreateProduct()) {
    this.xxx = xxx;
    ...
  } 
}

Factory 工厂类

private boolean canPermittedCreate = false;
// 起到桥梁的作用，将产品和事件衔接在一起
public Product createProduct() {
  Product p = new Product(this, ...);
  // 产生事件
  new ProductEvent(p, ProductEventType.ADD);
  return p;
}

// 删除逻辑 + 产生删除事件
public void abandonProduct(Product p) {
  new ProductEvent(...);
  p = null;
}

// 更新同理
public void editProduct(Product p, String xxx) {
  ...
}

public boolean canCreateProduct() {
  return canPermittedCreate
}

ProductEventType 产品的事件类型枚举
枚举自带单例模式，避免实例数量膨胀，同时存在线程安全的隐患（要尽量设计成无状态，检验的一种想法是多次调用返回同样的结果，这种线程问题适用于所有静态方法设计的考虑点；如果存在状态就需要加锁同步，这种情况下单例模式相比多实例会有性能问题）

enum EventType {
  ADD, DEL,EDIT;
}

ProductEvent 事件类

// 继承了Observable类
// 这个jdk提供的被观察者模式类，提供了localArr，synchronize，Vector等线程安全机制
class ProductEvent extends Observable {
  Product sourceProduct; // 事件发起方
  ProductEventType type; // 时间类型
  
  public ProductEvent(Product, ProductEventType) {
    this.source = product;
    this.type = type;
    notifyEventDispatch(); // 创建完事件后立即触发事件  
  }
  
  // 主要调用jdk提供的观察者模式流程
  private void notifyEventDispatch() {
    // 增加观察者
    super.addObserver(EventDispatch.getEvenetDispatchc());
    // 打开通知开关
    super.setChanged();
    // 通知观察者
    super.notifyObserver(source);
  }
}

EventDispatch

1. 作为观察者观察事件
2. 同时作为中介者分发事件
3. 管理事件处理者（观察到事件变化，分发事件给对应的处理者）

  //   实现jdk提供的观察者接口
class EventDispatch implements Observer {
  // 内部实例化了自己一个常量私有实例，单例模式
  private final static EventDispatch dispatch = new EventDispatch();
   // 事件消费者集合
  private Vector<EventConsumer> customer = new Vector<EventConsumer>(); 
  // 私有化构造方法，保证单例
  private EventDispatch() {}
  public static EventDispatch getEventDispatchc() {
    return dispatch; // 获取单例  
  }
  public void update(Observable o, Object arg) {
    ProductEvent event = (ProductEvent)o; // 获取事件对象
    // 这里的两层循环匹配，不是很好；一般做法是通过文件或者容器配置规则
    // 另外如果一个处理角色对应多个事件的情况，可以使用责任链模式（一个处理者有一个责任链属性，责任链上每个handler处理一种类型的事件）
    for (EventConsumer e : customer) {
      for (EventConsumeType t : e.getConsumeType()) {
        // 处理能力是否匹配
        if (t == event.getEventType) {
          e.exec(event); // 处理事件
        }
      }
    }
  }
  public void registerConsumer(EventConsumer consumer) {
    // 注册事件处理角色
    customer.add(consumer);
  }
}

EventConsumer 事件处理类

abstract class EventConsumer {
  // 能够处理的事件类型集合
  private Vector<EventConsumerType> customType =
    new Vector<EventConsumerType>();
  
  public void add(type) {
    customType.add(type);
  }
  
  abstract void exec(event);
}

事件处理实现类

Beggar extends EventConsumer {
   public Beggar() {
    // 硬编码该事件处理角色能够处理的事件类型
    super(EventType.DEL);
   }
}

例子

// 单例实例化
dispatch = EventDispatch.getEventDispatchc();
// 注册处理类
dispatch.registerConsumer(new Beggar());
factory = new Factory();
// 这一步会触发添加事件，交给添加事件的consumer处理
product = factory.createProduct(...);