设计模式之抽象工厂模式（代理方式实现）

抽象工厂模式跟工厂方法模式一样主要是为了解决接口问题，但实现上抽象工厂是一个中心工厂负责创建其他工厂的模式，接口负责创建一个相关对象的工厂，不需要显示指定具体的实现类，每个生成的工厂都能按照工厂模式提供对象。

代码实现

1、代码目录

• 工程部分核心代码功能如下：
  IFactoryAdapter：定义了适配器接口，用于屏蔽IFactoryOne、IFactoryTwo两个工厂接口的具体实现；
• FactoryProxy、FactoryInvocationHandler：代理类的定义和实现，抽象工厂的另外一种实现方法即代理实现。
  2、代码实现
  2.1、定义适配接口

public interface IFactoryAdapter {
    void println (String factory);
}

2.2、工厂一代码实现
2.2.1、工厂一接口

public interface IFactoryOne {

    void onePrintln (String factory);

}

2.2.2、工厂一两个实现

public class FactoryOneOne implements IFactoryOne {

    @Override
    public void onePrintln(String factory) {
        System.out.println("FactoryOneOne：" + factory);
    }
}

public class FactoryOneTwo implements IFactoryOne {

    @Override
    public void onePrintln(String factory) {
        System.out.println("FactoryOneTwo：" + factory);
    }
}

2.2.3、工厂一实例工厂

public class FactoryOneInstance {

    public IFactoryOne getFactory(Integer factoryType) {
        if (null == factoryType) {
            return null;
        }
        if (1 == factoryType) {
            return new FactoryOneOne();
        }
        if (2 == factoryType) {
            return new FactoryOneTwo();
        }
        return null;
    }
}

2.2.4、工厂一实现适配接口

public class FactoryAdapterOne implements IFactoryAdapter {

    private Integer factoryType;

    public FactoryAdapterOne(Integer factoryType) {
        this.factoryType = factoryType;
    }

    @Override
    public void println(String factory) {
        FactoryOneInstance factoryOneInstance = new FactoryOneInstance();
        factoryOneInstance.getFactory(factoryType).onePrintln(factory);
    }
}

2.3.工厂二代码实现
2.3.1、工厂二接口

public interface IFactoryTwo {

    void twoPrintln (String factory);
}

2.3.2、工厂二两个实现

public class FactoryTwoOne implements IFactoryTwo {

    @Override
    public void twoPrintln(String factory) {
        System.out.println("FactoryTwoOne：" + factory);
    }

}

public class FactoryTwoTwo implements IFactoryTwo {

    @Override
    public void twoPrintln(String factory) {
        System.out.println("FactoryTwoTwo：" + factory);
    }
}

2.3.3、工厂二实例工厂

public class FactoryTwoInstance {

    public IFactoryTwo getFactory(Integer factoryType) {
        if (null == factoryType) {
            return null;
        }
        if (1 == factoryType) {
            return new FactoryTwoOne();
        }
        if (2 == factoryType) {
            return new FactoryTwoOne();
        }
        return null;
    }
}

2.3.4、工厂二实现适配接口

public class FactoryAdapterTwo implements IFactoryAdapter {

    private Integer factoryType;

    public FactoryAdapterTwo(Integer factoryType) {
        this.factoryType = factoryType;
    }

    @Override
    public void println(String factory) {
        FactoryTwoInstance factoryTwoInstance = new FactoryTwoInstance();
        factoryTwoInstance.getFactory(factoryType).twoPrintln(factory);
    }
}

2.4、代理方式代码实现

public class FactoryInvocationHandler implements InvocationHandler {

    private IFactoryAdapter factoryAdapter;

    public FactoryInvocationHandler(IFactoryAdapter factoryAdapter) {
        this.factoryAdapter = factoryAdapter;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return IFactoryAdapter.class.getMethod(method.getName(), getClazzByArgs(args)).invoke(factoryAdapter, args);
    }

    private  Class<?>[] getClazzByArgs(Object[] args) {
        Class<?>[] parameterTypes = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            if (args[i] instanceof ArrayList) {
                parameterTypes[i] = List.class;
                continue;
            }
            if (args[i] instanceof LinkedList) {
                parameterTypes[i] = List.class;
                continue;
            }
            if (args[i] instanceof HashMap) {
                parameterTypes[i] = Map.class;
                continue;
            }
            if (args[i] instanceof Long){
                parameterTypes[i] = long.class;
                continue;
            }
            if (args[i] instanceof Double){
                parameterTypes[i] = double.class;
                continue;
            }
            if (args[i] instanceof TimeUnit){
                parameterTypes[i] = TimeUnit.class;
                continue;
            }
            parameterTypes[i] = args[i].getClass();
        }
        return parameterTypes;
    }
}

public class FactoryProxy {


    public static <T> T getFactoryProxy(Class<T> interfaceClass, IFactoryAdapter factoryAdapter) throws Exception {
        InvocationHandler handler = new FactoryInvocationHandler(factoryAdapter);
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class<?>[] classes = interfaceClass.getInterfaces();
        return (T) Proxy.newProxyInstance(classLoader, new Class[]{classes[0]}, handler);
    }

}

2.5、编写测试代码验证
2.5.1、代码实现

public class AbstractFactoryTest {

    public static void main(String[] args) throws Exception {
        IFactoryAdapter factoryAdapter11 = FactoryProxy.getFactoryProxy(FactoryAdapterOne.class, new FactoryAdapterOne(1));
        factoryAdapter11.println("工厂一实现一");
        IFactoryAdapter factoryAdapter12 = FactoryProxy.getFactoryProxy(FactoryAdapterOne.class, new FactoryAdapterOne(2));
        factoryAdapter12.println("工厂一实现二");
        IFactoryAdapter factoryAdapter21 = FactoryProxy.getFactoryProxy(FactoryAdapterTwo.class, new FactoryAdapterTwo(1));
        factoryAdapter21.println("工厂二实现一");
        IFactoryAdapter iFactoryAdapter22 = FactoryProxy.getFactoryProxy(FactoryAdapterTwo.class, new FactoryAdapterTwo(2));
        iFactoryAdapter22.println("工厂二实现二");
    }
}

2.5.2、测试结果

总结

• 抽象工厂模式解决的是一个产品族存在多种不同的产品类型（操作系统、手机）的情况下接口选择的问题；
• 符合单⼀职责、开闭原则、解耦的优点