第15章《抽象工厂模式》

分类：设计模式作者：编程之家用户

抽象工厂模式->简单工厂模式+抽象工厂模式->反射+抽象工厂模式->配置文件+抽象工厂模式。通过设计模式的一步步演化，实现了抽象工厂模式的优化。

/**


    

  • 

    @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");
    

    }
    
}

<span style="font-size:14px;">




/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/13 21:40
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public class ConcreteFactoryA1 implements Factory {
    
@Override
    
public ProductA getProduct() {
    
return new ConcreteProductA1();
    
}
    
}

<span style="font-size:14px;">



/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/13 21:48
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public class ConcreteFactoryA2 implements Factory {
    
@Override
    
public ProductA getProduct() {
    
return new ConcreteProductA2();
    
}
    
}

<span style="font-size:14px;">



/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/13 21:39
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public interface Factory {
    
ProductA getProduct();
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">

/**


    

  • 

    @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");
    

    }
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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();
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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();
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/13 22:48
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public interface Factory {
    
ProductA getA();
    
ProductB getB();
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">

/**


    

  • 

    @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");
    

    }
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • @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;
    
}
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">

/**


    

  • 

    @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");
    

    }
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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();
    
}
    
}

<span style="font-size:14px;">




/**


    

  • @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);
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">

/**


    

  • 

    @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");
    

    }
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @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;
    
}
    
}

<span style="font-size:14px;">


 1
 

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();
    
}
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">



/**


    

  • @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);
    
}

<span style="font-size:14px;">

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

什么是设计模式？Design pattern--和生活结合更好理解
什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结；使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性；设计模式使代码编制  真正工程化；设计模式使软件工程的 基石脉络， 如同大厦的结构一样；并不直接用来完成代码的编写，而是 描述 在各种不同情况下，要怎么解决问题的一种方案；能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免引
面向对象设计原则一——单一职责原则
单一职责原则定义（Single Responsibility Principle，SRP）一个对象应该只包含 单一的职责，并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t
十分钟理解Java中的动态代理----强烈推荐
动态代理和CGLib代理分不清吗，看看这篇文章，写的非常好，强烈推荐。原文截图*************************************************************************************************************************原文文本************
适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合作。
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的一些设计问题，总结出来的一套通用的解决方案。
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
外观模式-简化子系统的复杂性
外观模式又叫门面模式，它提供了一个统一的（高层）接口，用来访问子系统中的一群接口，使得子系统更容易使用。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方式处理个别对象和对象组合。
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候，所有依赖者都会自动收到通知。
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。
工厂模式-将对象的创建封装起来
工厂模式（Factory Design Pattern）可细分为三种，分别是简单工厂，工厂方法和抽象工厂，它们都是为了更好的创建对象。
状态模式-将状态和行为封装成对象
状态模式允许对象在内部状态改变时，改变它的行为，对象看起来好像改变了它的类。
命令模式-将请求封装成对象
命令模式将请求封装为对象，能够支持请求的排队执行、记录日志、撤销等功能。
【设计模式】备忘录模式
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。 基本介绍 **意图：**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该
【设计模式】职责链模式
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为
【设计模式】享元模式
享元模式（Flyweight Pattern）（轻量级）（共享元素）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot