工厂模式

之前做过一个需求，优化一下发送短信的代码逻辑，老代码中接入了大概有 6 个发送短信的渠道。老代码的逻辑设计的较为粗暴。

顶层接口：

public interface SmsProcess {
    boolean supportSms(SmsBean smsBean);
    boolean supportVoice(VoiceBean voiceBean);
    MQResult sendSms(SmsBean smsBean);
    MQResult sendVoice(VoiceBean voiceBean);
    boolean isAvailable(String phone);
    default String supplier() {
        return "default";
    }
}

各个渠道都有自己实现：

@Component
public class DaYuSmsProcess implements SmsProcess {
}
@Component
public class HLSmsProcess implements SmsProcess {
}
@Component("jzSmsProcess")
public class JZSmsProcess implements SmsProcess {
}

@Component
public class DaYuSmsFactory implements SmsFactory {
    @Autowired
    private DaYuSmsProcess daYuSmsProcess;
}
@Component
public class HLSmsFactory implements SmsFactory {
    @Autowired
    private HLSmsProcess hlSmsProcess;
}

老的代码中为每一中实现的渠道定义了一个工厂的实现。所以我认为 这样的工厂是一种假的实现。完全没有理解工厂 模式的特点，使用错误。

现在我进行一下改正。

@Service
public class SmsProcessFactory {
    @Autowired
    private List<SmsProcess> smsProcessList;
    private ConcurrentHashMap<String, SmsProcess> map = new ConcurrentHashMap();
    @PostConstruct
    public void init() {
        smsProcessList.forEach(w -> map.put(w.supplier(), w));
    }
    public SmsProcess getInstance(String type) {
        return map.get(type);
    }
    public List<SmsProcess> getInstances(Predicate<SmsProcess> predicate) {
        return smsProcessList.stream().filter(sms -> predicate.test(sms)).collect(Collectors.toList());
    }
//    public void testPredicate(){
//        List<SmsProcess> instances = getInstances((s) -> s.supportVoice(null));
//    }
}

第一个 getInstance 方法 通过关键字获得唯一的实现方式，第二个 getInstance 方法结合函数表达式 动态根据条件获取一组实现。

模板模式 lambda 的应用

场景，当遇到这样需求的时候： 有两种实现，这两种实现类中只有个方法不同，其他的方法都一样时，可以使用这个方法。

interface WorkflowManager{
  public default void doTask1(){
    System.out.println("Doing Task1...");
  }
  public void doTask2();
  public default void doTask3(){
    System.out.println("Doing Task3...");
  }
  public default void doTask4(){
    System.out.println("Doing Task4...");
  }
}

public class TemplateMethodPatternLambda {
  public static void main(String[] args) {
    /**
     * Using lambda expression to create different
     * implementation of the abstract workflow
     */
    initiateWorkFlow(()->System.out.println("Doing Task2.1..."));
    initiateWorkFlow(()->System.out.println("Doing Task2.2..."));
    initiateWorkFlow(()->System.out.println("Doing Task2.3..."));
  }
  static void initiateWorkFlow(WorkflowManager workflowMgr){
    System.out.println("Starting the workflow ...");
    workflowMgr.doTask1();
    workflowMgr.doTask2();
    workflowMgr.doTask3();
    workflowMgr.doTask4();
  }
}