2. 程式人生 > >Mybatis 使用的 9 種設計模式

Mybatis 使用的 9 種設計模式

阿新 • • 發佈：2019-04-16

雖然我們都知道有26個設計模式，但是大多停留在概念層面，真實開發中很少遇到，Mybatis原始碼中使用了大量的設計模式，閱讀原始碼並觀察設計模式在其中的應用，能夠更深入的理解設計模式。

Mybatis至少遇到了以下的設計模式的使用：

  1. Builder模式，例如SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder；

  2. 工廠模式，例如SqlSessionFactory、ObjectFactory、MapperProxyFactory；

  3. 單例模式，例如ErrorContext和LogFactory；

  4. 代理模式，Mybatis實現的核心，比如MapperProxy、ConnectionLogger，用的jdk的動態代理；還有executor.loader包使用了cglib或者javassist達到延遲載入的效果；

  5. 組合模式，例如SqlNode和各個子類ChooseSqlNode等；

  6. 模板方法模式，例如BaseExecutor和SimpleExecutor，還有BaseTypeHandler和所有的子類例如IntegerTypeHandler；

  7. 介面卡模式，例如Log的Mybatis介面和它對jdbc、log4j等各種日誌框架的適配實現；

  8. 裝飾者模式，例如Cache包中的cache.decorators子包中等各個裝飾者的實現；

  9. 迭代器模式，例如迭代器模式PropertyTokenizer；

 

接下來挨個模式進行解讀，先介紹模式自身的知識，然後解讀在Mybatis中怎樣應用了該模式。 

1、Builder模式

Builder模式的定義是“將一個複雜物件的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示。”，它屬於建立類模式，一般來說，如果一個物件的構建比較複雜，超出了建構函式所能包含的範圍，就可以使用工廠模式和Builder模式，相對於工廠模式會產出一個完整的產品，Builder應用於更加複雜的物件的構建，甚至只會構建產品的一個部分。

在Mybatis環境的初始化過程中，SqlSessionFactoryBuilder會呼叫XMLConfigBuilder讀取所有的MybatisMapConfig.xml和所有的*Mapper.xml檔案，構建Mybatis執行的核心物件Configuration物件，然後將該Configuration物件作為引數構建一個SqlSessionFactory物件。

其中XMLConfigBuilder在構建Configuration物件時，也會呼叫XMLMapperBuilder用於讀取*Mapper檔案，而XMLMapperBuilder會使用XMLStatementBuilder來讀取和build所有的SQL語句。

在這個過程中，有一個相似的特點，就是這些Builder會讀取檔案或者配置，然後做大量的XpathParser解析、配置或語法的解析、反射生成物件、存入結果快取等步驟，這麼多的工作都不是一個建構函式所能包括的，因此大量採用了Builder模式來解決。

對於builder的具體類，方法都大都用build*開頭，比如SqlSessionFactoryBuilder為例，它包含以下方法：

即根據不同的輸入引數來構建SqlSessionFactory這個工廠物件。

2、工廠模式

在Mybatis中比如SqlSessionFactory使用的是工廠模式，該工廠沒有那麼複雜的邏輯，是一個簡單工廠模式。

簡單工廠模式(Simple Factory Pattern)：又稱為靜態工廠方法(Static Factory Method)模式，它屬於類建立型模式。在簡單工廠模式中，可以根據引數的不同返回不同類的例項。簡單工廠模式專門定義一個類來負責建立其他類的例項，被建立的例項通常都具有共同的父類。

SqlSession可以認為是一個Mybatis工作的核心的介面，通過這個介面可以執行執行SQL語句、獲取Mappers、管理事務。類似於連線MySQL的Connection物件。從 0 開始手寫一個 Mybatis 框架，這個我推薦你看下。

 

 

可以看到，該Factory的openSession方法過載了很多個，分別支援autoCommit、Executor、Transaction等引數的輸入，來構建核心的SqlSession物件。

 

在DefaultSqlSessionFactory的預設工廠實現裡，有一個方法可以看出工廠怎麼產出一個產品：

 

 

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level,
     boolean autoCommit) {
   Transaction tx = null;
   try {
     final Environment environment = configuration.getEnvironment();
     final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
     tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
     final Executor executor = configuration.newExecutor(tx, execType);
     return new DefaultSqlSession(configuration, executor, autoCommit);
   } catch (Exception e) {
     closeTransaction(tx); // may have fetched a connection so lets call
                 // close()
     throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
   } finally {
     ErrorContext.instance().reset();
   }
 }

 

這是一個openSession呼叫的底層方法，該方法先從configuration讀取對應的環境配置，然後初始化TransactionFactory獲得一個Transaction物件，然後通過Transaction獲取一個Executor物件，最後通過configuration、Executor、是否autoCommit三個引數構建了SqlSession。

 

在這裡其實也可以看到端倪，SqlSession的執行，其實是委託給對應的Executor來進行的。

而對於LogFactory，它的實現程式碼：

 

public final class LogFactory {
 private static Constructor<? extends Log> logConstructor;

 private LogFactory() {
   // disable construction
 }

 public static Log getLog(Class<?> aClass) {
   return getLog(aClass.getName());
 }

 

這裡有個特別的地方，是Log變數的的型別是Constructor<? extends Log>，也就是說該工廠生產的不只是一個產品，而是具有Log公共介面的一系列產品，比如Log4jImpl、Slf4jImpl等很多具體的Log。

 

3、單例模式

單例模式(Singleton Pattern)：單例模式確保某一個類只有一個例項，而且自行例項化並向整個系統提供這個例項，這個類稱為單例類，它提供全域性訪問的方法。

單例模式的要點有三個：一是某個類只能有一個例項；二是它必須自行建立這個例項；三是它必須自行向整個系統提供這個例項。單例模式是一種物件建立型模式。單例模式又名單件模式或單態模式。

在Mybatis中有兩個地方用到單例模式，ErrorContext和LogFactory，其中ErrorContext是用在每個執行緒範圍內的單例，用於記錄該執行緒的執行環境錯誤資訊，而LogFactory則是提供給整個Mybatis使用的日誌工廠，用於獲得針對專案配置好的日誌物件。設計模式之單例模式實踐，這篇文章推薦你看下。

ErrorContext的單例實現程式碼：

 

public class ErrorContext {

 private static final ThreadLocal<ErrorContext> LOCAL = new ThreadLocal<ErrorContext>();

 private ErrorContext() {
 }

 public static ErrorContext instance() {
   ErrorContext context = LOCAL.get();
   if (context == null) {
     context = new ErrorContext();
     LOCAL.set(context);
   }
   return context;
 }

 

建構函式是private修飾，具有一個static的區域性instance變數和一個獲取instance變數的方法，在獲取例項的方法中，先判斷是否為空如果是的話就先建立，然後返回構造好的物件。

 

只是這裡有個有趣的地方是，LOCAL的靜態例項變數使用了ThreadLocal修飾，也就是說它屬於每個執行緒各自的資料，而在instance()方法中，先獲取本執行緒的該例項，如果沒有就建立該執行緒獨有的ErrorContext。

4、代理模式

代理模式可以認為是Mybatis的核心使用的模式，正是由於這個模式，我們只需要編寫Mapper.java介面，不需要實現，由Mybatis後臺幫我們完成具體SQL的執行。

代理模式(Proxy Pattern) ：給某一個物件提供一個代 理，並由代理物件控制對原物件的引用。代理模式的英 文叫做Proxy或Surrogate，它是一種物件結構型模式。

代理模式包含如下角色：

  • Subject: 抽象主題角色

  • Proxy: 代理主題角色

  • RealSubject: 真實主題角色

     

這裡有兩個步驟，第一個是提前建立一個Proxy，第二個是使用的時候會自動請求Proxy，然後由Proxy來執行具體事務；

當我們使用Configuration的getMapper方法時，會呼叫mapperRegistry.getMapper方法，而該方法又會呼叫mapperProxyFactory.newInstance(sqlSession)來生成一個具體的代理：

 

/**
* @author Lasse Voss
*/
public class MapperProxyFactory<T> {

 private final Class<T> mapperInterface;
 private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();

 public MapperProxyFactory(Class<T> mapperInterface) {
   this.mapperInterface = mapperInterface;
 }

 public Class<T> getMapperInterface() {
   return mapperInterface;
 }

 public Map<Method, MapperMethod> getMethodCache() {
   return methodCache;
 }

 @SuppressWarnings("unchecked")
 protected T newInstance(MapperProxy<T> mapperProxy) {
   return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface },
       mapperProxy);
 }

 public T newInstance(SqlSession sqlSession) {
   final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
   return newInstance(mapperProxy);
 }

}

 

在這裡，先通過T newInstance(SqlSession sqlSession)方法會得到一個MapperProxy物件，然後呼叫T newInstance(MapperProxy<T> mapperProxy)生成代理物件然後返回。

而檢視MapperProxy的程式碼，可以看到如下內容：

 

public class MapperProxy<T> implements InvocationHandler, Serializable {

 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   try {
     if (Object.class.equals(method.getDeclaringClass())) {
       return method.invoke(this, args);
     } else if (isDefaultMethod(method)) {
       return invokeDefaultMethod(proxy, method, args);
     }
   } catch (Throwable t) {
     throw ExceptionUtil.unwrapThrowable(t);
   }
   final MapperMethod mapperMethod = cachedMapperMethod(method);
   return mapperMethod.execute(sqlSession, args);
 }

 

非常典型的，該MapperProxy類實現了InvocationHandler介面，並且實現了該介面的invoke方法。

 

通過這種方式，我們只需要編寫Mapper.java介面類，當真正執行一個Mapper介面的時候，就會轉發給MapperProxy.invoke方法，而該方法則會呼叫後續的sqlSession.cud>executor.execute>prepareStatement等一系列方法，完成SQL的執行和返回。

5、組合模式

組合模式組合多個物件形成樹形結構以表示“整體-部分”的結構層次。

組合模式對單個物件(葉子物件)和組合物件(組合物件)具有一致性，它將物件組織到樹結構中，可以用來描述整體與部分的關係。同時它也模糊了簡單元素(葉子物件)和複雜元素(容器物件)的概念，使得客戶能夠像處理簡單元素一樣來處理複雜元素，從而使客戶程式能夠與複雜元素的內部結構解耦。

在使用組合模式中需要注意一點也是組合模式最關鍵的地方：葉子物件和組合物件實現相同的介面。這就是組合模式能夠將葉子節點和物件節點進行一致處理的原因。

Mybatis支援動態SQL的強大功能，比如下面的這個SQL：

 

<update id="update" parameterType="org.format.dynamicproxy.mybatis.bean.User">
   UPDATE users
   <trim prefix="SET" prefixOverrides=",">
       <if test="name != null and name != ''">
           name = #{name}
       </if>
       <if test="age != null and age != ''">
           , age = #{age}
       </if>
       <if test="birthday != null and birthday != ''">
           , birthday = #{birthday}
       </if>
   </trim>
   where id = ${id}
</update>

 

在這裡面使用到了trim、if等動態元素，可以根據條件來生成不同情況下的SQL；

 

在DynamicSqlSource.getBoundSql方法裡，呼叫了rootSqlNode.apply(context)方法，apply方法是所有的動態節點都實現的介面：

 

public interface SqlNode {
 boolean apply(DynamicContext context);
}

 

對於實現該SqlSource介面的所有節點，就是整個組合模式樹的各個節點：

 

 

組合模式的簡單之處在於，所有的子節點都是同一類節點，可以遞迴的向下執行，比如對於TextSqlNode，因為它是最底層的葉子節點，所以直接將對應的內容append到SQL語句中：

 

@Override
 public boolean apply(DynamicContext context) {
   GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
   context.appendSql(parser.parse(text));
   return true;
 }

 

但是對於IfSqlNode，就需要先做判斷，如果判斷通過，仍然會呼叫子元素的SqlNode，即contents.apply方法，實現遞迴的解析。

 

@Override
 public boolean apply(DynamicContext context) {
   if (evaluator.evaluateBoolean(test, context.getBindings())) {
     contents.apply(context);
     return true;
   }
   return false;
 }

 

6、模板方法模式

模板方法模式是所有模式中最為常見的幾個模式之一，是基於繼承的程式碼複用的基本技術。關注Java技術棧微信公眾號，在後臺回覆關鍵字：架構，可以獲取更多棧長整理的架構和設計模式乾貨。

模板方法模式需要開發抽象類和具體子類的設計師之間的協作。一個設計師負責給出一個演算法的輪廓和骨架，另一些設計師則負責給出這個演算法的各個邏輯步驟。代表這些具體邏輯步驟的方法稱做基本方法(primitive method)；而將這些基本方法彙總起來的方法叫做模板方法(template method)，這個設計模式的名字就是從此而來。

模板類定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。

在Mybatis中，sqlSession的SQL執行，都是委託給Executor實現的，Executor包含以下結構：

其中的BaseExecutor就採用了模板方法模式，它實現了大部分的SQL執行邏輯，然後把以下幾個方法交給子類定製化完成：

 

protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;

protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;

protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds,
     ResultHandler resultHandler, BoundSql boundSql) throws SQLException;

 

該模板方法類有幾個子類的具體實現，使用了不同的策略：

  • 簡單SimpleExecutor：每執行一次update或select，就開啟一個Statement物件，用完立刻關閉Statement物件。（可以是Statement或PrepareStatement物件）

  • 重用ReuseExecutor：執行update或select，以sql作為key查詢Statement物件，存在就使用，不存在就建立，用完後，不關閉Statement物件，而是放置於Map<String, Statement>內，供下一次使用。（可以是Statement或PrepareStatement物件）

  • 批量BatchExecutor：執行update（沒有select，JDBC批處理不支援select），將所有sql都新增到批處理中（addBatch()），等待統一執行（executeBatch()），它快取了多個Statement物件，每個Statement物件都是addBatch()完畢後，等待逐一執行executeBatch()批處理的；BatchExecutor相當於維護了多個桶，每個桶裡都裝了很多屬於自己的SQL，就像蘋果藍裡裝了很多蘋果，番茄藍裡裝了很多番茄，最後，再統一倒進倉庫。（可以是Statement或PrepareStatement物件）

 

比如在SimpleExecutor中這樣實現update方法：

 

@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
   Statement stmt = null;
   try {
     Configuration configuration = ms.getConfiguration();
     StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null,
         null);
     stmt = prepareStatement(handler, ms.getStatementLog());
     return handler.update(stmt);
   } finally {
     closeStatement(stmt);
   }
 }

 

7、介面卡模式

介面卡模式(Adapter Pattern) ：將一個介面轉換成客戶希望的另一個介面，介面卡模式使介面不相容的那些類可以一起工作，其別名為包裝器(Wrapper)。介面卡模式既可以作為類結構型模式，也可以作為物件結構型模式。

在Mybatsi的logging包中，有一個Log介面：

 

/**
* @author Clinton Begin
*/
public interface Log {

 boolean isDebugEnabled();

 boolean isTraceEnabled();

 void error(String s, Throwable e);

 void error(String s);

 void debug(String s);

 void trace(String s);

 void warn(String s);

}

 

該介面定義了Mybatis直接使用的日誌方法，而Log介面具體由誰來實現呢？Mybatis提供了多種日誌框架的實現，這些實現都匹配這個Log介面所定義的介面方法，最終實現了所有外部日誌框架到Mybatis日誌包的適配：

 

比如對於Log4jImpl的實現來說，該實現持有了org.apache.log4j.Logger的例項，然後所有的日誌方法，均委託該例項來實現。

 

public class Log4jImpl implements Log {

 private static final String FQCN = Log4jImpl.class.getName();

 private Logger log;

 public Log4jImpl(String clazz) {
   log = Logger.getLogger(clazz);
 }

 @Override
 public boolean isDebugEnabled() {
   return log.isDebugEnabled();
 }

 @Override
 public boolean isTraceEnabled() {
   return log.isTraceEnabled();
 }

 @Override
 public void error(String s, Throwable e) {
   log.log(FQCN, Level.ERROR, s, e);
 }

 @Override
 public void error(String s) {
   log.log(FQCN, Level.ERROR, s, null);
 }

 @Override
 public void debug(String s) {
   log.log(FQCN, Level.DEBUG, s, null);
 }

 @Override
 public void trace(String s) {
   log.log(FQCN, Level.TRACE, s, null);
 }

 @Override
 public void warn(String s) {
   log.log(FQCN, Level.WARN, s, null);
 }

}

 

8、裝飾者模式

 

裝飾模式(Decorator Pattern) ：動態地給一個物件增加一些額外的職責(Responsibility)，就增加物件功能來說，裝飾模式比生成子類實現更為靈活。其別名也可以稱為包裝器(Wrapper)，與介面卡模式的別名相同，但它們適用於不同的場合。根據翻譯的不同，裝飾模式也有人稱之為“油漆工模式”，它是一種物件結構型模式。

 

在mybatis中，快取的功能由根介面Cache（org.apache.ibatis.cache.Cache）定義。關注Java技術棧微信公眾號，在後臺回覆關鍵字：架構，可以獲取更多棧長整理的架構和設計模式乾貨。

整個體系採用裝飾器設計模式，資料儲存和快取的基本功能由PerpetualCache（org.apache.ibatis.cache.impl.PerpetualCache）永久快取實現，然後通過一系列的裝飾器來對PerpetualCache永久快取進行快取策略等方便的控制。如下圖：

用於裝飾PerpetualCache的標準裝飾器共有8個（全部在org.apache.ibatis.cache.decorators包中）：

  1. FifoCache：先進先出演算法，快取回收策略

  2. LoggingCache：輸出快取命中的日誌資訊

  3. LruCache：最近最少使用演算法，快取回收策略

  4. ScheduledCache：排程快取，負責定時清空快取

  5. SerializedCache：快取序列化和反序列化儲存

  6. SoftCache：基於軟引用實現的快取管理策略

  7. SynchronizedCache：同步的快取裝飾器，用於防止多執行緒併發訪問

  8. WeakCache：基於弱引用實現的快取管理策略

 

另外，還有一個特殊的裝飾器TransactionalCache：事務性的快取

正如大多數持久層框架一樣，mybatis快取同樣分為一級快取和二級快取

  • 一級快取，又叫本地快取，是PerpetualCache型別的永久快取，儲存在執行器中（BaseExecutor），而執行器又在SqlSession（DefaultSqlSession）中，所以一級快取的生命週期與SqlSession是相同的。

  • 二級快取，又叫自定義快取，實現了Cache介面的類都可以作為二級快取，所以可配置如encache等的第三方快取。二級快取以namespace名稱空間為其唯一標識，被儲存在Configuration核心配置物件中。

 

二級快取物件的預設型別為PerpetualCache，如果配置的快取是預設型別，則mybatis會根據配置自動追加一系列裝飾器。

Cache物件之間的引用順序為：

SynchronizedCache–>LoggingCache–>SerializedCache–>ScheduledCache–>LruCache–>PerpetualCache

9、迭代器模式

迭代器（Iterator）模式，又叫做遊標（Cursor）模式。GOF給出的定義為：提供一種方法訪問一個容器（container）物件中各個元素，而又不需暴露該物件的內部細節。 

Java的Iterator就是迭代器模式的介面，只要實現了該介面，就相當於應用了迭代器模式：

比如Mybatis的PropertyTokenizer是property包中的重量級類，該類會被reflection包中其他的類頻繁的引用到。這個類實現了Iterator介面，在使用時經常被用到的是Iterator介面中的hasNext這個函式。

 

public class PropertyTokenizer implements Iterator<PropertyTokenizer> {
 private String name;
 private String indexedName;
 private String index;
 private String children;

 public PropertyTokenizer(String fullname) {
   int delim = fullname.indexOf('.');
   if (delim > -1) {
     name = fullname.substring(0, delim);
     children = fullname.substring(delim + 1);
   } else {
     name = fullname;
     children = null;
   }
   indexedName = name;
   delim = name.indexOf('[');
   if (delim > -1) {
     index = name.substring(delim + 1, name.length() - 1);
     name = name.substring(0, delim);
   }
 }

 public String getName() {
   return name;
 }

 public String getIndex() {
   return index;
 }

 public String getIndexedName() {
   return indexedName;
 }

 public String getChildren() {
   return children;
 }

 @Override
 public boolean hasNext() {
   return children != null;
 }

 @Override
 public PropertyTokenizer next() {
   return new PropertyTokenizer(children);
 }

 @Override
 public void remove() {
   throw new UnsupportedOperationException(
       "Remove is not supported, as it has no meaning in the context of properties.");
 }
}

 

可以看到，這個類傳入一個字串到建構函式，然後提供了iterator方法對解析後的子串進行遍歷，是一個很

相關推薦

Mybatis 使用的 9 種設計模式

雖然我們都知道有26個設計模式，但是大多停留在概念層面，真實開發中很少遇到，Mybatis原始碼中使用了大量的設計模式，閱讀原始碼

Mybatis源碼解讀-9種設計模式總結

tex 持久層框架 tcl 輸入參數 image zed pattern owb ssl 雖然我們都知道有26個設計模式，但是大多停留在概念層面，真實開發中很少遇到，Mybatis源碼中使用了大量的設計模式，閱讀源碼並觀察設計模式在其中的應用，能夠更深入的理解設計模式。My

關於W3Cschool定義的設計模式--常用的9種設計模式的介紹

一、設計模式 tip：每種設計模式，其實都是為了更高效的，更方便的解決在面對物件程式設計中所遇到的問題。 什麼是設計模式：     是一套經過反覆使用、多人知曉的、經過分類的、程式碼設計經驗的總結   為什麼使用設計模式：     為了程式碼的可重

23種設計模式（9）：訪問者模式（轉）

類方法 打印 interface 增加 http col visitor 設計模式的 接口 定義：封裝某些作用於某種數據結構中各元素的操作，它可以在不改變數據結構的前提下定義作用於這些元素的新的操作。 類型：行為類模式 類圖： 訪問者模式可能是行為類模式中最

二十三種設計模式[9] - 裝飾模式(Decorator Pattern)

前言        裝飾模式，屬於物件結構型模式。在《設計模式 - 可複用的面向物件軟體》一書中將之描述為“ 動態地給一個物件新增一些額外的職責。就增加功能來說，Decorator模式相比生成子類更為靈活”。    &n

23種設計模式（9）：訪問者模式

定義：封裝某些作用於某種資料結構中各元素的操作，它可以在不改變資料結構的前提下定義作用於這些元素的新的操作。 型別：行為類模式 類圖：        訪問者模式可能是行為類模式中最複雜的一種模式了，但是這不能成為我們不去掌握它的理由。我們首先來看一個簡單的例子，程式碼如下

23種設計模式---9.組合模式

組合模式（Composite Pattern），又叫部分整體模式，是用於把一組相似的物件當作一個單一的物件。組合模式依據樹形結構來組合物件，用來表示部分以及整體層次。這種型別的設計模式屬於結構型模式，它建立了物件組的樹形結構。 這種模式建立了一個包含自己物件組的類。該類提供了修改相同物件組的方式

23種設計模式-9.外觀模式（Facade Pattern)

動機(Motivate):     在軟體開發系統中，客戶程式經常會與複雜系統的內部子系統之間產生耦合，而導致客戶程式隨著子系統的變化而變化。那麼如何簡化客戶程式與子系統之間的互動介面？如何將複雜系統的內部子系統與客戶程式之間的依賴解耦？ 意圖(Intent):     為

Java中的24種設計模式與7大原則

工廠模式 職責 需要 占位符 ati gre template 層次 cto 一、創建型模式 1、抽象工廠模式(Abstract factory pattern): 提供一個接口, 用於創建相關或依賴對象的家族, 而不需要指定具體類.2、生成器模式(Builder pat

23種設計模式介紹以及單例模式的學習

單例模式 餓漢式 23種設計模式 gof23 1、GOF23 設計模式總共分成創建型模式、結構型模式和行為型模式三種： a、創建型模式： - 單例模式、工廠模式、抽象工廠模式、建造者模式、原型模式 b、構建型模式： - 適配器模式、橋接模式、裝配模式、組合模式、建造者模

23種設計模式介紹（一）---- 創建型模式

接口 ret static 深復制 return 對象 相互 object c png 由於設計模式篇幅比較大，如果在一篇文章講完所有的設計模式的話不利於閱讀。於是我把它分為三篇文章 23種設計模式介紹（一）---- 創建型模式 23種設計模式介紹（二）---- 結構型模

【Unity與23種設計模式】狀態模式（State）

unity public text 開始 sys 狀態模式 改變 val 繼承 定義： “讓一個對象的行為隨著內部狀態的改變而變化，而該對象也像是換了類一樣” 應用場景： 角色AI：控制角色在不同狀態下的AI行為 服務器連接狀態：開始連線、連線中、斷線等狀態 關卡進

轉：23種設計模式的應用場景

橋模式 man 16px pop 表示 black strong art bstr 設計模式主要分三個類型:創建型、結構型和行為型。 其中創建型有： 一、Singleton，單例模式：保證一個類只有一個實例，並提供一個訪問它的全局訪問點 ；

【Unity3D與23種設計模式】建造者模式（Builder）

產出 private 一個 gof 行為 並且 bstr reac 定義 GoF中定義： “將一個復雜的構建流程與它的對象表現分離出來，讓相同的構建流程可以產生不同的對象行為表現。” 建造者模式可以分為兩個步驟來實施： 1.將復雜的構建流程獨立出來，並將整個流程分成

23種設計模式中的叠代器模式

pos over arr imp @override 一個 next() int position 叠代器模式：提供一種方法順序訪問一個聚合對象中的各個對象。 那麽如何提供一個方法順序呢？ public interface Iterator<T>{ 　　publ

23種設計模式中的訪問者模式

功能需求 封裝 改變 擴展 數據結構 模式 困難 操作 如果 訪問者模式：對於一組對象，在不改變數據結構的前提下，增加作用於這些結構元素新的功能。 適用於數據結構相對穩定，它把數據結構和作用於其上的操作解耦，使得操作集合可以相對自由地演化。 優點： 符合單一職責原則 擴展性

23種設計模式中的原型模式

1-1 ... 實例代碼 sets each png 為什麽 .get protect 原型模式：通過復制現有實例來創建新的實例，無須知道相應類的信息。 個人見解：在大量循環時，需要初始化對象，用 原型模式能節省大量的初始化所花費的時間，值得一談的是淺復制和深復制 淺復制：

java 23種設計模式

代理 建造者 學習 article 適配器 htm ava arc 叠代 備註這是別人總結的本來想轉載可惜不會怎麽轉載（感謝） 以下是學習過程中查詢的資料,別人總結的資料,比較容易理解(站在各位巨人的肩膀上,望博主勿究) 創建型抽象工廠模式 http://www.cnblo

23種設計模式之觀察者模式

主題 一個 server bsp 監聽 images 關系 .com 自動更新 觀察者模式（Observer）：定義了一種一對多的關系，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態發生變化時，會通知所有觀察者對象，使它們能夠自動更新自己。 23種設計模式之

23種設計模式之抽象工廠模式

tor turn sql數據庫 png insert face sign 相關 reat 抽象工廠模式（Abstract Factory）：提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。 package designMode.abstractFa