一文分清Java开发中容易混淆的四大设计模式

public interface TransportToolFactory {
   TransportTool createTool();
}

public class TruckTransportToolFactory implements TransportToolFactory {
   @Override
   public TransportTool createTool() {
       ...
   }
}

public class BoatTransportToolFactory implements TransportToolFactory {
   @Override
   public TransportTool createTool() {
       ...
   }
}

public class Transport {
   private TransportToolFactory factory;
   
   public Transport(int way) {
       if (way == 0) {
           factory = new TruckTransportToolFactory();
       }
       ...
   }
   
   public void transport() {
       TransportTool tool = factory.createTool();
       // 继续业务处理
}
}

public void transport() {
   int way = getWay();// 经过计算也好，前端传过来也好，反正得到了具体的运输方式
   TransportTool tool = new TransportToolFactory(way).createTool();
   // 继续业务处理
}

public TransportTool createTool() {
   if (way == 0) {
       // 货车
   }
   ...
}

public class CallBack {
   public void callback1(Param param) {
       // 查询审批记录的合法性

       // 修改审批记录

       // 处理业务逻辑1
   }
   public void callback1(Param param) {
       // 查询审批记录的合法性

       // 修改审批记录

       // 处理业务逻辑2
}
   ......
}

public class CallBack {
   private Strategy strategy = new Strategy();
   public void callback(Param param) {
       // 查询审批记录的合法性
       
       // 修改审批记录
       
       // 处理业务逻辑
       strategy.getHandle(param.getServiceName()).invokeHandle();
   }
}
public class Strategy {
   private Map<String, Iservice> map;
   
   static {
       map = new HashMap<String, Iservice>();
       map.put("Service1", new Service1());
       map.put("Service2", new Service2());
       ......
   }
   
   public Iservice getHandle(String serviceName) {
       return map.get(serviceName);
   }
}
public class Service1 implements Iservice {
   @Override
   public void invokeHandle() {
       ...
   }
}
public class Service2 implements Iservice {
   @Override
   public void invokeHandle() {
       ...
   }
}
......

/**
* Extended variant of the standard {@link ApplicationListener} interface,
* exposing further metadata such as the supported event and source type.
*
* <p>As of Spring Framework 4.2, this interface supersedes the Class-based
* {@link SmartApplicationListener} with full handling of generic event types.
*
* @author Stephane Nicoll
* @since 4.2
* @see SmartApplicationListener
* @see GenericApplicationListenerAdapter
*/
public interface GenericApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {
   ...

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
   // 我们都知道 spring 的广播事件都是是用了这个接口，我们看下 spring 是怎么做兼容的
   @Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
Executor executor = getTaskExecutor();
       // 重点在这 getApplicationListeners(event, type)，看看他们是怎么 get 这个 list 的
       // getApplicationListeners 是父类 AbstractApplicationEventMulticaster 的方法
for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
if (executor != null) {
executor.execute(() -> invokeListener(listener, event));
}
else {
invokeListener(listener, event);
}
}
}
}

protected boolean supportsEvent(
     ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {
  // 这里先看下这个 listener 是不是 GenericApplicationListener 的子类
  // 不是就转化成 GenericApplicationListener，这样以前 ApplicationListener 的子类就能被兼容了
  GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
        (GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
  return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
}