定义为组合关系的产品和工厂，保证一个对象只能由固定的对象初始化的方法叫做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
- 作为观察者观察事件
- 同时作为中介者分发事件
- 管理事件处理者（观察到事件变化，分发事件给对应的处理者）
// 实现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(...);
