将关联零件组装成产品的 Abstract Factory模式

Abstract Factory模式

应用场景

• 希望一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节时。
• 一个系统有多于一个的产品族， 而系统只消费其中某一产品族。

本质

• 选择产品族的实现

优点

• 增加产品族: Abstract Factory很好的支持了"开放一封闭"原则。

缺点

• 增加新产品的等级结构:需要修改所有的工厂角色，没有很好支持“开放一封闭”原则。

角色

• 产品族(Product Family)：
  所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。

• 抽象工厂(Abstract Factory)角色:
  担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

• 具体工厂(Concrete Factory) 角色:
  这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

• 抽象产品( Abstract Product)角色:
  担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

• 具体产品( Concrete Product)角色:
  抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满不应用系统的商业逻辑。

Abstract Factory模式的类图

示例程序

示例程序的类图

示例代码

public class User {

	private int id;
	private String name;
	public User() {}
	public User(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

public interface IUser {
	void insert(User user);
	void getUser(int id);
}

public class AccessUser implements IUser {

	@Override
	public void insert(User user) {
		System.out.println("Access --> INSERT INTO user( id , name ) VALUES( " + user.getId() + " , " + user.getName() + " )");
	}

	@Override
	public void getUser(int id) {
		System.out.println("Access --> SELECT * FROM user WHERE ID = " + id);
	}

}

public class SqlServerUser implements IUser {

	@Override
	public void insert(User user) {
		System.out.println("SQLServer --> INSERT INTO user( id , name ) VALUES( " + user.getId() + " , " + user.getName() + " )");
	}

	@Override
	public void getUser(int id) {
		System.out.println("SQLServer --> SELECT * FROM user WHERE ID = " + id);
	}

}

public class Department {

	private int id;
	private String name;
	public Department() {}
	public Department(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

public interface IDepartment {

	void insert(Department department);
	void getDepartment(int id);
}

public class AccessDepartment implements IDepartment {

	@Override
	public void insert(Department department) {
		System.out.println("Access --> INSERT INTO department( id , name ) VALUES( " + department.getId() + " , " + department.getName() + " )");

	}

	@Override
	public void getDepartment(int id) {
		System.out.println("Access --> SELECT * FROM department WHERE ID = " + id);

	}
}

public class SqlServerDepartment implements IDepartment {

	@Override
	public void insert(Department department) {
		System.out.println("SQLServer --> INSERT INTO department( id , name ) VALUES( " + department.getId() + " , " + department.getName() + " )");

	}

	@Override
	public void getDepartment(int id) {
		System.out.println("SQLServer --> SELECT * FROM department WHERE ID = " + id);

	}
}

public interface IFactory {

	IUser creatUser();
	IDepartment creatDepartment();
}

public class AccessFactory implements IFactory {

	@Override
	public IUser creatUser() {
		return  new AccessUser();
	}

	@Override
	public IDepartment creatDepartment() {
		return new AccessDepartment();
	}

}

public class SqlServerFactory implements IFactory {

	@Override
	public IDepartment creatDepartment() {
		return new SqlServerDepartment();
	}

	@Override
	public IUser creatUser() {
		return new SqlServerUser();
	}
}

public static void main(String[] args) {
		        /**
		         * 使用抽象工厂模式
		         * 更改生成的工厂类别即可更换数据库
		         */
		        User user = new User();
		        //IFactory factory = new SqlServerFactory();
		        IFactory factory = new AccessFactory();
		        IUser iUser = factory.creatUser();
		        iUser.insert(user);
		        iUser.getUser(1);

		        Department department = new Department();
		        IDepartment iDepartment = factory.creatDepartment();
		        iDepartment.insert(department);
		        iDepartment.getDepartment(1);
		    }

拓展思路

• 易于增加具体的工厂
• 难以增加新的零件

相关设计模式

• Builder 模式(第7章)
  Abstract Factory模式通过调用抽象产品的接口( API )来组装抽象产品，生成具有复杂结构的实例。
  Builder模式则是分阶段地制作复杂实例。

• Factory Method模式(第4章)
  有时Abstract Factory模式中零件和产品的生成会使用到Factory Method模式。

• Composite模式(第11章)
  有时Abstract Factory模式在制作产品时会使用Composite 模式。

• Singleton 模式(第5章)
  有时Abstract Factory模式中的具体工厂”会使用Singleton模式。

满足的原则

• 开放封闭原则