抽象工厂模式

抽象工厂模式

为什么需要工厂模式？

用于实现业务层与数据层进行解耦，比如，一个项目此时使用的是oracle,现在要修改成mysql,如果运用此模式则只需要修改一次程序代码（即初始化工厂代码）。

什么是抽象工厂模式？

提供一个创建一系列相关的或相互依赖抽象的接口，而无需指定它们具体的类。

抽象工厂模式的抽象实现

uml图

逻辑说明

抽象工厂接口(AbstractFactory)中定义了创建两种产品的方法，两个不同的具体工厂类(代表不同的数据库管理系统)实现抽象工厂中的接口，不同的工厂类重写该方法对应于不同的产品（数据库），从而实现不同数据库的数据表可以通过相同的方法访问。

抽象工厂类

public interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

抽象产品A类,B类

每一种方法可代表不同的数据库环境，不同的方法是不同的功能。不同的抽象产品接口代表不同的产品。

public interface AbstractProductA {
    void methodA1();
    void methodA2();
}

public interface AbstractProductB {
    void methodB1();
    void methodB2();
}

具体工厂1类,2类

public class ConcreteFactory1 implements AbstractFactory{

    @Override
    public AbstractProductA createProductA() {
        System.out.println("创建产品A1");
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        System.out.println("创建产品B1");
        return new ProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory{

    @Override
    public AbstractProductA createProductA() {
        System.out.println("创建产品A2");
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        System.out.println("创建产品B2");
        return new ProductB2();
    }
}

具体产品A1,A2,B1,B2类

public class ProductA1 implements AbstractProductA{
    @Override
    public void methodA1() {
        System.out.println("productA1实现的methodA1");
    }

    @Override
    public void methodA2() {
        System.out.println("productA1实现的methodA2");
    }
}

public class ProductA2 implements AbstractProductA{
    @Override
    public void methodA1() {
        System.out.println("productA2实现的methodA1");
    }

    @Override
    public void methodA2() {
        System.out.println("productA2实现的methodA2");
    }
}

public class ProductB1 implements AbstractProductB{
    @Override
    public void methodB1() {
        System.out.println("productB1实现的methodB1");
    }

    @Override
    public void methodB2() {
        System.out.println("productB1实现的methodB2");
    }
}

public class ProductB2 implements AbstractProductB{
    @Override
    public void methodB1() {
        System.out.println("productB2实现的methodB1");
    }

    @Override
    public void methodB2() {
        System.out.println("productB2实现的methodB2");
    }
}

使用类

public class App {
    public static void main(String[] args) {
//        AbstractFactory factory = new ConcreteFactory1();可通过修改初始化工厂的代码来适应不同的运行环境
        AbstractFactory factory = new ConcreteFactory2();
        AbstractProductA productA = factory.createProductA();
        productA.methodA1();
        productA.methodA2();
        AbstractProductB productB = factory.createProductB();
        productB.methodB1();
        productB.methodB2();
    }
}
//效果打印：
//    创建产品A1
//    productA1实现的methodA1
//    productA1实现的methodA2
//    创建产品B1
//    productB1实现的methodB1
//    productB1实现的methodB2

//    创建产品A2
//    productA2实现的methodA1
//    productA2实现的methodA2
//    创建产品B2
//    productB2实现的methodB1
//    productB2实现的methodB2

不足之处

增加一个产品时，需要增加产品类，修改工厂类，并且我们修改运行环境采取的方法是修改编译前的代码，可以通过反射来设置变量作为初始化工厂类的标志，做到编译到运行时修改