JAVA设计模式第四讲：行为型设计模式

public interface Subject {
  void registerObserver(Observer observer);
  void removeObserver(Observer observer);
  void notifyObservers(Message message);
}
// 观察者接口
public interface Observer {
  void update(Message message);
} 
// 被观察者
public class ConcreteSubject implements Subject {
  private List<Observer> observers = new ArrayList<Observer>();
  @Override
  public void registerObserver(Observer observer) {
    observers.add(observer);
  } 
  @Override
  public void removeObserver(Observer observer) {
    observers.remove(observer);
  } 
  @Override
  public void notifyObservers(Message message) {
    for (Observer observer : observers) {
      // 会一直阻塞，直到所有观察者代码都执行完成
      observer.update(message);
    }
  }
}
// 观察者1
public class ConcreteObserverOne implements Observer {
  @Override
  public void update(Message message) {
    //TODO: 获取消息通知，执行自己的逻辑...
    System.out.println("ConcreteObserverOne is notified.");
  }
}
// 观察者2
public class ConcreteObserverOne implements Observer {
  @Override
  public void update(Message message) {
    //TODO: 获取消息通知，执行自己的逻辑...
    System.out.println("ConcreteObserverOne is notified.");
  }
}
public class Demo {
  public static void main(String[] args) {
    ConcreteSubject subject = new ConcreteSubject();
    // 接受实现了同一 Observer 接口的类对象
    subject.registerObserver(new ConcreteObserverOne());
    subject.registerObserver(new ConcreteObserverTwo());
    subject.notifyObservers(new Message());
  }
}

// 被观察者
public class UserController {
  private UserService userService; // 依赖注入
  private EventBus eventBus;
  private static final int DEFAULT_EVENTBUS_THREAD_POOL_SIZE = 20;
  public UserController() {
    //eventBus = new EventBus(); // 同步阻塞模式
    eventBus = new AsyncEventBus(Executors.newFixedThreadPool(DEFAULT_EVENTBUS_SIZE);// 异步非阻塞模式
  } 
  public void setRegObservers(List<Object> observers) {
    for (Object observer : observers) {
      // 它可以接受任何类型的观察者
      eventBus.register(observer);
    }
  }
  public Long register(String telephone, String password) {
    //省略输入参数的校验代码
    //省略userService.register()异常的try-catch代码
    long userId = userService.register(telephone, password);
    //用于给观察者发消息，规则：能接受的消息类型是发送消息类型的父类
    eventBus.post(userId);
    return userId;
  }
}
// 观察者1，任意类型的对象都可以注册到 eventBus 中
public class RegPromotionObserver {
  private PromotionService promotionService; // 依赖注入
  // eventBus 会根据该注解找到方法，将方法能接收到的消息类型记录下来
  @Subscribe
  public void handleRegSuccess(long userId) {
    promotionService.issueNewUserExperienceCash(userId);
  }
}
// 观察者2
public class RegNotificationObserver {
  private NotificationService notificationService;
  @Subscribe
  public void handleRegSuccess(long userId) {
    notificationService.sendInboxMessage(userId, "...");
  }
}

public abstract class AbstractClass {
  // 定义为final，避免子类重写，实际开发中并不是必须的
  public final void templateMethod() {
    //...
    method1();
    //...
    method2();
    //...
  } 
  // 拓展点1
  protected abstract void method1();
  // 拓展点2
  protected abstract void method2();
}
public class ConcreteClass1 extends AbstractClass {
  @Override
  protected void method1() {
    //...
  } 
  @Override
  protected void method2() {
    //...
  }
} 
public class ConcreteClass2 extends AbstractClass {
  @Override
  protected void method1() {
    //...
  } 
  @Override
  protected void method2() {
    //...
  }
} 
// 使用
AbstractClass demo = ConcreteClass1();
demo.templateMethod();

public boolean addAll(int index, Collection<? extends E> c) {
  rangeCheckForAdd(index);
  boolean modified = false;
  for (E e : c) {
    add(index++, e);
    modified = true;
  }
  return modified;
} 
public void add(int index, E element) {
  throw new UnsupportedOperationException();
}

public class HelloServlet extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    this.doPost(req, resp);
  }
  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throw Exception {
    resp.getWriter().write("Hello World.");
  }
}

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
  HttpServletRequest request;
  HttpServletResponse response;
  if (!(req instanceof HttpServletRequest && res instanceof HttpServletResponse)) {
    throw new ServletException("non-HTTP request or response");
  }
  request = (HttpServletRequest) req;
  response = (HttpServletResponse) res;
  service(request, response);
}
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  String method = req.getMethod();
  if (method.equals(METHOD_GET)) {
    long lastModified = getLastModified(req);
    if (lastModified == -1) {
      // servlet doesn't support if-modified-since, no reason
      // to go through further expensive logic
      doGet(req, resp);
    } else {
      long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
      if (ifModifiedSince < lastModified) {
        // If the servlet mod time is later, call doGet()
        // Round down to the nearest second for a proper compare
        // A ifModifiedSince of -1 will always be less
        maybeSetLastModified(resp, lastModified);
        doGet(req, resp);
      } else {
        resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
      }
    }
  } else if (method.equals(METHOD_HEAD)) {
    long lastModified = getLastModified(req);
    maybeSetLastModified(resp, lastModified);
    doHead(req, resp);
  } else if (method.equals(METHOD_POST)) {
    doPost(req, resp);
  } else if (method.equals(METHOD_PUT)) {
    doPut(req, resp);
  } else if (method.equals(METHOD_DELETE)) {
    doDelete(req, resp);
  } else if (method.equals(METHOD_OPTIONS)) {
    doOptions(req,resp);
  } else if (method.equals(METHOD_TRACE)) {
    doTrace(req,resp);
  } else {
    String errMsg = lStrings.getString("http.method_not_implemented");
    Object[] errArgs = new Object[1];
    errArgs[0] = method;
    errMsg = MessageFormat.format(errMsg, errArgs);
    resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  }
}

public interface ICallback {
  void methodToCallback();
} 
public class BClass {
  public void process(ICallback callback) {
    //...
    callback.methodToCallback();
    //...
  }
}
public class AClass {
  public static void main(String[] args) {
    BClass b = new BClass();
    // 在 process 返回之前执行了回调函数，属同步回调
    // 如果是不需要等待回调函数被调用就返回，属于异步回调
    b.process(new ICallback() { //回调对象
      @Override
      public void methodToCallback() {
        System.out.println("Call back me.");
      }
    });
  }
}

public class JdbcTemplateDemo {
  private JdbcTemplate jdbcTemplate;
  public User queryUser(long id) {
    String sql = "select * from user where id=" + id;
    return jdbcTemplate.query(sql, new UserRowMapper()).get(0);
  } 
  class UserRowMapper implements RowMapper<User> {
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
      User user = new User();
      user.setId(rs.getLong("id"));
      user.setName(rs.getString("name"));
      user.setTelephone(rs.getString("telephone"));
      return user;
    }
  }
}

public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
  public <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException {
        return (List)result(this.query((String)sql, (ResultSetExtractor)(new RowMapperResultSetExtractor(rowMapper))));
    }
    @Nullable
    public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException {
        Assert.notNull(sql, "SQL must not be null");
        Assert.notNull(rse, "ResultSetExtractor must not be null");
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Executing SQL query [" + sql + "]");
        }
        // 可变部分放到了 StatementCallback
        class QueryStatementCallback implements StatementCallback<T>, SqlProvider {
            QueryStatementCallback() {
            }
            @Nullable
            public T doInStatement(Statement stmt) throws SQLException {
                ResultSet rs = null;
                Object var3;
                try {
                    rs = stmt.executeQuery(sql);
                    var3 = rse.extractData(rs);
                } finally {
                    JdbcUtils.closeResultSet(rs);
                }
                return var3;
            }
            public String getSql() {
                return sql;
            }
        }
        // 不变部分放到了 execute() 中
        return this.execute((StatementCallback)(new QueryStatementCallback()));
    }
  @Nullable
    public <T> T execute(StatementCallback<T> action) throws DataAccessException {
        Assert.notNull(action, "Callback object must not be null");
        Connection con = DataSourceUtils.getConnection(this.obtainDataSource());
        Statement stmt = null;
        Object var11;
        try {
            stmt = con.createStatement();
            this.applyStatementSettings(stmt);
            T result = action.doInStatement(stmt);
            this.handleWarnings(stmt);
            var11 = result;
        } catch (SQLException var9) {
            String sql = getSql(action);
            JdbcUtils.closeStatement(stmt);
            stmt = null;
            DataSourceUtils.releaseConnection(con, this.getDataSource());
            con = null;
            throw this.translateException("StatementCallback", sql, var9);
        } finally {
            JdbcUtils.closeStatement(stmt);
            DataSourceUtils.releaseConnection(con, this.getDataSource());
        }
        return var11;
    }
}

public class ShutdownHookDemo {
  private static class ShutdownHook extends Thread {
  public void run() {
    System.out.println("I am called during shutting down.");
  }
  } 
  public static void main(String[] args) {
    Runtime.getRuntime().addShutdownHook(new ShutdownHook());
  }
}
public class Runtime {
  public void addShutdownHook(Thread hook) {
  SecurityManager sm = System.getSecurityManager();
  if (sm != null) {
    sm.checkPermission(new RuntimePermission("shutdownHooks"));
  }
  ApplicationShutdownHooks.add(hook);
  }
} 
// 当应用程序关闭的时候，JVM 会调用这个类的 runHooks() 方法，创建多个线程，并发地执行多个 Hook
class ApplicationShutdownHooks {
  /* The set of registered hooks */
  private static IdentityHashMap<Thread, Thread> hooks;
  static {
    try {
            Shutdown.add(1 /* shutdown hook invocation order */,
                false /* not registered if shutdown in progress */,
                new Runnable() {
                    public void run() {
                        runHooks();
                    }
                }
            );
            hooks = new IdentityHashMap<>();
        } catch (IllegalStateException e) {
            // application shutdown hooks cannot be added if
            // shutdown is in progress.
            hooks = null;
        }
    }
  static synchronized void add(Thread hook) {
    if(hooks == null)
      throw new IllegalStateException("Shutdown in progress");
    if (hook.isAlive())
      throw new IllegalArgumentException("Hook already running");
    if (hooks.containsKey(hook))
      throw new IllegalArgumentException("Hook previously registered");
    hooks.put(hook, hook);
  } 
  static void runHooks() {
    Collection<Thread> threads;
    synchronized(ApplicationShutdownHooks.class) {
      threads = hooks.keySet();
      hooks = null;
    } 
    for (Thread hook : threads) {
      hook.start();
    }
    for (Thread hook : threads) {
      while (true) {
        try {
          hook.join();
          break;
        } catch (InterruptedException ignored) {
        }
      }
    }
  }
}

public class ProtocolChangeService {
  public double change(Order order) {
    ChangeType type = ChangeType.getType();
    if (type.equals(itemShelf)) { 
      // 商品上架
    } else if (type.equals(itemUnShelf)) { 
      // 商品下架
    } else if (type.equals(itemUnfreeze)) { 
      // 商品解冻
    }
    // 处理业务逻辑
  }
}

public interface ProtocolChangeStrategy {
    /**
     * @param items           商品
     * @param changeType      变更类型
     */
    void associateItemChange(List<Item> items, Byte changeType);
}

@Component
public class ItemShelfStrategy implements ProtocolChangeStrategy {
   @Override
    public void associateItemChange(List<Item> agItems, Byte changeType) {
    // todo   业务逻辑
    }
}
@Component
public class ItemUnShelfStrategy implements ProtocolChangeStrategy {
   @Override
    public void associateItemChange(List<Item> agItems, Byte changeType) {
    // todo   业务逻辑
    }
}

// 消除if/else的关键代码，定义了一个StrategyHolder 来当做工厂类
@Component
public class StrategyHolder {
    // 关键功能 Spring 会自动将 EntStrategy 接口的类注入到这个Map中
    @Autowired
    private Map<String, ProtocolChangeStrategy> strategyMap;
    public ProtocolChangeStrategy getBy(String entNum) {
        return strategyMap.get(entNum);
    }
}

public static void main(String[] args) {
  // 在代码中指定使用哪种策略
  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
    context.getBean(StrategyHolder.class).getBy("itemShelfStrategy").associateItemChange("","");
}

@Component
@EnableConfigurationProperties
@ConfigurationProperties(prefix = "ent")
public class EntAlias {
    private HashMap<String, String> aliasMap;
    public static final String DEFAULT_STATEGY_NAME = "defaultStrategy";
    public HashMap<String, String> getAliasMap() {
        return aliasMap;
    }
    public void setAliasMap(HashMap<String, String > aliasMap) {
        this.aliasMap = aliasMap;
    }
    String of(String entNum) {
        return aliasMap.get(entNum);
    }
}

ent:
  aliasMap:
    entA: entAStrategy
    entB: entBStrategy

@Component
public class ProtocolChangeStrategy {
    @Autowired
    private EntAlias entAlias;
    // 关键功能 Spring 会自动将 EntStrategy 接口的类注入到这个Map中
    @Autowired
    private Map<String, ProtocolChangeStrategy> strategyMap;
    // 找不到对应的策略类，使用默认的
    public ProtocolChangeStrategy getBy(String entNum) {
        String name = entAlias.of(entNum);
        if (name == null) {
            return strategyMap.get(EntAlias.DEFAULT_STATEGY_NAME);
        }
        ProtocolChangeStrategy strategy = strategyMap.get(name);
        if (strategy == null) {
            return strategyMap.get(EntAlias.DEFAULT_STATEGY_NAME);
        }
        return strategy;
    }
}

/**
  * 商品下架策略
  * 只有一个方法的接口，可被定义为函数接口
  */
@FunctionalInterface
private interface UnderStrategy {
    void underItem(List<AgSearchItem> agItems , String brandName , String showReason);
}

/**
  * 策略1：下架并且撤回在途审核
  */
private UnderStrategy UNDER_AND_REJECT = (agItems , brandName , showReason) -> {
        if (CollectionUtils.isEmpty(agItems)) {
            return;
        }
        toUnderItem(agItems, true,brandName , showReason);
};
 /**
  * 策略2：仅下架无在途审核
  */
 private UnderStrategy UNDER_NO_AUDIT = (agItems , brandName , showReason) -> {
        if (CollectionUtils.isEmpty(agItems)) {
            return;
        }
        List<AgSearchItem> noAuditItems = agItems.stream()
            .filter(agItem -> Objects.equals(agItem.getAuditStatus(), ImGoodsMapperAuditStateEnum.NORMAL.getCode()))
            .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(noAuditItems)) {
            return;
        }
        toUnderItem(noAuditItems, false,brandName , showReason);
};

public interface SensitiveWordFilter {
  boolean doFilter(Content content);
}
public class SexyWordFilter implements SensitiveWordFilter {
  @Override
  public boolean doFilter(Content content) {
    boolean legal = true;
    //...
    return legal;
  }
}
// PoliticalWordFilter、AdsWordFilter类代码结构与SexyWordFilter类似
public class SensitiveWordFilterChain {
  private List<SensitiveWordFilter> filters = new ArrayList<>();
  public void addFilter(SensitiveWordFilter filter) {
    this.filters.add(filter);
  }
  //return true if content doesn't contain sensitive words.
  public boolean filter(Content content) {
    for(SensitiveWordFilter filter : filters) {
      if(!filter.doFilter(content)){
        return false;
      }
    }
    return true;
  }
}
public class ApplicationDemo {
  public static void main(String[] args) {
    SensitiveWordFilterChain filterChain = new SensitiveWordFilterChain();
    filterChain.addFilter(new AdsWordFilter());
    filterChain.addFilter(new SexyWordFilter());
    filterChain.addFilter(new PoliticalWordFilter());
    boolean legal = filterChain.filter(new Content());
    if(!legal) {
      //不发表
    } else {
      // 发表
    }
  }
}

// 设计的不友好，破坏了规则引擎，既要保证性能又要满足审核时去掉校验规则，所以只能硬编码处理
// 只有申请变更才会走handleInboundAuditData逻辑，审核单独走自己的校验规则
// 校验数据,一旦数据不合法, 会抛出异常
//* 重要: 可以根据需求而定是否抛出异常,
//* 例如可能的需求有:
//* 1.忽略或者过滤用户提交的无效数据
//* 2. 可以处理用户提交的数据, 比如修正或者添加更多的信息
if(Objects.nonNull(auditState) && Objects.equals(GoodsAuditStateEnum.IN_UPDATE.getCode(),auditState)){
    ruleEngine.handleInboundAuditData(newFullItem, null);
}else {
    ruleEngine.handleInboundData(newFullItem, null);
}

//* 规则引擎在处理数据输出时会调用这个方法 (例如用户查询商品/spu, 或者进入编辑商品/spu的界面)
//* 处理数据, 如果数据不合法, 不会抛出异常, 而是根据规则做相应的修正
//* 目前的策略是, 根据规则本身来修正或者过滤, 或者添加信息,  也可以根据需要抛出异常
 public <T extends BaseInput> void handleOutboundData(T input, BaseOutput output) {
    for (GeneralRuleExecutor ruleExecutor : ruleExecutorPipeline.getRuleExecutors()) {
        ruleExecutor.handleOutboundData(input, output, propertyBusinessTagCode);
    }
}

public class Order {
    public static  void  main(String [] args) {
        // 关于订单状态的事情，大家有没有这样判断过
        String stateName = getStateName(1);
        System.out.println(stateName);
    }
    /**
     * @method  getStateName
     * @description 获取订单状态的方法
     *              订单状态1、已下单2、已付款3、已发货4、送货中5、确认收货
     * @date: 2018/12/19 22:04
     * @author: Ni Shichao
     * @param status 状态
     * @return
     */
    public  static  String getStateName (int status) {
        String stateName = "" ;
        if (status == 1) {
            stateName = "已下单";
        } else if (status == 2) {
            stateName = "已付款";
        } else if (status == 3) {
            stateName = "已发货";
        } else if (status == 4) {
            stateName = "送货中";
        } else if (status == 5) {
            stateName = "确认收货";
        }
        return stateName;
    }
}

// 1、定义state接口
public interface State {
    void handle();
}
// 2、定义一个环境类来维护State接口 
public class Context {
    private State state;
    // 无参构造
    public Context() {}
  // 有参构造
    public Context(State state) {
        this.state = state;
    }
    public void setState(State state) {
        System.out.println("订单信息已更新！");
        this.state = state;
        this.state.handle();
    }
}
// 3、具体状态角色  ConcreteState
public class Booked implements  State {
    @Override
    public void handle() {
        System.out.println("您已下单！");
    }
}
//4、测试类
public class Client {
    public static  void  main(String [] args) {
        Context context = new Context();
        context.setState(new Booked());
        context.setState(new Payed());
        context.setState(new Sended());
        context.setState(new InWay());
        context.setState(new Recieved());
    }
}

订单信息已更新！
您已下单！
订单信息已更新！
您已付款！
订单信息已更新！
已发货！
订单信息已更新！
送货中。。。
订单信息已更新！
已确认收货！

// 状态机的定义
public class ItemFSM {
    // 事件
    private enum Trigger {
        APPLY_ONSHELF,  // 申请上架
        APPLY_UNFREEZE,  // 申请解冻
        UNFREEZE,         // 解冻
        CANCEL_AUDIT,    // 撤销审核
        FREEZE    // 撤销审核
    }
    private final StateMachine<ItemStatus, Trigger> stateMachine;
    public ItemFSM(ItemStatus status) throws Exception {
        this.stateMachine = new StateMachine<>(status);
        /** * 【冻结】---(申请解冻)---> 【解冻审核中】*/
        stateMachine.Configure(ItemStatus.FROZEN)
                .Permit(Trigger.APPLY_UNFREEZE, ItemStatus.WAIT_UNFREEZE);
        /*** 【解冻审核中】---(解冻)---> 【下架】*/
        stateMachine.Configure(ItemStatus.WAIT_UNFREEZE)
                .Permit(Trigger.UNFREEZE, ItemStatus.UNDERSHELF);
        /*** 【待审核】---(取消审核)---> 【下架】*/
        stateMachine.Configure(ItemStatus.AUDITWAIT)
                .Permit(Trigger.CANCEL_AUDIT, ItemStatus.UNDERSHELF);
        /*** 【上架】---(冻结)---> 【冻结中】*/
        stateMachine.Configure(ItemStatus.ONSHELF)
                .Permit(Trigger.FREEZE, ItemStatus.FROZEN);
        /*** 【下架】---(申请上架)---> 【审核中】*/
        stateMachine.Configure(ItemStatus.UNDERSHELF)
                .Permit(Trigger.APPLY_ONSHELF, ItemStatus.AUDITWAIT);
        /** * 【审核失败】---(申请上架)---> 【审核中】*/
        stateMachine.Configure(ItemStatus.AUDITREJECT)
                .Permit(Trigger.APPLY_ONSHELF, ItemStatus.AUDITWAIT);
    }
    /*** 获取状态机当前状态*/
    public ItemStatus getCurrentState() {
        return stateMachine.getState();
    }
    /** * 申请上架*/
    public void applyOnshelf() throws StateMachineException {
        try {
            stateMachine.Fire(Trigger.APPLY_ONSHELF);
        } catch (Exception e) {
            log.warn("item audit failed", e);
            throw new StateMachineException("item audit statemachine trigger apply unfreeze.");
        }
    }
    ...
}
// 状态机的使用
ItemStatus originalStatus = ItemStatus.from(blockItem.getStatus());
ItemFSM fsm = new ItemFSM(originalStatus);
fsm.applyOnshelf();
ItemStatus newStatus = fsm.getCurrentState();
...