Java 工厂设计模式

简介

工厂设计模式在java中有大量的应用，如spring框架，这种类型的设计模式属于创建型模式。在工厂设计模式中，创建逻辑不会对客户端暴露，可以通过一个对外接口创建所需对象。

工厂模式使用场景

需要频繁创建对象且这些对象多处使用，业务发生改变需要修改多处代码，使用工厂模式即可进行代码解耦，业务改变修改时只需修改工厂部分代码

简单工厂模式

1.抽象一个对象，定义共性内容 

/**
 * 将购商场象为一个接口
 */
public interface IMarket {
    /**
     * 商品的接口
     */
    void goods();

    /****
     * 商场京东、淘宝、拼多多，各个商场有各自的商品
     */
}

2.创建具体实现类，实现自己特有内容

/**
 * 京东商场
 */
public class JdMarket implements IMarket {

    /**
     * 具体实现京东的商品
     */
    @Override
    public void goods() {
        System.out.println("这是京东的商品");
    }
}

/**
 * 拼多多商场
 */
public class PddMarket implements IMarket {


    /**
     * 具体实现PDD的商品
     */
    @Override
    public void goods() {
        System.out.println("这是拼多多的商品");
    }
}

/**
 * 淘宝商场
 */
public class TbMarket implements IMarket {

    /**
     * 具体实现TB的商品
     */
    @Override
    public void goods() {
        System.out.println("这是淘宝的商品");
    }
}

3.创建工厂，定义通过类型获取对应产品对象的方法

/**
 * 获取商场的工厂类
 */
public class SimpleFactory {

    /**
     * 根据Type获取相应的商场
     * @param type 商场类型
     * @return 对应商场
     */
    public static IMarket getMarket(String type) {
        switch (type) {
            case "JD":
                return new JdMarket();
            case "TB":
                return new TbMarket();
            case "PDD":
                return new PddMarket();
            default:
                return null;
        }
    }
}

测试结果 

public class SimpleFactoryTestMain {
    public static void main(String[] args) {
        // 此处传入京东，获取京东商场
        IMarket market = SimpleFactory.getMarket("JD");
        market.goods();
    }
}

 总结

简单工厂就是将对象抽象，定义共性内容，创建具体实现类。然后创建一个工厂，通过传入不同类型，创建对应对象。在一定程度上解耦代码。未来产品发生变化时，一定程度上减少修改工作量。但是在新增对象时需要修改工厂内部逻辑，对象过多时增加了系统逻辑复杂度，不利于未来的扩展和维护。

工厂方法模式

对简单工厂模式进一步抽象定义，使得可以在不修改工厂逻辑的情况下，可以拓展添加新的对象。

抽象工厂类，创建工厂接口，抽象定义获取对象的接口。

/**
 * 抽象定义工厂
 */
public interface IMarketFactory {
    /**
     * 定义获取商场的接口
     * @return 具体商场对象
     */
    IMarket getMarket();
}

定义具体工厂类，实现抽象工厂接口，实现获取对象的方法，由具体的工厂创建对应的对象 

/**
 * 具体实现京东商场工厂
 */
public class JdMarketFactory implements IMarketFactory {

    /**
     * 实现获取商场对象的方法
     * @return 京东商场
     */
    @Override
    public IMarket getMarket() {
        return new JdMarket();
    }
}

/**
 * 拼多多商场工厂具体实现
 */
public class PddMarketFactory implements IMarketFactory {

    /**
     * 实现获取商场对象的方法
     * @return 拼多多对象
     */
    @Override
    public IMarket getMarket() {
        return new PddMarket();
    }
}

/**
 * 实现淘宝商场工厂
 */
public class TbMarketFactory implements IMarketFactory {

    /**
     * 实现获取商场对象的方法
     * @return 淘宝商场对象
     */
    @Override
    public IMarket getMarket() {
        return new TbMarket();
    }
}

测试结果

public class FactoryMethodTestMain {
    public static void main(String[] args) {
        // 获取京东商场对象
        JdMarketFactory jdMarketFactory = new JdMarketFactory();
        IMarket market = jdMarketFactory.getMarket();
        market.goods();
        // 获取淘宝商场对象
        TbMarketFactory tbMarketFactory = new TbMarketFactory();
        IMarket tbMarket = tbMarketFactory.getMarket();
        tbMarket.goods();
    }
}

 总结

工厂方法模式的优点是具备更高的复用性和可读性，可以在不需要修改工厂逻辑的情况下可以创建新的对象。缺点是需要创建很多的工厂，当类型很多的时候，需要创建的工厂类就很多。

抽象工厂模式 

在工厂方法模式中，工厂能创建的对象类型太过单一，例如一个商场，有批发类型的商场，也有零售的商场，如果使用工厂方法模式，那么我们就需要创建两个工厂来进行生产对应类型的对象。经过时间发展后，假设又有了新的营销模式，如网销，直播销售的方式等，又得创建更多的工厂来进行生产对应的对象。那么如果将工厂继续抽象，在工厂中定义创建对象的接口，然后由具体的子工厂实现具体创建那种对象。这样，工厂就可以生产多种类型的对象，便于未来的维护与拓展。

1.创建抽象工厂

/**
 * 定义抽象工厂
 * 通过抽象工厂定义可以创建的各种类型，比如零售类和批发类
 */
public interface IAbstractFactory {

    /***
     * 创建零售类的商场
     * @return 零售类商场
     */
    IRetailMarket makeRetailMarket();

    /**
     * 创建批发类的商场
     * @return 批发类商场
     */
    IWholesalMarket makeWholesalMarket();
}

2.创建具体实现的工厂

/**
 * 定义京东商场类工厂，京东商场工厂实现抽象工厂，即可创建对应功能的对象
 */
public class JdMarketFactory implements IAbstractFactory {

    /**
     * 创建京东零售商场对象
     * @return 京东零售商场对象
     */
    @Override
    public IRetailMarket makeRetailMarket() {
        return new JdRetailMarket();
    }

    /**
     * 创建京东批发商场对象
     * @return 京东批发商场对象
     */
    @Override
    public IWholesalMarket makeWholesalMarket() {
        return new JdWholesalMarket();
    }
}

/**
 * 创建淘宝商场工厂类
 */
public class TbMarketFactory implements IAbstractFactory {

    /**
     * 创建淘宝零售商场对象
     * @return 淘宝零售商场对象
     */
    @Override
    public IRetailMarket makeRetailMarket() {
        return new TbRetailMarket();
    }

    /**
     * 创建淘宝批发商场对象
     * @return 淘宝批发商场对象
     */
    @Override
    public IWholesalMarket makeWholesalMarket() {
        return new TbWholesalMarket();
    }
}

测试结果

public class AbsFactoryTestMain {

    public static void main(String[] args) {
        // 创建京东商场工厂，
        IAbstractFactory jdMarketFactory = new JdMarketFactory();
        // 通过jd工厂创建出京东零售商场与京东批发商场
        IRetailMarket jdRetailMarket = jdMarketFactory.makeRetailMarket();
        IWholesalMarket jdWholesalMarket = jdMarketFactory.makeWholesalMarket();
        jdRetailMarket.retail();
        jdWholesalMarket.wholesal();
        System.out.println("----------------------分割线---------------------");
        // 创建淘宝商场工厂
        IAbstractFactory tbMarketFactory = new TbMarketFactory();
        // 通过淘宝商场工厂创建淘宝零售商场与淘宝批发商场
        IWholesalMarket tbWholesalMarket = tbMarketFactory.makeWholesalMarket();
        IRetailMarket tbRetailMarket = tbMarketFactory.makeRetailMarket();
        tbRetailMarket.retail();
        tbWholesalMarket.wholesal();
    }
}

 总结

将工厂进一步封装成抽象工厂，定义各类工厂可以创建的对象类型，使工厂可以创建的类型不再单一，在实际应用中可以将相关的功能整合成一个功能线。开发时使得代码可读性与可维护性提高，同时可以快捷的使用各种封装好的功能。