第15章《抽象工厂模式》

最新推荐文章于 2022-04-07 23:20:11 发布
最新推荐文章于 2022-04-07 23:20:11 发布
阅读量272 收藏
点赞数
分类专栏： 大话设计模式笔记 文章标签： 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoxiaohong1005/article/details/79058162
版权

1、工厂模式和抽象工厂模式的区别：

工厂模式适合具体功能类ConcreteProductX只有一个系列的情况；

抽象工厂模式适合一个具体功能类ConcreteProductX有至少两个系列的情况。


2、抽象工厂模式准确定义：

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


3、抽象工厂模式的优点：

3.1、易于交换产品系列，这是最大的优点。通过改变具体的工厂，就可使用不同的产品配置。

3.2、它让具体的创建过程和客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端代码中。

3.3、是开放-封闭原则、依赖倒转原则的良好运用。其实，这一点和工厂模式 一样。


4、抽象工厂模式UML图：



5、例子：

5.1、场景：某公司有两个系列的产品，1系列和2系列。对应的每个 系列中，包含所有的不同类型的产品。假设产品类型为A和B。故1系列中有产品；A1、B1；2系列中有产品：A2、B2。每个生产清单只生产一个系列的所有产品。比如：生产清单X只生产1系列的所有产品，包括：A1、B1。因此针对不同的生产清单需要生产不同系列的产品。当客户端收到一个生产清单时，就要生产一个系列的产品。

5.2、下面给出针对上述需求的代码，采用的设计模式演化过程为：工厂模式->抽象工厂模式->简单工厂模式+抽象工厂模式->反射+抽象工厂模式->配置文件+抽象工厂模式。通过设计模式的一步步演化，实现了抽象工厂模式的优化。

(1)工厂模式

代码结构为：


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:56
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) {
        //建立工厂A1
        ConcreteFactoryA1 cfa1=new ConcreteFactoryA1();
        //生成产品A1
        ConcreteProductA1 pa1=(ConcreteProductA1)cfa1.getProduct();
        //对产品A1的crud操作
        pa1.create(new ConcreteProductA1());
        pa1.retrieve();
        pa1.update(new ConcreteProductA1());
        pa1.delete("1");

        System.out.println("--------分隔线--------");

        //建立工厂A2
        ConcreteFactoryA2 cfa2=new ConcreteFactoryA2();
        //生成产品A2
        ConcreteProductA2 pa2=(ConcreteProductA2)cfa2.getProduct();
        //对产品A2的crud操作
        pa2.create(new ConcreteProductA2());
        pa2.retrieve();
        pa2.update(new ConcreteProductA2());
        pa2.delete("1");

    }
}


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:40
 * @ProjectName: JavaBaseTest
 */
public class ConcreteFactoryA1 implements Factory {
    @Override
    public ProductA getProduct() {
        return new ConcreteProductA1();
    }
}


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:48
 * @ProjectName: JavaBaseTest
 */
public class ConcreteFactoryA2 implements Factory {
    @Override
    public ProductA getProduct() {
        return new ConcreteProductA2();
    }
}


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:40
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA1 implements ProductA {
    @Override
    public void create(ProductA product) {
        System.out.println("增加一条ProductA1的信息");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查找一条ProductA1的信息");
        return null;
    }

    @Override
    public boolean update(ProductA product) {
        System.out.println("更新一条ProductA1的信息");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ProductA1的信息");
        return false;
    }
}


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:41
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA2 implements ProductA {
    @Override
    public void create(ProductA product) {
        System.out.println("增加一条ProductA2的信息");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查找一条ProductA2的信息");
        return null;
    }

    @Override
    public boolean update(ProductA product) {
        System.out.println("更新一条ProductA2的信息");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ProductA2的信息");
        return false;
    }
}


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:39
 * @ProjectName: JavaBaseTest
 */
public interface Factory {
    ProductA getProduct();
}


package designmodel.fifteenthchapter.工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:40
 * @ProjectName: JavaBaseTest
 */
public interface ProductA {
    //crud
    void create(ProductA product);
    ProductA retrieve();
    boolean update(ProductA product);
    boolean delete(String id);
}


(2)抽象工厂模式

代码结构为：


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:08
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) {
        //使用1类型工厂,创建1类型的产品A和B(当然,也可以使用类型2,写法一致)

        //创建工厂实例和产品实例
        ConcreteFactory1 cf1=new ConcreteFactory1();
        ConcreteProductA1 a1=(ConcreteProductA1)cf1.getA();
        ConcreteProductB1 b1=(ConcreteProductB1)cf1.getB();
        //调用A1产品的crud方法
        a1.create(new ConcreteProductA1());
        a1.retrieve();
        a1.update(new ConcreteProductA1());
        a1.delete("1");
        //调用B1产品的crud方法
        b1.create(new ConcreteProductB1());
        b1.retrieve();
        b1.update(new ConcreteProductB1());
        b1.delete("1");
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:05
 * @ProjectName: JavaBaseTest
 */
public class ConcreteFactory1 implements Factory{

    @Override
    public ProductA getA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB getB() {
        return new ConcreteProductB1();
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:05
 * @ProjectName: JavaBaseTest
 */
public class ConcreteFactory2 implements Factory {
    @Override
    public ProductA getA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB getB() {
        return new ConcreteProductB2();
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;



/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:40
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA1 implements ProductA {
    @Override
    public void create(ProductA product) {
        System.out.println("增加一条ProductA1的信息");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查找一条ProductA1的信息");
        return null;
    }

    @Override
    public boolean update(ProductA product) {
        System.out.println("更新一条ProductA1的信息");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ProductA1的信息");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;



/**
 * @Author: cxh
 * @CreateTime: 18/1/13 21:41
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA2 implements ProductA {
    @Override
    public void create(ProductA product) {
        System.out.println("增加一条ProductA2的信息");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查找一条ProductA2的信息");
        return null;
    }

    @Override
    public boolean update(ProductA product) {
        System.out.println("更新一条ProductA2的信息");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ProductA2的信息");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;



/**
 * @Author: cxh
 * @CreateTime: 18/1/13 22:17
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB1 implements ProductB {
    @Override
    public void create(ProductB product) {
        System.out.println("增加一条ProductB1记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查找一条ProductB1记录");
        return null;
    }

    @Override
    public boolean update(ProductB product) {
        System.out.println("更新一条ProductB1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ProductB1记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 22:19
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB2 implements ProductB {
    @Override
    public void create(ProductB product) {
        System.out.println("增加一条ProdctB2记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查询一条ProdctB2记录");
        return null;
    }

    @Override
    public boolean update(ProductB product) {
        System.out.println("更新一条ProdctB2记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ProdctB2记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 22:48
 * @ProjectName: JavaBaseTest
 */
public interface Factory {
    ProductA getA();
    ProductB getB();
}


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 22:43
 * @ProjectName: JavaBaseTest
 */
public interface ProductA {
    //crud
    void create(ProductA product);
    ProductA retrieve();
    boolean update(ProductA product);
    boolean delete(String id);
}


package designmodel.fifteenthchapter.抽象工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 22:58
 * @ProjectName: JavaBaseTest
 */
public interface ProductB {
    //crud
    void create(ProductB product);
    ProductA retrieve();
    boolean update(ProductB product);
    boolean delete(String id);
}


(3)简单工厂模式+抽象工厂模式

代码结构为：


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:31
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) {
        ProductA productA=Factory.getProductA("1");
        ProductB productB=Factory.getProductB("1");
        //A产品的crud操作
        productA.create(new ConcreteProductA1());
        productA.retrieve();
        productA.update(new ConcreteProductA1());
        productA.delete("1");

        System.out.println("-------分隔线---------");

        //B产品的crud操作
        productB.create(new ConcreteProductB1());
        productB.retrieve();
        productB.update(new ConcreteProductB1());
        productB.delete("1");
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:38
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA1 implements ProductA {
    @Override
    public void create(ProductA a) {
        System.out.println("新增一条ConcreteA1记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查找一条ConcreteA1记录");
        return null;
    }

    @Override
    public boolean update(ProductA a) {
        System.out.println("更新一条ConcreteA1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteA1记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:41
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA2 implements ProductA {

    @Override
    public void create(ProductA a) {
        System.out.println("添加一条ConcreteA2记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查询一条ConcreteA2记录");
        return null;
    }

    @Override
    public boolean update(ProductA a) {
        System.out.println("更新一条ConcreteA2记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteA2记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:43
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB1 implements ProductB {
    @Override
    public void create(ProductB b) {
        System.out.println("新增一条ConcreteB1记录");
    }

    @Override
    public ProductB retrieve() {
        System.out.println("查询一条ConcreteB1记录");
        return null;
    }

    @Override
    public boolean update(ProductB b) {
        System.out.println("更新一条ConcreteB1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteB1记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:45
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB2 implements ProductB {
    @Override
    public void create(ProductB b) {
        System.out.println("新增一条B2产品记录");
    }

    @Override
    public ProductB retrieve() {
        System.out.println("查询一条B2产品记录");
        return null;
    }

    @Override
    public boolean update(ProductB b) {
        System.out.println("更新一条B2产品记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条B2产品记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 09:52
 * @ProjectName: JavaBaseTest
 */
public class Factory {
    //获取产品A系列某一个产品
    public static ProductA getProductA(String type){
        switch (type){
            case "1":
                return new ConcreteProductA1();
            case "2":
                return new ConcreteProductA2();
        }
        return null;
    }
    //获取产品B系列某一个产品
    public static ProductB getProductB(String type){
        switch (type){
            case "1":
                return new ConcreteProductB1();
            case "2":
                return new ConcreteProductB2();
        }
        return null;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:34
 * @ProjectName: JavaBaseTest
 */
public interface ProductA {
    //crud
    void create(ProductA a);
    ProductA retrieve();
    boolean update(ProductA a);
    boolean delete(String id);
}


package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
 * @Author: cxh
 * @CreateTime: 18/1/13 23:36
 * @ProjectName: JavaBaseTest
 */
public interface ProductB {
    //crud
    void create(ProductB b);
    ProductB retrieve();
    boolean update(ProductB b);
    boolean delete(String id);
}


(4)反射+抽象工厂模式

代码结构为： 


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:27
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) throws Exception{
        ProductA productA=Factory.getProductA();
        ProductB productB=Factory.getProductB();

        //产品A的crud操作
        productA.create(productA.getClass().newInstance());
        productA.retrieve();
        productA.update(productA.getClass().newInstance());
        productA.delete("1");

        System.out.println("------分隔线----------");

        //产品B的crud操作
        productB.create(productB.getClass().newInstance());
        productB.retrieve();
        productB.update(productB.getClass().newInstance());
        productB.delete("1");
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:32
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA1 implements ProductA{
    @Override
    public void create(ProductA productA) {
        System.out.println("新增一条ConcreteProductA1记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查询一条ConcreteProductA1记录");
        return null;
    }

    @Override
    public boolean update(ProductA productA) {
        System.out.println("更新一条ConcreteProductA1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductA1记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:35
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA2 implements ProductA {
    @Override
    public void create(ProductA productA) {
        System.out.println("新增一条ConcreteProductA2记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("新查询一条ConcreteProductA2记录");
        return null;
    }

    @Override
    public boolean update(ProductA productA) {
        System.out.println("更新一条ConcreteProductA2记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductA2记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:38
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB1 implements ProductB{
    @Override
    public void create(ProductB productB) {
        System.out.println("新增一条ConcreteProductB1记录");
    }

    @Override
    public ProductB retrieve() {
        System.out.println("查询一条ConcreteProductB1记录");
        return null;
    }

    @Override
    public boolean update(ProductB productB) {
        System.out.println("更新一条ConcreteProductB1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductB1记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:42
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB2 implements ProductB {
    @Override
    public void create(ProductB productB) {
        System.out.println("新增一条ConcreteProductB2记录");
    }

    @Override
    public ProductB retrieve() {
        System.out.println("查询一条ConcreteProductB2记录");
        return null;
    }

    @Override
    public boolean update(ProductB productB) {
        System.out.println("更新一条ConcreteProductB2记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductB2记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:32
 * @ProjectName: JavaBaseTest
 * 利用反射,去除了简单工厂模式中的switch case语句
 */
public class Factory {
    private static final String path="designmodel.fifteenthchapter.抽象工厂模式and反射";
    private static final String type="1";

    //利用反射,获取实例
    public static ProductA getProductA() throws Exception{
        return  (ProductA)Class.forName(path+".ConcreteProductA"+type).newInstance();
    }
    public static ProductB getProductB() throws Exception{
        return  (ProductB)Class.forName(path+".ConcreteProductB"+type).newInstance();
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:27
 * @ProjectName: JavaBaseTest
 */
public interface ProductA {
    //crud
    void create(ProductA productA);
    ProductA retrieve();
    boolean update(ProductA productA);
    boolean delete(String id);
}


package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 10:29
 * @ProjectName: JavaBaseTest
 */
public interface ProductB {
    //crud
    void create(ProductB productB);
    ProductB retrieve();
    boolean update(ProductB productB);
    boolean delete(String id);
}


(5)配置+抽象工厂模式 

代码结构为：


package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:22
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) throws Exception{
        //获取配置文件信息
        Factory.getType();

        ProductA a=Factory.getProductA();
        ProductB b=Factory.getProductB();
        //A产品的crud操作
        a.create(a.getClass().newInstance());
        a.retrieve();
        a.update(a.getClass().newInstance());
        a.delete("1");

        System.out.println("--------分隔线-------");

        //B产品的crud操作
        b.create(b.getClass().newInstance());
        b.retrieve();
        b.update(b.getClass().newInstance());
        b.delete("1");
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:25
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA1 implements ProductA {
    @Override
    public void create(ProductA productA) {
        System.out.println("新增一条ConcreteProductA1记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查询一条ConcreteProductA1记录");
        return null;
    }

    @Override
    public boolean update(ProductA productA) {
        System.out.println("更新一条ConcreteProductA1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductA1记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:31
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductA2 implements ProductA {
    @Override
    public void create(ProductA productA) {
        System.out.println("新增一条ConcreteProductA2记录");
    }

    @Override
    public ProductA retrieve() {
        System.out.println("查询一条ConcreteProductA2记录");
        return null;
    }

    @Override
    public boolean update(ProductA productA) {
        System.out.println("更新一条ConcreteProductA2记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductA2记录");
        return false;
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:33
 * @ProjectName: JavaBaseTest
 */
public class ConcreteProductB1 implements ProductB {
    @Override
    public void create(ProductB productB) {
        System.out.println("新增一条ConcreteProductB1记录");
    }

    @Override
    public ProductB retrieve() {
        System.out.println("查询一条ConcreteProductB1记录");
        return null;
    }

    @Override
    public boolean update(ProductB productB) {
        System.out.println("更新一条ConcreteProductB1记录");
        return false;
    }

    @Override
    public boolean delete(String id) {
        System.out.println("删除一条ConcreteProductB1记录");
        return false;
    }
}


<series>
    <producta>1</producta>
    <productb></productb>
</series>

package designmodel.fifteenthchapter.抽象工厂模式and配置;

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:35
 * @ProjectName: JavaBaseTest
 */
public class Factory {
    private static final String path="designmodel.fifteenthchapter.抽象工厂模式and配置";
    private static String type;
    public static void getType(){
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        try{
            DocumentBuilder db=dbf.newDocumentBuilder();
            Document document=
                    db.parse("/Users/caoxiaohong/IdeaProjects/JavaBaseTest/src/designmodel/fifteenthchapter/抽象工厂模式and配置/config.xml");
            NodeList list=document.getElementsByTagName("producta");
            type=list.item(0).getFirstChild().getNodeValue();
        }catch (Exception e){
            System.out.println("解析xml文件出错!");
        }
    }
    public static ProductA getProductA() throws Exception{
        return (ProductA)Class.forName(path+".ConcreteProductA"+type).newInstance();
    }
    public static ProductB getProductB() throws Exception{
        return (ProductB)Class.forName(path+".ConcreteProductB"+type).newInstance();
    }
}


package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:21
 * @ProjectName: JavaBaseTest
 */
public interface ProductA {
    //crud操作
    void create(ProductA productA);
    ProductA retrieve();
    boolean update(ProductA productA);
    boolean delete(String id);
}


package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
 * @Author: cxh
 * @CreateTime: 18/1/14 11:21
 * @ProjectName: JavaBaseTest
 */
public interface ProductB {
    //crud
    void create(ProductB productB);
    ProductB retrieve();
    boolean update(ProductB productB);
    boolean delete(String id);
}


参考书籍：《大话设计模式》－程杰


iCoding91
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式-第12章（抽象工厂模式）
保持热爱，持续学习
03-08 179
抽象工厂模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
第15章抽象工厂模式
weixin_30265171的博客
07-02 58
一 概念 抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 二 包含的角色 抽象工厂：它里面应该包含所有的产品创建的抽象方法 具体工厂：具体工厂，创建具有特定实现的产品对象 抽象产品：他们都有可能有两种不同的实现 具体产品 三 优势 抽象工厂模式是对工厂方法模式的改进。用于处理产品不只有一类的情况（工厂方法模式下，产品只有User这一类，而抽象...
大话设计模式：第15章 抽象工厂模式
Always On The Way
05-06 255
第15章：抽象工厂模式 抽象工厂模式 工厂方法模式（factory method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 抽象工厂模式（abstract factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 AbstractProductA和AbstractProductB是两个抽象产品，之所以为抽...
读《大话设计模式——第15章 抽象工厂模式》有感
SWINGING VINE的博客
09-12 120
上周末看了一下抽象工厂模式，然后对比了一下简单工厂模式、工厂模式和抽象工厂模式。 对比工厂模式和抽象工厂模式，看得我一愣一愣的。 一个工厂生产一个产品叫工厂模式，生产多个产品就叫抽象工厂模式？ 不要试图去理解它，而是去感受它。——ChristopherNolan 按照《大话设计模式》第15章抽象工厂模式的案例走下去，有提到使用简单工厂模式去改进db软件的切换， 但有新数据库软件("新工厂")引入的时候，就需要增加相应的工厂类（实现工厂接口）和数据表("产品")类（实现相应的产品接口）。这种场景下.
设计模式--第十八章 抽象工厂模式
追梦的土豆的博客
04-07 104
第十八章 抽象工厂模式
第1章《简单工厂模式》
iCoding91
12-31 439
1、学习总结： （1）工厂模式优点： a、将业务逻辑和界面逻辑分离，降低两者之间的耦合性。 b、将具体的不同业务进行分离，实现业务间的松耦合。 c、用一个单独的类来决定创建哪个业务实例的过程。这就是工厂。究竟要实例化哪个业务类，将来会不会增加实例化的对象，这些都是容易变化的地方，所以适合用一个工厂来做决策。 其实，c的内容才是工厂模式的原理，但是c的实现，需要a和b已经实现的情况下才可以
第9章《原型模式》
iCoding91
01-07 317
1、原型模式的规范定义： 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的实例。 2、原型模式的实质： 利用一个指定的对象实例，再创建一个同类型的对象实例，且这个新对象可以被定制，而且不需要知道创建的细节。 3、在java中的实现方式： 一个类只要实现了Cloneable()接口，就能作为原型被复制。当创建一个同类型的新实例时，可以通过调用这个类的clone()方
第2章《策略模式》
iCoding91
01-01 312
1、策略模式实质：封装了变化点。 2、策略模式定义：是一种定义了一系列算法的方法。 说明：这些算法完成的工作都是一样的，只是实现方式不同而已(比如，商场促销，满1000减100和打九折，这就是两个算法，但完成的工作是一样的，你想，你去商场买衣服，付款时候，只能是使用其中一种策略减少付款金额，而不能叠加使用，所以完成的工作是一样的。) 3、策略模式适用场景：通过其特点就能知道它
单例模式总结
iCoding91
08-16 305
单例模式 饿汉模式　　 初始化时间　　 类加载到JVM时　　 缺点　　 类加载慢　　 优点　　 获取对象速度快　 避免多线程的同步问题　　 懒汉模式【线程不安全】　　 初始化时间　　 第一次调用方法时 缺点 第一次方法调用响应慢，因需要实例化对象。 多线程不安全 优点 节约资源 懒汉模式【线程安全】 初始化时间 第一次方法调用时 缺点 调用方法为“synch...
第22章《桥接模式》
iCoding91
01-26 290
1、定义：将抽象部分和它的实现部分分离，使它们都可以独立的变化。 这个定义真的很拗口，然后GoF的定义，我也是读了好几遍，还是有点蒙圈。还好书里有一个比较通俗的解释：实现系统可能会有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让他们独立变化，减少它们之间的耦合。 举个例子： 手机的实现可以通过先按照品牌分类，然后在品牌下再按照功能分类； 也可以先按照功能分类，然后每个功能
第21章《单例模式》
iCoding91
12-13 284
今天买了《大话设计模式》这本书，也是找朋友推荐的。晚上拿到手，就看了一下单例模式这一章，因为自己只是知道单例模式，其它模式完全不懂，就想看看这本书是不是真的读起来容易理解以及讲的怎么样。一个小时看完这一章节，觉得还可以吧，讲的东西是很容易理解，且循序渐进，虽然讲的东西自己基本都是知道的，因为之前就了解这个模式。接下来还要把其它模式研究一下，继续努力～～～ 关于单例模式，补充一下自己曾经遗
第18章《备忘录模式》
iCoding91
01-16 273
1、定义： 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。 2、功能： 2.1、当角色的状态改变时，有可能这个状态无效，这时候就可以使用暂存起来的备忘录将状态复原。 2.2、实现命令的撤销功能。命令模式可以使用备忘录来存储可撤销操作的状态。 3、适用场景： Memento模式适用于：功能比较复杂的，
第20章《迭代器模式》
iCoding91
01-24 256
1、定义： 提供一种方法顺序访问一个对象中各个元素，而又不暴露对象的内部表示。 2、实际应用： 由于现在高级语言，比如java、c＃都已经把迭代器模式集成在语言中了，所以这个模式没有什么实用价值，但是有学习价值，我们还是可以了解一下迭代器模式内部是怎么实现的。 3、对ArrayList的迭代器源码的分析： 3.1、对ArrayList迭代器源码及其分析： (1)JDK8
第7章《代理模式》
iCoding91
01-03 255
1、规范定义:为其它对象提供一种代理，以控制对这个对象的访问。                       通俗的讲，就是本来C是要访问S的，但是通过加入代理P后，C不需要知道S是谁，C直接访问P，P通过自己的内部逻辑，去访问S，这就实现了C最终还是调用到了S的方法，只是不是自己直接调用，而是通过代理P调用的。 2、代理模式结构图：     说明：       (1)通过继承S
第25章《中介者模式》
iCoding91
02-20 244
1.定义 用一个对象来封装一系列的对象交互。中介者使各对象不需要显示的互相引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 2.优点 中介者的出现降低了各个交互对象之间的耦合性，使得可以独立和复用所有的交互对象类、中介者类。 由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到了它们之间的交互上来，也就是站在一个...
第23章《命令模式》
iCoding91
01-26 236
1、定义：将一个请求封装为一个对象，从而可以使用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销操作。 2、优势： 2.1、能较容易的设计一个命令队列。 2.2、在需要的情况下，可以较容易的将命令记入日志。 2.3、允许接受请求的一方决定是否要否决请求。 2.4、可以容易的实现对请求的撤销和重做。 2.5、由于加进具体命令类不影响其他的类，因此增加新的具体命
第8章《工厂方法模式》
iCoding91
01-06 236
1、工厂方法和简单工厂的对比： 1.1、添加新功能时，二者的区别： (1)简单工厂需要完成工作：添加一个新功能类＋更改工厂类 (2)工厂方法需要完成工作：添加一个新功能类＋添加一个生成对象的工厂＋更改客户端实例化工厂的代码 1.2、二者共同点：集中封装了对象的创建，使得要更换对象时，不需要做大的动作就可实现，降低了客户端程序和产品对象的耦合。 2、工厂方法的优点： 2.
第24章《职责链模式》
iCoding91
01-28 232
1、定义： 使得多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 从定义分析： (1)对于一个请求会有多个对象对其进行转发。 (2)请求的发送者和最终处理请求的接受者之间互相并不知道，没有任何耦合关系。 (3)最终能够处理一个请求的对象有且只有一个，如果没有则表示处理过程or职责链设置出现错误。
工厂模式和抽象工厂模式
最新发布
04-02
工厂模式和抽象工厂模式都是创建型设计模式，它们的主要区别在于： 1. 工厂模式：工厂模式定义了一个工厂类，该类负责创建对象并将其返回给调用者。调用者不需要知道对象的具体创建过程，只需要知道如何使用它。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值