本文節選自《設計模式就該這樣學》
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彈架構 』可獲取更多技術乾貨！