设计模式——工厂模式和抽象工厂模式

#Java设计模式——工厂模式
工厂模式和抽象工厂模式都属于创建型模式。

创建型模式
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

简单工厂模式

在简单工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
作用：

1、减少和复用代码：同一类复杂的对象（比如圆形、方形、三角形都属于图形；线性布局、相对布局都属于布局），如果它们在创建时都需要编写大量的步骤，那么可以考虑将它们的创建交给工厂去进行；
2、减少耦合度：两个类的关系最好是A创造B或者是A使用B，而不是A又创造B又使用B（单一职能原则）。比如我使用B时是直接new一个B对象，往后我们需求变更，需要将B替换为C，那么我就需要更改代码中new B为new C，这样的替换很麻烦也很容易出错。

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了；
2、屏蔽产品的具体实现，调用者只关心产品的接口；
3、简单粗暴，可以创建任何我们想要创建的对象。

缺点：

1、每次增加一个产品时，都需要修改工厂类，这违反了开闭原则，同时也增加了系统具体类的依赖。这并不是什么好事。

使用案例：
首先，我们现在有一个需求，要连接MySQL数据库，那么我们建一个连接MySQL数据库的类：

public class MySQLHelper {
	
	private String userName;
	private String passWord;
	
	public MySQLHelper(String userName, String password) {
		this.userName = userName;
		this.passWord = password;
	}
	
	public void setTimeout(long time) {
		 //Set TimeOut
	}
	
	public void setSelectMode(String mode) {
		// Set SelectMode
	}
	
	public void setCache(String cache) {
		// Set Cache
	}

	public void connect() {
		// Connect SQL
	}

	// ...  更多初始化操作

}

现在，我们在AConnectSQL类和BConnectSQL类中分别用不同的账号密码连接数据库：

AConnectSQL：

public class AConnectSQL {
	
	public void connect() {
		MySQLHelper mySQLHelper = new MySQLHelper("jack", "123");
		mySQLHelper.setTimeout(1000);
		mySQLHelper.setSelectMode("A Mode");
		mySQLHelper.setCache("ALL");
		mySQLHelper.connect();
	}

}

BConnectSQL：

public class BConnectSQL {
		
	public void connect() {
		MySQLHelper mySQLHelper = new MySQLHelper("lucy", "456");
		mySQLHelper.setTimeout(1000);
		mySQLHelper.setSelectMode("A Mode");
		mySQLHelper.setCache("ALL");
		mySQLHelper.connect();
	}

}

以上代码存在两个问题：
1、每一次创建MySQLHelper时，都需要编写大量初始化代码；
2、如果项目需求改动，要求不再所有的数据库连接都连接MySQL，而改用部分连接MySQL，部分连接SQLite，此时就需要将部分连接MySQL的地方都改成连接SQLite，一个两个类还好改，要是有更多的类，那么不仅工作量巨大，而且极有可能造成问题隐患。

此时，工厂模式就可以很好的解决如上两个问题。

首先，我们先建一个接口SQLHelper，只有一个connectSQL方法用于连接数据库：

public interface SQLHelper {
	
	void connectSQL();
	
}

然后，让我们的MySQLHelper实现这个接口，在重写的connectSQL中调用connect方法连接数据库：

public class MySQLHelper implements SQLHelper{
	
	private String userName;
	private String passWord;
	
	public MySQLHelper(String userName, String password) {
		this.userName = userName;
		this.passWord = password;
	}
	
	public void setTimeout(long time) {
		 //Set TimeOut
	}
	
	public void setSelectMode(String mode) {
		// Set SelectMode
	}
	
	public void setCache(String cache) {
		// Set Cache
	}

	public void connect() {
		// Connect SQL
	}

	// ...  更多初始化操作
	
	
	@Override
	public void connectSQL() {
		connect();
	}
}

接着，我们新建一个类似于MySQLHelper的类SQLiteHelper用于连接SQLite数据库，并且它也实现了SQLHelper这个接口：

public class SQLiteHelper implements SQLHelper {

	private String userName;
	private String passWord;
	
	public SQLiteHelper(String userName, String password) {
		this.userName = userName;
		this.passWord = password;
	}
	
	public void setTimeout(long time) {
		 //Set TimeOut
	}
	
	public void setSelectMode(String mode) {
		// Set SelectMode
	}
	
	public void setCache(String cache) {
		// Set Cache
	}

	public void connect() {
		// Connect SQL
	}

	// ...  更多初始化操作
	
	
	@Override
	public void connectSQL() {
		connect();
	}
}

好，我们接下来新建一个连接数据库的工厂类SQLHelperFactory：

public class SQLHelperFactory {
	
	public static final int TYPE_SQLITE = 0x0001;
	public static final int TYPE_MYSQL = 0x0002;
	
	public SQLHelper createSQLHelper(int type, String userName, String passWord) {
		if(type == TYPE_SQLITE) {
			MySQLHelper mySQLHelper = new MySQLHelper(userName, passWord);
			mySQLHelper.setTimeout(1000);
			mySQLHelper.setSelectMode("A Mode");
			mySQLHelper.setCache("ALL");
			return mySQLHelper;
		}else if(type == TYPE_MYSQL) {
			SQLiteHelper sqLiteHelper = new SQLiteHelper(userName, passWord);
			sqLiteHelper.setTimeout(1000);
			sqLiteHelper.setSelectMode("A Mode");
			sqLiteHelper.setCache("ALL");
			return sqLiteHelper;
		}
		
		return null;
	} 

}

然后，我们在需要使用这两种数据库连接的AConnectSQL和BConnectSQL代码更改成这样：

AConnectSQL:

public class AConnectSQL {
	
	public void connect() {
		SQLHelperFactory sqlHelperFactory = new SQLHelperFactory();
		SQLHelper sqlHelper = sqlHelperFactory.createSQLHelper(SQLHelperFactory.TYPE_SQLITE, "jack", "123");
		sqlHelper.connectSQL();
	}

}

BConnectSQL:

public class BConnectSQL {
		
	public void connect() {
		SQLHelperFactory sqlHelperFactory = new SQLHelperFactory();
		SQLHelper sqlHelper = sqlHelperFactory.createSQLHelper(SQLHelperFactory.TYPE_MYSQL, "lucy", "456");
		sqlHelper.connectSQL();
	}

}

这样，需要连接哪个数据库就从工厂中创造该类型的数据库即可。即使以后需要将SQLite换成Oracle也仅仅只是将SQLHelperFactory中的SQLite更改就行。

有的朋友也许会通过反射的写法写工厂类的方法：

public SQLHelper createSQLHelper2(Class<? extends SQLHelper> clazz) {
	SQLHelper sqlHelper = null;
	
	try {
		sqlHelper = (SQLHelper) Class.forName(clazz.getName()).newInstance();
	} catch (InstantiationException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IllegalAccessException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
	return sqlHelper;	
}

用的时候，这样调用：

SQLHelperFactory sqlHelperFactory = new SQLHelperFactory();
SQLHelper sqlHelper = sqlHelperFactory.createSQLHelper2(SQLiteHelper.class);

但是根据迪米特原则（越少知道越好），调用者是不知道有SQLiteHelper类存在的，如果他知道，那么为什么不直接new SQLiteHelper呢？所以，采用上述这种调用方法的模式，我认为背离了工厂模式的原则。

工厂模式

其实工厂模式和简单工厂模式类似，只是在简单工厂模式中，我们创建了一个类SQLHelperFactory用来创造我们需要的连接数据库的对象比如SQLiteHelper或者MySQLHelper。
而在工厂模式中，我们是把SQLHelperFactory也抽象化，而会针对不同的数据库创建不同的具体工厂，通过具体工厂来创造我们需要的对象。

因为在简单工厂模式中，我们其实可以返回任何我们想要的对象，如果我们想要生产一辆飞机，只需要在判断时传入Type为飞机，同时在create方法中返回飞机的对象就行。而我们的工厂的目的明明是返回SQLHelper。因此，工厂模式就很好的解决了这个问题。

优点：

1、减轻工厂类的负担，某一类对象交给某一类的工厂去生产；
2、增加新的分类时不用修改工厂类，只需要修改某一类的工厂，符合开闭原则。

缺点：
1、每新增一个分类，就需要增加分类的工厂和产品类，造成代码量成倍增加。

使用场景：
首先，我们把类SQLHelperFactory更改成抽象类SQLHelperFactory：

public abstract class SQLHelperFactory {
	
	public abstract SQLHelper createSQLHelper(String username, String password);
}

然后，我们创建两个类SQLiteHelperFactory和MySQLHelperFactory两个工厂类，它们的作用分别是用来生产SQLiteHelper和MySQLHelper：

SQLiteHelperFactory：

public class SQLiteHelperFactory extends SQLHelperFactory{

	@Override
	public SQLHelper createSQLHelper(String username, String password) {
		SQLiteHelper sqLiteHelper = new SQLiteHelper(username, password);
		sqLiteHelper.setTimeout(1000);
		sqLiteHelper.setSelectMode("A Mode");
		sqLiteHelper.setCache("ALL");
		return sqLiteHelper;
	}

}

MySQLHelperFactory：

public class MySQLHelperFactory extends SQLHelperFactory{

	@Override
	public SQLHelper createSQLHelper(String username, String password) {
		MySQLHelper mySQLHelper = new MySQLHelper(username, password);
		mySQLHelper.setTimeout(1000);
		mySQLHelper.setSelectMode("A Mode");
		mySQLHelper.setCache("ALL");
		return mySQLHelper;
	}

}

使用的时候：

public class AConnectSQL {
	
	public void connect() {
		SQLiteHelperFactory sqLiteHelperFactory = new SQLiteHelperFactory();
		sqLiteHelperFactory.createSQLHelper("jack", "123");
		SQLHelper sqlHelper = sqLiteHelperFactory.createSQLHelper("jack", "123");
		sqlHelper.connectSQL();
	}

}

抽象工厂

在工厂模式中，我们将每一个不同的数据库都更改为一个单独的工厂。这样做，我们避免了“超级工厂”的存在，仅仅针对不同产品，提供不同的工厂。

而抽象工厂的出现，是在工厂模式的基础上又进一步抽象——抽象工厂将工厂和产品都抽象化了，创造一系列相互依赖的接口或类，而无需指明它们具体的实现类。

比如，我们在工厂模式中，我们假设现在是在Android系统上连接数据库，那么此时我们仅仅对每一个不同的数据库做一个单独的工厂，如果我们现在切换到IOS系统上，可能此时连接数据库的方式又变了，那么此时我们在Android系统上所写的连接数据库的方法可能就不管用了，需要重新写工厂模式，而抽象工厂则是把工厂再抽象一层，每一个工厂都有连接MySQL和SQLite的方法，而具体是哪个系统去连接，则交给他们自己去实现。
因此，可以说，工厂模式是针对一个产品，抽象工厂是针对多个产品。

优点：
同工厂模式。

缺点：
扩展极其困难。

使用场景：
比如我们针对MySQL和SQLite都生产了不同的工厂，那么，如果我们在不同的操作系统（Android,IOS等）上连接数据库的方式不同，那么此时就不在使用工厂模式，而使用抽象工厂模式了。

1、首先，我们新建一个抽象产品类ConnectMySQLHelper，用来连接MySQL数据库：

public abstract class ConnectMySQLHelper {
	
	public abstract void connectMySQL();

}

然后建两个实体类AndroidConnectMySQLHelper和IOSConnectMySQLHelper分别实现去连接Android和IOS的方法：

AndroidConnectMySQLHelper：

public class AndroidConnectMySQLHelper extends ConnectMySQLHelper {

	@Override
	public void connectMySQL() {
		System.out.println("Android connect MySQL");
	}

}

IOSConnectMySQLHelper：

public class IOSConnectMySQLHelper extends ConnectMySQLHelper{

	@Override
	public void connectMySQL() {
		System.out.println("IOS connect MySQL");
	}

}

2、同样的，我们也要像步骤1一样建立一个抽象类ConnectSQLiteHelper和两个实体类AndroidConnectSQLiteHelper，IOSConnectSQLiteHelper分别去连接SQLite数据库。

3、创建一个抽象工厂类，用来连接MySQL和SQLite：

public abstract class AbstractSQLFactory {
	
	public abstract ConnectMySQLHelper connectMySQL();
	
	public abstract ConnectSQLiteHelper connectSQLite();

}

4、分别创建Andoird和IOS连接两个数据库的工厂类：

AndroidSQLFactory：

public class AndroidSQLFactory extends AbstractSQLFactory {

	@Override
	public ConnectMySQLHelper connectMySQL() {
		return new AndroidConnectMySQLHelper();
	}

	@Override
	public ConnectSQLiteHelper connectSQLite() {
		return new AndroidConnectSQLiteHelper();
	}

}

IOSSQLFactory：

public class IOSSQLFactory extends AbstractSQLFactory {

	@Override
	public ConnectMySQLHelper connectMySQL() {
		return new IOSConnectMySQLHelper();
	}

	@Override
	public ConnectSQLiteHelper connectSQLite() {
		return new IOSConnectSQLiteHelper();
	}

}

抽象工厂模式，我个人也掌握的不是很好，没有理解它的精髓，但是却看到了它扩展很难的一面（比如此时我再来一个Windows系统，又需要从AbstractSQLFactory那一层开始更改起），因此，我不打算在自己的编码中引入这种模式。