本文節選自《設計模式就該這樣學》
1 關於產品等級結構和產品族
在講解抽象工廠之前，我們要了解兩個概念：產品等級結構和產品族，如下圖所示。
上圖中有正方形、圓形和菱形3種圖形，相同顏色、相同深淺的代表同一個產品族，相同形狀的代表同一個產品等級結構。同樣可以從生活中來舉例，比如，美的電器生產多種家用電器，那么上圖中，顏色最深的正方形就代表美的洗衣機，顏色最深的圓形代表美的空調，顏色最深的菱形代表美的熱水器，顏色最深的一排都屬於美的品牌，都屬於美的電器這個產品族。再看最右側的菱形，顏色最深的被指定了代表美的熱水器，那么第二排顏色稍微淺一點的菱形代表海信熱水器。同理，同一產品族下還有格力洗衣機、格力空調、格力熱水器。
再看下圖，最左側的小房子被認為是具體的工廠，有美的工廠、海信工廠、格力工廠。每個品牌的工廠都生產洗衣機、空調和熱水器。
通過上面兩張圖的對比理解，相信大家對抽象工廠有了非常形象的理解。
2 抽象工廠模式的通用寫法
以下是抽象工廠模式的通用寫法。
public class Client {
public static void main(String[] args) {
IFactory factory = new ConcreteFactoryA();
factory.makeProductA();
factory.makeProductB();
factory = new ConcreteFactoryB();
factory.makeProductA();
factory.makeProductB();
}
//抽象工廠類
public interface IFactory {
IProductA makeProductA();
IProductB makeProductB();
}
//產品A抽象
public interface IProductA {
void doA();
}
//產品B抽象
public interface IProductB {
void doB();
}
//產品族A的具體產品A
static class ConcreteProductAWithFamilyA implements IProductA{
public void doA() {
System.out.println("The ProductA be part of FamilyA");
}
}
//產品族A的具體產品B
static class ConcreteProductBWithFamilyA implements IProductB{
public void doB() {
System.out.println("The ProductB be part of FamilyA");
}
}
//產品族B的具體產品A
static class ConcreteProductAWithFamilyB implements IProductA{
public void doA() {
System.out.println("The ProductA be part of FamilyB");
}
}
//產品族B的具體產品B
static class ConcreteProductBWithFamilyB implements IProductB{
public void doB() {
System.out.println("The ProductB be part of FamilyB");
}
}
//具體工廠類A
static class ConcreteFactoryA implements IFactory{
public IProductA makeProductA() {
return new ConcreteProductAWithFamilyA();
}
public IProductB makeProductB() {
return new ConcreteProductBWithFamilyA();
}
}
//具體工廠類B
static class ConcreteFactoryB implements IFactory{
public IProductA makeProductA() {
return new ConcreteProductAWithFamilyB();
}
public IProductB makeProductB() {
return new ConcreteProductBWithFamilyB();
}
}
}
3 使用抽象工廠模式支持產品擴展
我們來看一個具體的業務場景，並且用代碼來實現。還是以網絡課程為例，一般課程研發會有一定的標准，每個課程不僅要提供課程的錄播視頻，還要提供老師的課堂筆記。相當於現在的業務變更為同一個課程不單純是一個課程信息，要同時包含錄播視頻、課堂筆記，甚至要提供源碼才能構成一個完整的課程。首先在產品等級中增加兩個產品：錄播視頻IVideo和課堂筆記INote。
IVideo接口的代碼如下。
public interface IVideo {
void record();
}
INote接口的代碼如下。
public interface INote {
void edit();
}
然后創建一個抽象工廠CourseFactory類。
/**
* 抽象工廠是用戶的主入口
* 在Spring中應用得最為廣泛的一種設計模式
* 易於擴展
* Created by Tom
*/
public abstract class CourseFactory {
public void init(){
System.out.println("初始化基礎數據");
}
protected abstract INote createNote();
protected abstract IVideo createVideo();
}
接下來創建Java產品族，Java視頻JavaVideo類的代碼如下。
public class JavaVideo implements IVideo {
public void record() {
System.out.println("錄制Java視頻");
}
}
擴展產品等級Java課堂筆記JavaNote類。
public class JavaNote implements INote {
public void edit() {
System.out.println("編寫Java筆記");
}
}
創建Java產品族的具體工廠JavaCourseFactory。
public class JavaCourseFactory extends CourseFactory {
public INote createNote() {
super.init();
return new JavaNote();
}
public IVideo createVideo() {
super.init();
return new JavaVideo();
}
}
隨后創建Python產品族，Python視頻PythonVideo類的代碼如下。
public class PythonVideo implements IVideo {
public void record() {
System.out.println("錄制Python視頻");
}
}
擴展產品等級Python課堂筆記PythonNote類。
public class PythonNote implements INote {
public void edit() {
System.out.println("編寫Python筆記");
}
}
創建Python產品族的具體工廠PythonCourseFactory。
public class PythonCourseFactory implements CourseFactory {
public INote createNote() {
return new PythonNote();
}
public IVideo createVideo() {
return new PythonVideo();
}
}
最后來看客戶端調用代碼。
public static void main(String[] args) {
JavaCourseFactory factory = new JavaCourseFactory();
factory.createNote().edit();
factory.createVideo().record();
}
上面代碼完整地描述了Java課程和Python課程兩個產品族，也描述了視頻和筆記兩個產品等級。抽象工廠非常完美、清晰地描述了這樣一層復雜的關系。但是，不知道大家有沒有發現，如果再繼續擴展產品等級，將源碼Source也加入課程中，則代碼從抽象工廠到具體工廠要全部調整，這顯然不符合開閉原則。
4 使用抽象工廠模式重構數據庫連接池
還是演示課堂開始的JDBC操作案例，我們每次操作都需要重新創建數據庫連接。其實每次創建都非常耗費性能，消耗業務調用時間。我們使用抽象工廠模式，將數據庫連接預先創建好，放到容器中緩存着，當業務調用時就只需現取現用。我們來看代碼。
Pool抽象類的代碼如下。
/**
* 自定義連接池getInstance()返回POOL唯一實例，第一次調用時將執行構造函數
* 構造函數Pool()調用驅動裝載loadDrivers()函數；
* 連接池創建createPool()函數，loadDrivers()裝載驅動
* createPool()創建連接池，getConnection()返回一個連接實例，
* getConnection(long time)添加時間限制
* freeConnection(Connection con)將con連接實例返回連接池，getnum()返回空閑連接數
* getnumActive()返回當前使用的連接數
*
* @author Tom
*
*/
public abstract class Pool {
public String propertiesName = "connection-INF.properties";
private static Pool instance = null; //定義唯一實例
/**
* 最大連接數
*/
protected int maxConnect = 100; //最大連接數
/**
* 保持連接數
*/
protected int normalConnect = 10; //保持連接數
/**
* 驅動字符串
*/
protected String driverName = null; //驅動字符串
/**
* 驅動類
*/
protected Driver driver = null; //驅動變量
/**
* 私有構造函數，不允許外界訪問
*/
protected Pool() {
try
{
init();
loadDrivers(driverName);
}catch(Exception e)
{
e.printStackTrace();
}
}
/**
* 初始化所有從配置文件中讀取的成員變量
*/
private void init() throws IOException {
InputStream is = Pool.class.getResourceAsStream(propertiesName);
Properties p = new Properties();
p.load(is);
this.driverName = p.getProperty("driverName");
this.maxConnect = Integer.parseInt(p.getProperty("maxConnect"));
this.normalConnect = Integer.parseInt(p.getProperty("normalConnect"));
}
/**
* 裝載和注冊所有JDBC驅動程序
* @param dri 接收驅動字符串
*/
protected void loadDrivers(String dri) {
String driverClassName = dri;
try {
driver = (Driver) Class.forName(driverClassName).newInstance();
DriverManager.registerDriver(driver);
System.out.println("成功注冊JDBC驅動程序" + driverClassName);
} catch (Exception e) {
System.out.println("無法注冊JDBC驅動程序:" + driverClassName + ",錯誤:" + e);
}
}
/**
* 創建連接池
*/
public abstract void createPool();
/**
*
*（單例模式）返回數據庫連接池Pool的實例
*
* @param driverName 數據庫驅動字符串
* @return
* @throws IOException
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static synchronized Pool getInstance() throws IOException,
InstantiationException, IllegalAccessException,
ClassNotFoundException {
if (instance == null) {
instance = (Pool) Class.forName("org.e_book.sqlhelp.Pool").newInstance();
}
return instance;
}
/**
* 獲得一個可用的連接，如果沒有，則創建一個連接，並且小於最大連接限制
* @return
*/
public abstract Connection getConnection();
/**
* 獲得一個連接，有時間限制
* @param time 設置該連接的持續時間（以毫秒為單位）
* @return
*/
public abstract Connection getConnection(long time);
/**
* 將連接對象返回連接池
* @param con 獲得連接對象
*/
public abstract void freeConnection(Connection con);
/**
* 返回當前空閑的連接數
* @return
*/
public abstract int getnum();
/**
* 返回當前工作的連接數
* @return
*/
public abstract int getnumActive();
/**
* 關閉所有連接，撤銷驅動注冊（此方法為單例方法）
*/
protected synchronized void release() {
//撤銷驅動
try {
DriverManager.deregisterDriver(driver);
System.out.println("撤銷JDBC驅動程序 " + driver.getClass().getName());
} catch (SQLException e) {
System.out
.println("無法撤銷JDBC驅動程序的注冊:" + driver.getClass().getName());
}
}
}
DBConnectionPool數據庫連接池的代碼如下。
/**
* 數據庫連接池管理類
* @author Tom
*
*/
public final class DBConnectionPool extends Pool {
private int checkedOut; //正在使用的連接數
/**
* 存放產生的連接對象容器
*/
private Vector<Connection> freeConnections = new Vector<Connection>();
//存放產生的連接對象容器
private String passWord = null; //密碼
private String url = null; //連接字符串
private String userName = null; //用戶名
private static int num = 0; //空閑連接數
private static int numActive = 0; //當前可用的連接數
private static DBConnectionPool pool = null; //連接池實例變量
/**
* 產生數據連接池
* @return
*/
public static synchronized DBConnectionPool getInstance()
{
if(pool == null)
{
pool = new DBConnectionPool();
}
return pool;
}
/**
* 獲得一個數據庫連接池的實例
*/
private DBConnectionPool() {
try
{
init();
for (int i = 0; i < normalConnect; i++) { //初始normalConn個連接
Connection c = newConnection();
if (c != null) {
freeConnections.addElement(c); //往容器中添加一個連接對象
num++; //記錄總連接數
}
}
}catch(Exception e)
{
e.printStackTrace();
}
}
/**
* 初始化
* @throws IOException
*/
private void init() throws IOException
{
InputStream is = DBConnectionPool.class.getResourceAsStream(propertiesName);
Properties p = new Properties();
p.load(is);
this.userName = p.getProperty("userName");
this.passWord = p.getProperty("passWord");
this.driverName = p.getProperty("driverName");
this.url = p.getProperty("url");
this.driverName = p.getProperty("driverName");
this.maxConnect = Integer.parseInt(p.getProperty("maxConnect"));
this.normalConnect = Integer.parseInt(p.getProperty("normalConnect"));
}
/**
* 如果不再使用某個連接對象，則可調此方法將該對象釋放到連接池
* @param con
*/
public synchronized void freeConnection(Connection con) {
freeConnections.addElement(con);
num++;
checkedOut--;
numActive--;
notifyAll(); //解鎖
}
/**
* 創建一個新連接
* @return
*/
private Connection newConnection() {
Connection con = null;
try {
if (userName == null) { //用戶、密碼都為空
con = DriverManager.getConnection(url);
} else {
con = DriverManager.getConnection(url, userName, passWord);
}
System.out.println("連接池創建一個新的連接");
} catch (SQLException e) {
System.out.println("無法創建這個URL的連接" + url);
return null;
}
return con;
}
/**
* 返回當前空閑的連接數
* @return
*/
public int getnum() {
return num;
}
/**
* 返回當前可用的連接數
* @return
*/
public int getnumActive() {
return numActive;
}
/**
* （單例模式）獲取一個可用連接
* @return
*/
public synchronized Connection getConnection() {
Connection con = null;
if (freeConnections.size() > 0) { //還有空閑的連接
num--;
con = (Connection) freeConnections.firstElement();
freeConnections.removeElementAt(0);
try {
if (con.isClosed()) {
System.out.println("從連接池刪除一個無效連接");
con = getConnection();
}
} catch (SQLException e) {
System.out.println("從連接池刪除一個無效連接");
con = getConnection();
}
//沒有空閑連接且當前連接小於最大允許值，若最大值為0，則不限制
} else if (maxConnect == 0 || checkedOut < maxConnect) {
con = newConnection();
}
if (con != null) { //當前連接數加1
checkedOut++;
}
numActive++;
return con;
}
/**
* 獲取一個連接，並加上等待時間限制，時間為毫秒
* @param timeout 接受等待時間（以毫秒為單位）
* @return
*/
public synchronized Connection getConnection(long timeout) {
long startTime = new Date().getTime();
Connection con;
while ((con = getConnection()) == null) {
try {
wait(timeout); //線程等待
} catch (InterruptedException e) {
}
if ((new Date().getTime() - startTime) >= timeout) {
return null; //如果超時，則返回
}
}
return con;
}
/**
* 關閉所有連接
*/
public synchronized void release() {
try {
//將當前連接賦值到枚舉中
Enumeration allConnections = freeConnections.elements();
//使用循環關閉連接池中的所用連接
while (allConnections.hasMoreElements()) {
//如果此枚舉對象至少還有一個可提供的元素，則返回此枚舉的下一個元素
Connection con = (Connection) allConnections.nextElement();
try {
con.close();
num--;
} catch (SQLException e) {
System.out.println("無法關閉連接池中的連接");
}
}
freeConnections.removeAllElements();
numActive = 0;
} finally {
super.release();
}
}
/**
* 建立連接池
*/
public void createPool() {
pool = new DBConnectionPool();
if (pool != null) {
System.out.println("創建連接池成功");
} else {
System.out.println("創建連接池失敗");
}
}
}
5 抽象工廠模式在Spring源碼中的應用
在Spring中，所有工廠都是BeanFactory的子類。通過對BeanFactory的實現，我們可以從Spring的容器訪問Bean。根據不同的策略調用getBean()方法，從而獲得具體對象。
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
Object getBean(String name) throws BeansException;
<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBean DefinitionException;
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}
BeanFactory的子類主要有ClassPathXmlApplicationContext、XmlWebApplicationContext、StaticWebApplicationContext、StaticPortletApplicationContext、GenericApplicationContext和Static ApplicationContext。在Spring中，DefaultListableBeanFactory實現了所有工廠的公共邏輯。
關注微信公眾號『 Tom彈架構 』回復“設計模式”可獲取完整源碼。
本文為“Tom彈架構”原創，轉載請注明出處。技術在於分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支持是我堅持創作的動力。關注微信公眾號『 Tom彈架構 』可獲取更多技術干貨！