项目背景：公司需求目前需要对接抖音 和 菜鸟，一期需求只做抖音菜鸟，后面会对接更多的，比如拼多多，得物等。

条条大路通罗马，代码都能实现，但如何更合理的实现，遵循设计模式，才是一个优秀的程序员该考虑的问题。作为一个 精益求精的程序员，工作几年之后，不应该只满足于单纯的实现需求，还应该追求代码的质量。

为了防止大家忘记前面文章写的设计模式，于是大家再复习一遍。

简单工厂模式，通过传递的参数来确定返回的对象是什么：

public class SimpleChickenFactory {

    /**
     * 通过传递的参数
     */
    public Chicken getChicken(String name){
        Chicken chicken = null;
        if(name.equals("CN")){
            chicken = new CNChicken();
        }else if(name.equals("USA")){
            chicken = new USAChicken();
        }
        return chicken;
    }

}

public class CNChicken extends Chicken{



}

这样写就不遵循开闭原则，每次新增一个的时候，都需要修改之前的代码，所以从设计的角度讲，肯定是有问题的，如何解决这个问题？

我们可以写一个创建对象类，然后用不同的工厂来实现这个抽象类，这样如果新增则直接新增工厂类。

public class USAChicken extends AllChicken{

    @Override
    public Chicken create(String name) {
        Chicken chicken = null;
        if(name.equals("KFC")){
            chicken = new KFCChicken();
        }else if(name.equals("MC")){
            chicken = new MCChicken();
        }
        return chicken;
    }
}


public class BJChicken extends AllChicken{

    @Override
    public Chicken create(String name) {
        Chicken chicken = null;
        if(name.equals("KFC")){
            chicken = new KFCChicken();
        }else if(name.equals("MC")){
            chicken = new MCChicken();
        }
        return chicken;
    }
}

当我们通过抽象类实现的时候，扩展性就更好了，但还是有缺陷，如果我们继续优化的话。

public class FactoryChicken extends AllChicken{

    public FactoryChicken(String address) {
        super(address);
    }

    @Override
    public Chicken create(String name) {
        Chicken chicken = null;
        if(name.equals("KFC")){
            chicken = new KFCChicken();
        }else if(name.equals("MC")){
            chicken = new MCChicken();
        }
        return chicken;
    }
}



public abstract class AllChicken implements ChickenInterface{

    private String address;

    public AllChicken(String address){
        this.address = address;
    }

}


public interface ChickenInterface {
    public Chicken create(String name);
}

这样扩展性就更好了，通过地址只需要入参就可以通过不同的地址实例化。

当以上实现之后，我们把项目需求代入抽象工厂模式，我们需要根据不同的商家来写不同的代码，遵循开闭原则，每个商家都有订购或者取消等功能，于是设计如下。

public class DYOrderFactory extends OrderFactory{

    public DYOrderFactory(String channel) {
        super(channel);
    }

    @Override
    public void order() {
        System.out.println("下单");
    }

    @Override
    public void cancel() {

    }
}


public abstract class OrderFactory implements OrderInterface{

    private String channel;

    public OrderFactory(String channel){
        this.channel = channel;
    }

    public String getChannel() {
        return channel;
    }
}


public interface OrderInterface {

    public void order();

    public void cancel();

}