抽象工厂模式

一、定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式属于对象创建型模式。

 

二、模式简介

模式动机：在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。

产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。

产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

 

三、抽象工厂模式结构图

抽象工厂模式包含角色：

抽象工厂(Abstract Factory)：声明生成一系列抽象产品的方法。

具体工厂(Concrete Factory)：执行生成一系列抽象产品的方法，生成一系列具体的产品。

抽象产品(Abstract Product)：为这一系列的某一种产品声明接口。

具体产品(Product)：定义具体工厂生成的具体产品的对象，实现产品接口。

四、实例

抽象工厂

public interface IFactory {
	public IUser createUser();
	public ILogin createLogin();
}

具体工厂

public class MysqlFactory implements IFactory {

	@Override
	public IUser createUser() {
		return new MysqlUser();
	}

	@Override
	public ILogin createLogin() {
		return new MysqlLogin();
	}

}

public class OracleFactory implements IFactory {

	@Override
	public IUser createUser() {
		return new OracleUser();
	}

	@Override
	public ILogin createLogin() {
		return new OracleLogin();
	}

}

抽象产品

public interface ILogin {
	public void insert(Login login);
	public Login getLogin(Login login);
}

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

具体工厂

public class MysqlLogin implements ILogin {

	@Override
	public void insert(Login login) {
		System.out.println("对MySQL里的Login表插入了一条数据");
	}

	@Override
	public Login getLogin(Login login) {
		System.out.println("通过uid在MySQL里的Login表得到了一条数据");
		return null;
	}

}

public class MysqlUser implements IUser {

	@Override
	public void insert(User user) {
		System.out.println("对MySQL里的User表插入了一条数据");
	}

	@Override
	public IUser getUser(int uid) {
		System.out.println("通过uid在MySQL里的User表得到了一条数据");
		return null;
	}

}

public class OracleLogin implements ILogin {

	@Override
	public void insert(Login login) {
		System.out.println("对Oracle里的Login表插入了一条数据");
	}

	@Override
	public Login getLogin(Login login) {
		System.out.println("通过uid在Oracle里的Login表得到了一条数据");
		return null;
	}

}

public class OracleUser implements IUser {

	@Override
	public void insert(User user) {
		System.out.println("对Oracle里的User表插入了一条数据");
	}

	@Override
	public IUser getUser(int uid) {
		System.out.println("通过uid在Oracle里的User表得到了一条数据");
		return null;
	}

}

实体类

public class Login {
	private int id;
	private String date;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getDate() {
		return date;
	}
	public void setDate(String date) {
		this.date = date;
	}
	
}

public class User {
	private int uid;
	private String uname;
	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
}

测试类

public class Test {

	public static void main(String[] args) {
		User user = new User();
		Login login = new Login();
		
		// 只需要确定实例化哪一个数据库访问对象给factory
		IFactory factory = new MysqlFactory();
		/*IFactory factory = new OracleFactory();*/
		
		// 已与具体的数据库访问解除了耦合
		IUser userOperation = factory.createUser();
		
		userOperation.getUser(1);
		userOperation.insert(user);
		
		// 已与具体的数据库访问解除了耦合
		ILogin loginOperation = factory.createLogin();
		loginOperation.insert(login);
		loginOperation.getLogin(login);
		
	}

}

五、抽象工厂模式优缺点

优点：

1. 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
3. 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：

1. 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
2. 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）

 

适用情况：

1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。 
2. 系统中有多于一个的产品族，而每次只使用其中某一产品族。
3. 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
4. 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。