本文節選自《設計模式就該這樣學》
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彈架構 』可獲取更多技術干貨！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/356233.html
標籤：Java