【设计模式】抽象工厂模式(创建型)

抽象工程

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

模型图

 

 代码

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

public abstract class AbstractProductA {
   public abstract void show();  
}

public abstract class AbstractProductB {
	 public abstract void show();  
}

public class ConcreteFactory1  implements AbstractFactory{

	@Override
	public AbstractProductA createProductA() {
		// TODO Auto-generated method stub
		return new ProductA1();
	}

	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB1();
	}
}

public class ConcreteFactory2 implements AbstractFactory {

	@Override
	public AbstractProductA createProductA() {
		// TODO Auto-generated method stub
		return new ProductA2();
	}

	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	}
}

public class ProductA1 extends AbstractProductA {

	@Override
	public void show() {
		System.out.println("ProductA1");
	}

}

 

public class ProductA2 extends AbstractProductA{
	@Override
	public void show() {
		System.out.println("ProductA2");
	}
}

public class ProductB1 extends AbstractProductB{

	@Override
	public void show() {
		System.out.println("ProductB1");
	}

}

public class ProductB2 extends AbstractProductB {

	@Override
	public void show() {
		System.out.println("ProductB2");
	}
}

 

public class Test {
	public static void main(String[] args) {
		ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
		ConcreteFactory2 concreteFactory2 = new ConcreteFactory2();
		AbstractProductA createProductA1 = concreteFactory1.createProductA();
		AbstractProductB createProductB1 = concreteFactory1.createProductB();
		AbstractProductA createProductA2 = concreteFactory2.createProductA();
		AbstractProductB createProductB2 = concreteFactory2.createProductB();
		createProductA1.show();
		createProductA2.show();
		createProductB1.show();
		createProductB2.show();
	}
}

案例  完成一套系统，既要支持sqlserver数据库的系统存储操作，又要支持access数据库的系列存储操作

分析设计 仔细分析，可以把它看做是创建不同的数据库服务类，根据sqlserver与access，可以创建工厂模式

然而，你会发现创建出的不仅仅只是一个服务，而是一类服务包括用户服务，部门服务等等。此时我们可以把不同的服务归为一类，把它视为同一个服务下的不同产品，这就要求我们灵活运用工厂模式，形成抽象产品服务类，也就是我们所说的抽象工厂模式。

 

模型图

 

代码

public interface IFactory {
    public IUser createUser();
    public IDepartMent createDepart();
}

public interface IDepartMent {
    public void save();
}

public interface IUser {
	 public void save();
}

public class AccessDepartMent implements IDepartMent {
	@Override
	public void save() {
		System.out.println("AccessDepartMent");
	}
}

public class AccessFactory implements IFactory{
	@Override
	public IUser createUser() {
		return new AccessUser();
	}

	@Override
	public IDepartMent createDepart() {
		return new AccessDepartMent();
	}
}

public class AccessUser implements  IUser{
	@Override
	public void save() {
		System.out.println("AccessUser");
	}
}

public class SqlServerDepartMent implements IDepartMent {

	@Override
	public void save() {
		System.out.println("SqlServerDepartMent");
	}
}

 

public class SqlServerFactory implements IFactory{

	@Override
	public IUser createUser() {
		// TODO Auto-generated method stub
		return new SqlServerUser();
	}

	@Override
	public IDepartMent createDepart() {
		// TODO Auto-generated method stub
		return new SqlServerDepartMent();
	}
}

 

public class SqlServerUser implements IUser {
	@Override
	public void save() {
		System.out.println("SqlServerUser");
	}
}

 

 

public class Test {
  public static void main(String[] args) {
				IFactory accessfactory=new AccessFactory();
				IFactory sqlserverfactory=new SqlServerFactory();
				IDepartMent createDepart = accessfactory.createDepart();
				IUser createUser = accessfactory.createUser();
				IDepartMent createDepart2 = sqlserverfactory.createDepart();
				IUser createUser2 = sqlserverfactory.createUser();
				createDepart2.save();
				createUser2.save();
				createUser.save();
				createDepart.save();
  }
}

 小结

    利于交换产品系列，由于具体的工厂在一个应用只需要初始化一次，这使得改变一个应用的具体工厂非常容易，只需要改变不同的工厂就可以实现不同的产品配置。

   创建与实现松耦合，提高代码质量

  

缺点

    在增加新需求的时候改动的类太多 不太方便

简单工厂+抽象工厂

可以这样操作，取消具体的工厂，改用简单工厂的方式。通过db来创建爱不同数据库的服务类

最终stirng db也可以写到配置文件中