目錄

前言
網上泛濫流傳單例模式的寫法種類，有說7種的，也有說6種的，當然也不排除說5種的，他們說的有錯嗎？其實沒有對與錯，刨根問底，寫法終究是寫法，其本質精髓大體一致！因此完全沒必要去追究寫法的多少，有這個時間還不如跟着宜春去網吧偷耳機、去田裡抓青蛙得了，一天天的….

言歸正傳…單例模式是最常用到的設計模式之一，熟悉設計模式的朋友對單例模式絕對不會陌生。同時單例模式也是比較簡單易理解的一種設計模式。

@

何謂單例模式？

專業術語

單例模式是一種常用的軟件設計模式，其定義是單例對象的類只能允許一個實例存在。許多時候整個系統只需要擁有一個的全局對象，這樣有利於我們協調系統整體的行為。比如在某個服務器程序中，該服務器的配置信息存放在一個文件中，這些配置數據由一個單例對象統一讀取，然後服務進程中的其他對象再通過這個單例對象獲取這些配置信息。這種方式簡化了在複雜環境下的配置管理。

單例模式，簡單的說就是 一個類只能有一個實例，並且在整個項目中都能訪問到這個實例。

單例模式的優點

1、在內存中只有一個對象，節省內存空間。
2、避免頻繁的創建銷毀對象，可以提高性能。
3、避免對共享資源的多重佔用。
4、可以全局訪問。

單例模式實現整體思路流程

首先我們要清楚單例模式要求類能夠有返回對象一個引用(永遠是同一個)和一個獲得該實例的方法（必須是靜態方法，通常使用getInstance這個名稱）。

單例模式的常規實現思路大致相同為以下三個步驟：

1、私有構造方法
2、指向自己實例的私有靜態引用
3、以自己實例為返回值的靜態的公有的方法

當然也可以理解為
1、私有化構造方法，讓外部不能new。
2、本類內部創建對象實例【靜態變量目的是為了類加載的時候創建實例】
3、提供一個公有的static靜態方法（一般該方法使用getInstance這個名稱），返回實例對象。

將該類的構造方法定義為私有方法，這樣其他處的代碼就無法通過調用該類的構造方法來實例化該類的對象，只有通過該類提供的靜態方法來得到該類的唯一實例；
在該類內提供一個靜態方法，當我們調用這個方法時，如果類持有的引用不為空就返回這個引用，如果類保持的引用為空就創建該類的實例並將實例的引用賦予該類保持的引用。

單例模式的適用場景

由於單例模式有很多獨特的優點，所以是編程中用的比較多的一種設計模式。我總結了一下我所知道的適合使用單例模式的場景：

1、需要頻繁實例化然後銷毀的對象。
2、創建對象時耗時過多或者耗資源過多，但又經常用到的對象。
3、有狀態的工具類對象。
4、頻繁訪問數據庫或文件的對象。

在後面我將會講到JDK中的Runtime類就是使用的餓漢式單例！在Spring MVC框架中的controller 默認是單例模式的!

單例模式的八種姿態寫法

宜春強烈建議：如果是沒有接觸單例模式的讀者朋友強烈建議你們動手敲一遍，不要複製，不然沒效果！

還有一點就是，要真正輕而易舉的理解單例模式，JVM的類加載知識是不能少的，不然你只是會敲的層次，啥？不懂類加載？放心，宜春就是要你會，要你理解透徹。

其實上面的這篇文章特別重要，上面這篇文章的重要性懂的自然懂，不懂的希望能理解宜春的一片好意，去看一下吧，實在看不懂看不下去在回來看這篇文章就好了,再大不了就把博主一起按在馬桶蓋蓋上….

是不是心裏暖暖的？宜春也不多嗶嗶了，直接擼碼走起….

姿態一：餓漢式1（靜態變量）

package singletonPattern;
//餓漢式（靜態變量）

class Singleton{
    //1、私有化構造方法，讓外部不能new
    private Singleton(){

    }
    //2、本類內部創建對象實例【靜態變量目的是為了類加載的時候創建實例】
    private final static Singleton instance=new Singleton();

    //3、提供一個公有的static靜態方法，返回實例對象
    public static Singleton getInstance(){
        return instance;
    }
}
//以下是測試代碼=====================

public class SingletenDemo1 {
    public static void main(String[] args) {
        Singleton singleton=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
//驗證一：
        System.out.println(singleton==singleton2);
//驗證二：
        System.out.println(singleton.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

//運行結果：
//        true
//        460141958
//        460141958

/*
餓漢式（靜態變量）方法

優點：寫法簡單，在類加載的時候就完成了實例化，同時也就避免了線程同步問題，因此線程安全
缺點：由於是在類加載時就完成了實例化，沒有達到懶加載的效果。如果一直沒有使用過這個實例，就造成了內存的浪費！

總結：這種方式基於ClassLoader類加載機制避免了多線程的同步問題，只不過instance屬性在類加載就實例化，在單例模式中大多數都是調用getInstance方法，
     由於getInstance方法是static靜態的，調用它肯定會觸發類加載！但是觸發類加載的原因有很多，我們不能保證這個類會通過其他的方式觸發類加載（比如調用了其他的static方法）
     這個時候初始化instance就沒有達到lazy loading 懶加載的效果，可能造成內存的浪費！

     餓漢式（靜態變量）這種方式可以使用但是會造成內存的浪費！

     */

姿態二：餓漢式2（static靜態代碼塊）

package singletonPattern;
//餓漢式2（static靜態代碼塊）

class Singleton2{
    private Singleton2(){

    }

    private static Singleton2 instance;

    static{ //把創建單例對象的操作放進了static靜態代碼塊中==============
        instance = new Singleton2();
    }

    public static Singleton2 getInstance(){
        return instance;
    }
}
//餓漢式2（static靜態代碼塊）其實和第一種餓漢式（靜態變量）方法差不多，其優缺點一致！
//唯一不同的就是把創建單例對象的操作放進了static靜態代碼塊中

姿態三：懶漢式1（線程不安全）

package singletonPattern;
//懶漢式1（線程不安全）
class Singleton3{
    private Singleton3(){

    }

    private static Singleton3 instance;

    public static Singleton3 getInstance(){
        if(instance == null){
            instance=new Singleton3();
        }
        return instance;
    }
}
/*
懶漢式（線程不安全）的這種方式起到了懶加載的效果，但只能在單線程下使用。
如果在多線程下，一個線程進入了if（singleton==null）判斷語句塊，還沒執行產生實例的句子，另一個線程
又進來了，這時會產生多個實例，所以不安全。

結語：懶漢式（線程不安全）在實際開發中，不要使用這種方式！！存在潛在危險
*/

姿態四：懶漢式2（線程安全）

package singletonPattern;
//懶漢式2（線程安全）
class Singleton4{
    private Singleton4(){

    }

    private static Singleton4 instance;

    public static synchronized Singleton4 getInstance(){
        if(instance == null){
            instance=new Singleton4();
        }
        return instance;
    }
}

/*
懶漢式2（線程安全）方式

優點：線程安全
缺點：效率太低，每次調用getInstance方法都要進行同步

結語：懶漢式2（線程安全）方式在開發中不推薦使用，主要是效率太低了*/

姿態五：餓漢式2（static靜態代碼塊）

package singletonPattern;
//懶漢式3 同步代碼塊（線程安全） 但是不滿足單例，在多線程下依舊會有多個實例
class Singleton5{
    private Singleton5(){

    }

    private static Singleton5 instance;

    public static  Singleton5 getInstance(){
        if(instance == null){   //多線程情況下可能多個線程進入這個if塊
            synchronized (Singleton5.class){  //到這裏只會一個一個創建實例，雖然安全，但是就不再是單例了
                instance=new Singleton5();
            }
        }
        return instance;
    }
}
/*
懶漢式3 同步代碼塊（線程安全） 但是不滿足單例，依舊會有多個實例

結語：懶漢式3 同步代碼塊（線程安全）方式在開發中不使用 ，實際上這個單例設計的有點搞笑*/

姿態六：雙重檢查單例

package singletonPattern;
//雙重檢查應用實例方式
class Singleton6{
    private Singleton6(){}

    private static volatile Singleton6 singleton;

    public static Singleton6 getInstance(){
        if(singleton==null){
            synchronized(Singleton6.class){
                if(singleton == null){
                    singleton= new Singleton6();
                }
            }
        }
        return singleton;
    }
}
/*
雙重檢查應用實例方式：

線程安全、延遲加載、效率較高

結語：開發中推薦使用！
*/

這個時候博主就得嗶嗶幾句了，細心的童鞋會發現有一個Volatile關鍵字，完了，沒見過，小白童鞋慌了！

Volatile 變量具有 synchronized 的可見性特性，但是不具備原子特性。這就是說線程能夠自動發現 volatile 變量的最新值。

這種實現方式既可以實現線程安全地創建實例，而又不會對性能造成太大的影響。它只是第一次創建實例的時候同步，以後就不需要同步了，從而加快了運行速度。

姿態七：靜態內部類單例

package singletonPattern;
//static靜態內部類單例

class Singleton7{
    private Singleton7(){}

    private static volatile Singleton7 instance;

    //寫一個static靜態內部類，給該類添加一個static靜態instance屬性
    private static class SingletonInstance{
        private static final Singleton7 SINGLETON_7=new Singleton7();
    }

    //
    public static synchronized Singleton7 getInstence(){
        return SingletonInstance.SINGLETON_7;
    }
}
/*
靜態內部類單例方式
        1、這種方式採用了類加載機制來保證初始化實例時只有一個線程
        2、巧妙的將實例化Singleton操作放進getInstance方法中，getInstance方法返回靜態內部類中實例化好的Singleton
        3、類的靜態屬性只會在第一次加載類的時候初始化，也就是只會初始化一次，在這裏，JVM幫我們保證了線程的安全，類在初始化時，別的線程無法進入。
       
        優點：線程安全、利用靜態內部類特點實現延遲加載、效率高
        開發中推薦使用這種靜態內部類單例方式！

static靜態內部特點：
1、外部類加載不會導致內部類加載，保證了其懶加載
*/

這個單例，宜春就不得不嗶嗶兩句了，要清楚這個單例，必須要明白static靜態內部特點，也就是外部類加載不會導致內部類加載！

姿態八：餓漢式2（static靜態代碼塊）

package singletonPattern;
//使用枚舉

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader;

enum Singleton8{
    INSTANCE;
    public void methodName(){
        System.out.println("測試數據");
    }
}
/*

枚舉方式的枚舉：
推薦寫法，簡單高效。充分利用枚舉類的特性，只定義了一個實例，且枚舉類是天然支持多線程的。
藉助JDK1.5中添加的枚舉來實現單例模式優點：
         1、不僅能避免多線程同步問題 
         2、還能防止反序列化重新創建新的對象

枚舉方式單例是由Effective java作者Josh Bloch提倡的，結語：推薦使用！
*/

當然也可以測試一下

public class SingletonDemo8 {
    public static void main(String[] args) {
        Singleton8 instance = Singleton8.INSTANCE;
        Singleton8 instance2 = Singleton8.INSTANCE;
        System.out.println(instance==instance2);

        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

        instance.methodName();
    }
}

運行結果：

true
460141958
460141958
測試數據

屬實沒毛病！

JDK源碼中單例模式的應用

先來看一段Runtime 的源碼吧，並分析一下其使用的是種單例模式！

/**
 * Every Java application has a single instance of class
 * <code>Runtime</code> that allows the application to interface with
 * the environment in which the application is running. The current
 * runtime can be obtained from the <code>getRuntime</code> method.
 * <p>
 * An application cannot create its own instance of this class.
 *
 * @author  unascribed
 * @see     java.lang.Runtime#getRuntime()
 * @since   JDK1.0
 */
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

這應該不難看出吧！如果看不出的話只能說明你真的還沒有理解單例模式，我其實想說單例模式其實是23種設計模式中最簡單的一個，只是寫法比較多而已！同時面試官一般都會問單例模式，它已經是很基礎的了，問的稍微有點水平就是問你單例模式在JDK中哪裡運用到了，顯然JDK中的Runtime其實它使用的就是餓漢式單例！正如註釋所說，每一個java應用程序都有一個Runtime實例。Runtime的單例模式是採用餓漢模式創建的，意思是當你加載這個類文件時，這個實例就已經存在了。

Runtime類可以取得JVM系統信息，或者使用gc()方法釋放掉垃圾空間，還可以使用此類運行本機的程序。

==還有就是spring Mvc 中的controller 默認是單例模式的，解析。==

單例模式總結

1、餓漢式（靜態變量）這種方式可以使用，但是沒有達到 lazy loading 懶加載的效果會造成內存的浪費！開發中不建議使用。
2、餓漢式（static靜態代碼塊）其實和第一種餓漢式（靜態變量）方法差不多，其優缺點一致！唯一不同的就是把創建單例對象的操作放進了static靜態代碼塊中
3、懶漢式（線程不安全）起到了懶加載的效果，但只能在單線程下使用。在實際開發中，不要使用這種方式！！！
4、懶漢式2（線程安全）方式線程安全但是效率太低，每次調用getInstance方法都要進行同步。所以在開發中不推薦使用。 5、懶漢式3
同步代碼塊（線程安全）方式在開發中不使用 ，實際上這個設計有點搞笑哈哈。
6、雙重檢查應用實例方式，線程安全、延遲加載、效率較高。因此開發中推薦使用！
7、靜態內部類單例方式線程安全、利用靜態內部類特點實現延遲加載、效率高。 開發中推薦使用這種靜態內部類單例方式！
8、藉助JDK1.5中添加的枚舉來實現單例模式不僅能避免多線程同步問題還能防止反序列化重新創建新的對象。枚舉方式單例是由Effective java作者Josh Bloch提倡的，開發中推薦使用！

單例模式必須考慮到在多線程的應用場合下的使用，畢竟現在的服務器基本上都是多核的了。

如果本文對你有一點點幫助，那麼請點個讚唄，謝謝~

最後，若有不足或者不正之處，歡迎指正批評，感激不盡！如果有疑問歡迎留言，絕對第一時間回復！

歡迎各位關注我的公眾號，一起探討技術，嚮往技術，追求技術，說好了來了就是盆友喔…

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

目錄

話引

• 前兩張我們分別介紹了Mybatis環境搭建及其組件的生命周期。這些都是我們Mybatis入門必備技能。有了前兩篇的鋪墊我們今天就來深入下Mybatis， 也為了填下之前埋下的坑。

XML配置標籤

概覽

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration> 
    <!--引入外部配置文件-->
    <properties resource=""/>
    <!--設置-->
    <settings/>
    <!--定義別名-->
    <typeAliases>
        <package name=""/>
    </typeAliases>
    <!--類型處理器-->
    <typeHandlers/>
    <!--對象工廠-->
    <objectFactory/>
    <!--插件-->
    <plugins/>
    <!--定義數據庫信息，默認使用development數據庫構建環境-->
    <environments default="development">
        <environment id="development">
            <!--jdbc事物管理-->
            <transactionManager type="JDBC"/>
            <!--配置數據庫連接信息-->
            <dataSource type="POOLED"/>
        </environment>
    </environments>
    <!--數據庫廠商標識-->
    <databaseIdProvider/>
    <mappers/>
</configuration>

• 上面模板列出了所有xml可以配置的屬性。這裏plugins是一個讓人哭笑不得的東西。用的好是利器，用的不好就是埋坑。接下來我們來看看各個屬性的作用

properties

• 該標籤的作用就是引入變量。和maven的properties一樣。在這裏定義的變量或者引入的變量，在下面我們是可以童工${}使用的。

子標籤property

<properties>
  <property name="zxhtom" value="jdbc:mysql://localhost:3306/mybatis"/>
</properties>

<dataSource type="POOLED">
<property name="driver" value="${zxhtom}"/>
<dataSource>

• 上述的配置就可以直接使用zxhtom這個變量。

resource

• 除了上述方法我們還可以通過引入其他properties文件，就可以使用文件里的配置變量了。

<properties resource="mybatis.properties"/>

程序注入

• 最後還有一種我們在構建SqlSessionFactory的時候重新載入我們的Properties對象就可以了。另外三者的優先級是從低到高

settings

configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
configuration.setDefaultEnumTypeHandler(resolveClass(props.getProperty("defaultEnumTypeHandler")));
configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
configuration.setLogPrefix(props.getProperty("logPrefix"));
configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));

• 上面代碼是我們在XMLConfigBuilder解析settings標籤的代碼。從這段代碼中我們了解到settings子標籤。

參數	功能	可選值	默認值
autoMappingBehavior	指定Mybatis應如何自動映射列到字段上。 NONE : 表示取消自動映射 PARTIAL:只會自動映射沒有定義嵌套結果集映射的結果集 FULL : 自動映射任意複雜的結果集	NONE、PARTIAL、FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定識別到位置列或屬性的時間 NONE : 什麼都不做 WARNING:日誌會報警(前提是日誌設置了显示權限) FAILING : 拋出異常。	NONE, WARNING, FAILING	NONE
cacheEnabled	該配置影響的所有映射器中配置的緩存的全局開關	true|false	true
proxyFactory	指定Mybatis創建具有延遲加載能力的對象所用到的代理工具未指定時將自動查找	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	not set
lazyLoadingEnabled	延時加載全局開關 開啟時：級聯對象會延時加載；級聯標籤中可以通過fetchType來定製覆蓋此選項	true|false	false
aggressiveLazyLoading	啟用時：對任意延遲屬性的調用會使帶有延遲加載屬性的對象分層性質完整加載，反之按需加載	true|false	true
multipleResultSetsEnabled	是否允許單一語句返回多結果集	true|false	true
useColumnLabel	確切的說當映射找不到參數時會使用列標籤(數據庫列名)代替別名去映射	true|false	true
useGeneratedKeys	允許 JDBC 支持自動生成主鍵，需要驅動兼容。 如果設置為 true 則這個設置強制使用自動生成主鍵，儘管一些驅動不能兼容但仍可正常工作（比如 Derby）	true|false	false
defaultExecutorType	配置默認的執行器。SIMPLE 就是普通的執行器；REUSE 執行器會重用預處理語句（prepared statements）； BATCH 執行器將重用語句並執行批量更新	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	設置超時時間，決定驅動等待數據庫響應的秒數	整數	null
defaultFetchSize	設置數據庫resultSet讀取數據方式，默認全部加載進內存，設置該屬性可以設置一次性讀多少條數據進內存	整數	null
mapUnderscoreToCamelCase	是否開啟自動駝峰命名規則（camel case）映射，即從經典數據庫列名 A_COLUMN 到經典 Java 屬性名 aColumn 的類似映射。	true|false	false
safeRowBoundsEnabled	-允許在嵌套語句中使用分頁	true|false	false
localCacheScope	一級緩存。mybatis默認對同一個sqlsession中數據是共享的。一個sqlsession調用兩次相同查詢實際只會查詢一次。就是因為該屬性為SESSION ， STATEMENT則針對的是每一條sql	SESSION|STATEMENT	SESSION
jdbcTypeForNull	當沒有為參數提供特定的jdbc類型時，為空值則指定JDBC類型。在新增時我們沒有設置參數，這個時候就會根據此參數天長。加入設置VARCHAR，那麼我們新增的數據沒傳參數則為空字符	NULL|VARCHAR|OTHER	OTHER
lazyLoadTriggerMethods	指定具體方法延時加載	方法	equals,clone,hashCode,toString
safeResultHandlerEnabled	允許在嵌套語句中使用分頁	true|false	true
defaultScriptingLanguage	動態SQL生成的默認語言		org.apache.ibatis.scripting.xmltags.XMLDynamicLanguageDriver
defaultEnumTypeHandler	mybatis默認的枚舉處理類
callSettersOnNulls	指定當結果集中值為null的時候是否調用映射對象的setter(put)方法。
useActualParamName	允許使用他們的編譯后名稱來映射，3.4.2后默認true.在xml中#{0}則報錯。設置為false，則#{0}代表第一個參數#{n}第n個	true|false	true
returnInstanceForEmptyRow	當返回行的所有列都是空時，MyBatis默認返回 null。 當開啟這個設置時，MyBatis會返回一個空實例。 請注意，它也適用於嵌套的結果集 （如集合或關聯）。（新增於 3.4.2）	true|false	false
logPrefix	指定 MyBatis 增加到日誌名稱的前綴。

別名

• 別名是mybatis為我們項目中類起的一個名字，類名往往會很長所以別名就方便我們平時的開發。Mybatis為我們內置了一些類的別名：byte、short、int、long、float、double、boolean、char等基礎類型的別名。還有其的封裝類型、String，Object,Map,List等等常用的類。
  org.apache.ibatis.type.TypeAliasRegistry這個類中幫我們內置了別名。可以看下。自定義別名也是通過這個類進行註冊的。我們可以通過settings中typeAliases配置的方式結合@Alias。或者掃描包也可以的。

TypeHandler

• 這個接口就四個方法

public interface TypeHandler<T> {

  /**
   * 設置參數是用到的方法
   */
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  T getResult(ResultSet rs, String columnName) throws SQLException;

  T getResult(ResultSet rs, int columnIndex) throws SQLException;

  T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}

• 可以理解成攔截器。它主要攔截的是設置參數和獲取結果的兩個節點。這個類的作用就是將Java對象和jdbcType進行相互轉換的一個功能。同樣的在org.apache.ibatis.type.TypeHandlerRegistry這個類中mybatis為我們提供了內置的TypeHandler。基本上是對於基本數據和分裝對象的轉換。
• 下面我們隨便看一個TypeHandler處理細節

public class BooleanTypeHandler extends BaseTypeHandler<Boolean> {

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, Boolean parameter, JdbcType jdbcType)
      throws SQLException {
    ps.setBoolean(i, parameter);
  }

  @Override
  public Boolean getNullableResult(ResultSet rs, String columnName)
      throws SQLException {
    boolean result = rs.getBoolean(columnName);
    return !result && rs.wasNull() ? null : result;
  }

  @Override
  public Boolean getNullableResult(ResultSet rs, int columnIndex)
      throws SQLException {
    boolean result = rs.getBoolean(columnIndex);
    return !result && rs.wasNull() ? null : result;
  }

  @Override
  public Boolean getNullableResult(CallableStatement cs, int columnIndex)
      throws SQLException {
    boolean result = cs.getBoolean(columnIndex);
    return !result && cs.wasNull() ? null : result;
  }
}

• setParameter是PreparedStatement進行設置成boolean類型。getResult分別通過三種不同方式獲取。在這些方法里我們可以根據自己也無需求進行控制。常見的控制是枚舉的轉換。傳遞參數過程可能是枚舉的name，但是傳遞到數據庫中要枚舉的index.這種需求我們就可以在TypeHandler中實現。我們書寫的typeHandler之後並不能被識別，還需要我們在resultMap中的result標籤中通過typeHandler指定我們的自定義Handler.

自定義TypeHandler

• 承接上文我們說道枚舉的轉換。下面我們還是已學生類為例。學生中性別之前是boolean類型。現在我們採用枚舉類型。但是數據庫中存的還是數據，01.

EnumTypeHandler

• 在TypeHandlerRegister類中申明了默認的枚舉類處理器是private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;。

@Override
public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
  String s = rs.getString(columnName);
  return s == null ? null : Enum.valueOf(type, s);
}

• 我們通過這個方法可以看出，這個枚舉處理器適合已枚舉名稱存儲的方式

EnumOrdinalTypeHandler

• 在Enum中還有一個屬性oridinal。這個表示枚舉中的索引。然後我們通過查看Mybatis提供的處理器發現有個叫EnumOrdinalTypeHandler。我們很容易聯想到的就是這個處理器是通過枚舉的所以作為數據庫內容的。在SexEnum中MALE存儲到數據庫中則為0.注意這個0不是我們的index.而是MALE的索引。如果將MALE和FEMAEL調換。那麼MALE索引則為1.

• 因為默認的是EnumTypeHandler。所以想用EnumOrdinalTypeHandler的話我們要麼在resultMap中sex字段指定該處理器。要不就通過配置文件typeHandlers註冊進來。（將處理器與Java類進行綁定。mybatis遇到這個Java對象的時候就知道用什麼處理器處理）

<typeHandlers>
    <typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler" javaType="com.github.zxhtom.enums.SexEnum"/>
</typeHandlers>

SexTypeHandler

• 上面的不管是通過名稱存儲還是通過索引存儲都不太滿足我們的需求。我們想通過我們的index存儲。那麼這時候我們就得自定義處理邏輯了。Mybatis處理器都是繼承BaseTypeHandler。因為BaseTypeHandler實現了TypeHandler.所以我們這裏也就繼承BaseTypeHandler。

public class SexTypeHandler extends BaseTypeHandler<SexEnum> {


    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, SexEnum parameter, JdbcType jdbcType) throws SQLException {
        ps.setInt(i,parameter.getIndex());
    }

    @Override
    public SexEnum getNullableResult(ResultSet rs, String columnName) throws SQLException {
        int i = rs.getInt(columnName);
        return SexEnum.getSexEnum(i);
    }

    @Override
    public SexEnum getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        int i = rs.getInt(columnIndex);
        return SexEnum.getSexEnum(i);
    }

    @Override
    public SexEnum getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        int i = cs.getInt(columnIndex);
        return SexEnum.getSexEnum(i);
    }
}

typeHandler注意點

• 在編寫自定義處理器的時候我們得之處Javatype、jdbctype。兩者不是必填。但至少得有一個。正常我們默認javatype是必填的。
• 填寫的方式有三種
  • 通過MappedTypes、MappedJdbcTypes分別指定javatype、jdbctype
  • 通過在mybatis-config.xml中配置typeHandlers進行註解。裏面也有這兩個屬性的配置。
  • 通過在mapper.xml的resultmap中再次指定某個字段的typehandler.
• TypeHandler為我們提供了Java到jdbc數據的轉換橋樑。極大的方便了我們平時的開發。讓我們開發期間忽略數據的轉換這麼糟心的事情。

# 加入戰隊

微信公眾號

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

作者 | 阿里巴巴技術專家  溪恆

一、需求來源

為什麼需要服務發現

在 K8s 集群裏面會通過 pod 去部署應用，與傳統的應用部署不同，傳統應用部署在給定的機器上面去部署，我們知道怎麼去調用別的機器的 IP 地址。但是在 K8s 集群裏面應用是通過 pod 去部署的， 而 pod 生命周期是短暫的。在 pod 的生命周期過程中，比如它創建或銷毀，它的 IP 地址都會發生變化，這樣就不能使用傳統的部署方式，不能指定 IP 去訪問指定的應用。

另外在 K8s 的應用部署里，之前雖然學習了 deployment 的應用部署模式，但還是需要創建一個 pod 組，然後這些 pod 組需要提供一個統一的訪問入口，以及怎麼去控制流量負載均衡到這個組裡面。比如說測試環境、預發環境和線上環境，其實在部署的過程中需要保持同樣的一個部署模板以及訪問方式。因為這樣就可以用同一套應用的模板在不同的環境中直接發布。

Service：Kubernetes 中的服務發現與負載均衡

最後應用服務需要暴露到外部去訪問，需要提供給外部的用戶去調用的。我們上節了解到 pod 的網絡跟機器不是同一個段的網絡，那怎麼讓 pod 網絡暴露到去給外部訪問呢？這時就需要服務發現。

在 K8s 裏面，服務發現與負載均衡就是 K8s Service。上圖就是在 K8s 里 Service 的架構，K8s Service 向上提供了外部網絡以及 pod 網絡的訪問，即外部網絡可以通過 service 去訪問，pod 網絡也可以通過 K8s Service 去訪問。

向下，K8s 對接了另外一組 pod，即可以通過 K8s Service 的方式去負載均衡到一組 pod 上面去，這樣相當於解決了前面所說的複發性問題，或者提供了統一的訪問入口去做服務發現，然後又可以給外部網絡訪問，解決不同的 pod 之間的訪問，提供統一的訪問地址。

二、用例解讀

下面進行實際的一個用例解讀，看 pod K8s 的 service 要怎麼去聲明、怎麼去使用？

Service 語法

首先來看 K8s Service 的一個語法，上圖實際就是 K8s 的一個聲明結構。這個結構里有很多語法，跟之前所介紹的 K8s 的一些標準對象有很多相似之處。比如說標籤 label 去做一些選擇、selector 去做一些選擇、label 去聲明它的一些 label 標籤等。

這裡有一個新的知識點，就是定義了用於 K8s Service 服務發現的一個協議以及端口。繼續來看這個模板，聲明了一個名叫 my-service 的一個 K8s Service，它有一個 app:my-service 的 label，它選擇了 app:MyApp 這樣一個 label 的 pod 作為它的後端。

最後是定義的服務發現的協議以及端口，這個示例中我們定義的是 TCP 協議，端口是 80，目的端口是 9376，效果是訪問到這個 service 80 端口會被路由到後端的 targetPort，就是只要訪問到這個 service 80 端口的都會負載均衡到後端 app：MyApp 這種 label 的 pod 的 9376 端口。

創建和查看 Service

如何去創建剛才聲明的這個 service 對象，以及它創建之後是什麼樣的效果呢？通過簡單的命令：

• kubectl apply -f service.yaml

或者是

• kubectl created -f service.yaml

上面的命令可以簡單地去創建這樣一個 service。創建好之後，可以通過：

• kubectl discribe service

去查看 service 創建之後的一個結果。

service 創建好之後，你可以看到它的名字是 my-service。Namespace、Label、Selector 這些都跟我們之前聲明的一樣，這裏聲明完之後會生成一個 IP 地址，這個 IP 地址就是 service 的 IP 地址，這個 IP 地址在集群裏面可以被其它 pod 所訪問，相當於通過這個 IP 地址提供了統一的一個 pod 的訪問入口，以及服務發現。

這裏還有一個 Endpoints 的屬性，就是我們通過 Endpoints 可以看到：通過前面所聲明的 selector 去選擇了哪些 pod？以及這些 pod 都是什麼樣一個狀態？比如說通過 selector，我們看到它選擇了這些 pod 的一個 IP，以及這些 pod 所聲明的 targetPort 的一個端口。

實際的架構如上圖所示。在 service 創建之後，它會在集群裏面創建一個虛擬的 IP 地址以及端口，在集群里，所有的 pod 和 node 都可以通過這樣一個 IP 地址和端口去訪問到這個 service。這個 service 會把它選擇的 pod 及其 IP 地址都掛載到後端。這樣通過 service 的 IP 地址訪問時，就可以負載均衡到後端這些 pod 上面去。

當 pod 的生命周期有變化時，比如說其中一個 pod 銷毀，service 就會自動從後端摘除這個 pod。這樣實現了：就算 pod 的生命周期有變化，它訪問的端點是不會發生變化的。

集群內訪問 Service

在集群裏面，其他 pod 要怎麼訪問到我們所創建的這個 service 呢？有三種方式：

• 首先我們可以通過 service 的虛擬 IP 去訪問，比如說剛創建的 my-service 這個服務，通過 kubectl get svc 或者 kubectl discribe service 都可以看到它的虛擬 IP 地址是 172.29.3.27，端口是 80，然後就可以通過這個虛擬 IP 及端口在 pod 裏面直接訪問到這個 service 的地址。

• 第二種方式直接訪問服務名，依靠 DNS 解析，就是同一個 namespace 里 pod 可以直接通過 service 的名字去訪問到剛才所聲明的這個 service。不同的 namespace 裏面，我們可以通過 service 名字加“.”，然後加 service 所在的哪個 namespace 去訪問這個 service，例如我們直接用 curl 去訪問，就是 my- 就可以訪問到這個 service。

• 第三種是通過環境變量訪問，在同一個 namespace 里的 pod 啟動時，K8s 會把 service 的一些 IP 地址、端口，以及一些簡單的配置，通過環境變量的方式放到 K8s 的 pod 裏面。在 K8s pod 的容器啟動之後，通過讀取系統的環境變量比讀取到 namespace 裏面其他 service 配置的一個地址，或者是它的端口號等等。比如在集群的某一個 pod 裏面，可以直接通過 curl $ 取到一個環境變量的值，比如取到 MY_SERVICE_SERVICE_HOST 就是它的一個 IP 地址，MY_SERVICE 就是剛才我們聲明的 MY_SERVICE，SERVICE_PORT 就是它的端口號，這樣也可以請求到集群裏面的 MY_SERVICE 這個 service。

Headless Service

service 有一個特別的形態就是 Headless Service。service 創建的時候可以指定 clusterIP:None，告訴 K8s 說我不需要 clusterIP（就是剛才所說的集群裏面的一個虛擬 IP），然後 K8s 就不會分配給這個 service 一個虛擬 IP 地址，它沒有虛擬 IP 地址怎麼做到負載均衡以及統一的訪問入口呢？

它是這樣來操作的：pod 可以直接通過 service_name 用 DNS 的方式解析到所有後端 pod 的 IP 地址，通過 DNS 的 A 記錄的方式會解析到所有後端的 Pod 的地址，由客戶端選擇一個後端的 IP 地址，這個 A 記錄會隨着 pod 的生命周期變化，返回的 A 記錄列表也發生變化，這樣就要求客戶端應用要從 A 記錄把所有 DNS 返回到 A 記錄的列表裡面 IP 地址中，客戶端自己去選擇一個合適的地址去訪問 pod。

可以從上圖看一下跟剛才我們聲明的模板的區別，就是在中間加了一個 clusterIP:None，即表明不需要虛擬 IP。實際效果就是集群的 pod 訪問 my-service 時，會直接解析到所有的 service 對應 pod 的 IP 地址，返回給 pod，然後 pod 裏面自己去選擇一個 IP 地址去直接訪問。

向集群外暴露 Service

前面介紹的都是在集群裏面 node 或者 pod 去訪問 service，service 怎麼去向外暴露呢？怎麼把應用實際暴露給公網去訪問呢？這裏 service 也有兩種類型去解決這個問題，一個是 NodePort，一個是 LoadBalancer。

• NodePort 的方式就是在集群的 node 上面（即集群的節點的宿主機上面）去暴露節點上的一個端口，這樣相當於在節點的一個端口上面訪問到之後就會再去做一層轉發，轉發到虛擬的 IP 地址上面，就是剛剛宿主機上面 service 虛擬 IP 地址。

• LoadBalancer 類型就是在 NodePort 上面又做了一層轉換，剛才所說的 NodePort 其實是集群裏面每個節點上面一個端口，LoadBalancer 是在所有的節點前又掛一個負載均衡。比如在阿里雲上掛一個 SLB，這個負載均衡會提供一個統一的入口，並把所有它接觸到的流量負載均衡到每一個集群節點的 node pod 上面去。然後 node pod 再轉化成 ClusterIP，去訪問到實際的 pod 上面。

三、操作演示

下面進行實際操作演示，在阿里雲的容器服務上面進去體驗一下如何使用 K8s Service。

創建 Service

我們已經創建好了一個阿里雲的容器集群，然後並且配置好本地終端到阿里雲容器集群的一個連接。

首先可以通過 kubectl get cs ，可以看到我們已經正常連接到了阿里雲容器服務的集群上面去。

今天將通過這些模板實際去體驗阿里雲服務上面去使用 K8s Service。有三個模板，首先是 client，就是用來模擬通過 service 去訪問 K8s 的 service，然後負載均衡到我們的 service 裏面去聲明的一組 pod 上。

K8s Service 的上面，跟剛才介紹一樣，我們創建了一個 K8s Service 模板，裏面 pod，K8s Service 會通過前端指定的 80 端口負載均衡到後端 pod 的 80 端口上面，然後 selector 選擇到 run:nginx 這樣標籤的一些 pod 去作為它的後端。

然後去創建帶有這樣標籤的一組 pod，通過什麼去創建 pod 呢？就是之前所介紹的 K8s deployment，通過 deployment 我們可以輕鬆創建出一組 pod，然後上面聲明 run:nginx 這樣一個label，並且它有兩個副本，會同時跑出來兩個 pod。

先創建一組 pod，就是創建這個 K8s deployment，通過 kubectl create -f service.yaml。這個 deployment 也創建好了，再看一下 pod 有沒有創建出來。如下圖看到這個 deployment 所創建的兩個 pod 都已經在 running 了。通過 kubectl get pod -o wide 可以看到 IP 地址。通過 -l，即 label 去做篩選，run=nginx。如下圖所示可以看到，這兩個 pod 分別是 10.0.0.135 和 10.0.0.12 這樣一個 IP 地址，並且都是帶 run=nginx 這個 label 的。

下面我們去創建 K8s service，就是剛才介紹的通過 service 去選擇這兩個 pod。這個 service 已經創建好了。

根據剛才介紹，通過 kubectl describe svc 可以看到這個 service 實際的一個狀態。如下圖所示，剛才創建的 nginx service，它的選擇器是 run=nginx，通過 run=nginx 這個選擇器選擇到後端的 pod 地址，就是剛才所看到那兩個 pod 的地址：10.0.0.12 和 10.0.0.135。這裏可以看到 K8s 為它生成了集群裏面一個虛擬 IP 地址，通過這個虛擬 IP 地址，它就可以負載均衡到後面的兩個 pod 上面去。

現在去創建一個客戶端的 pod 實際去感受一下如何去訪問這個 K8s Service，我們通過 client.yaml 去創建客戶端的 pod，kubectl get pod 可以看到客戶端 pod 已經創建好並且已經在運行中了。

通過 kubectl exec 到這個 pod 裏面，進入這個 pod 去感受一下剛才所說的三種訪問方式，首先可以直接去訪問這個 K8s 為它生成的這個 ClusterIP，就是虛擬 IP 地址，通過 curl 訪問這個 IP 地址，這個 pod 裏面沒有裝 curl。通過 wget 這個 IP 地址，輸入進去測試一下。可以看到通過這個去訪問到實際的 IP 地址是可以訪問到後端的 nginx 上面的，這個虛擬是一個統一的入口。

第二種方式，可以通過直接 service 名字的方式去訪問到這個 service。同樣通過 wget，訪問我們剛才所創建的 service 名 nginx，可以發現跟剛才看到的結果是一樣的。

在不同的 namespace 時，也可以通過加上 namespace 的一個名字去訪問到 service，比如這裏的 namespace 為 default。

最後我們介紹的訪問方式裏面還可以通過環境變量去訪問，在這個 pod 裏面直接通過執行 env 命令看一下它實際注入的環境變量的情況。看一下 nginx 的 service 的各種配置已經註冊進來了。

可以通過 wget 同樣去訪問這樣一個環境變量，然後可以訪問到我們的一個 service。

介紹完這三種訪問方式，再看一下如何通過 service 外部的網絡去訪問。我們 vim 直接修改一些剛才所創建的 service。

最後我們添加一個 type，就是 LoadBalancer，就是我們前面所介紹的外部訪問的方式。

然後通過 kubectl apply，這樣就把剛剛修改的內容直接生效在所創建的 service 裏面。

現在看一下 service 會有哪些變化呢？通過 kubectl get svc -o wide，我們發現剛剛創建的 nginx service 多了一個 EXTERNAL-IP，就是外部訪問的一個 IP 地址，剛才我們所訪問的都是 CLUSTER-IP，就是在集群裏面的一個虛擬 IP 地址。

然後現在實際去訪問一下這個外部 IP 地址 39.98.21.187，感受一下如何通過 service 去暴露我們的應用服務，直接在終端裏面點一下，這裏可以看到我們直接通過這個應用的外部訪問端點，可以訪問到這個 service，是不是很簡單？

我們最後再看一下用 service 去實現了 K8s 的服務發現，就是 service 的訪問地址跟 pod 的生命周期沒有關係。我們先看一下現在的 service 後面選擇的是這兩個 pod IP 地址。

我們現在把其中的一個 pod 刪掉，通過 kubectl delete 的方式把前面一個 pod 刪掉。

我們知道 deployment 會讓它自動生成一個新的 pod，現在看 IP 地址已經變成 137。

現在再去 describe 一下剛才的 service，如下圖,看到前面訪問端點就是集群的 IP 地址沒有發生變化，對外的 LoadBalancer 的 IP 地址也沒有發生變化。在所有不影響客戶端的訪問情況下，後端的一個 pod IP 已經自動放到了 service 後端裏面。

這樣就相當於在應用的組件調用的時候可以不用關心 pod 在生命周期的一個變化。

以上就是所有演示。

四、架構設計

最後是對 K8s 設計的一個簡單的分析以及實現的一些原理。

Kubernetes 服務發現架構

如上圖所示，K8s 服務發現以及 K8s Service 是這樣整體的一個架構。

K8s 分為 master 節點和 worker 節點：

• master 裏面主要是 K8s 管控的內容；
• worker 節點裏面是實際跑用戶應用的一個地方。

在 K8s master 節點裏面有 APIServer，就是統一管理 K8s 所有對象的地方，所有的組件都會註冊到 APIServer 上面去監聽這個對象的變化，比如說我們剛才的組件 pod 生命周期發生變化，這些事件。

這裏面最關鍵的有三個組件：

• 一個是 Cloud Controller Manager，負責去配置 LoadBalancer 的一個負載均衡器給外部去訪問；
• 另外一個就是 Coredns，就是通過 Coredns 去觀測 APIServer 裏面的 service 後端 pod 的一個變化，去配置 service 的 DNS 解析，實現可以通過 service 的名字直接訪問到 service 的虛擬 IP，或者是 Headless 類型的 Service 中的 IP 列表的解析；
• 然後在每個 node 裏面會有 kube-proxy 這個組件，它通過監聽 service 以及 pod 變化，然後實際去配置集群裏面的 node pod 或者是虛擬 IP 地址的一個訪問。

實際訪問鏈路是什麼樣的呢？比如說從集群內部的一個 Client Pod3 去訪問 Service，就類似於剛才所演示的一個效果。Client Pod3 首先通過 Coredns 這裏去解析出 ServiceIP，Coredns 會返回給它 ServiceName 所對應的 service IP 是什麼，這個 Client Pod3 就會拿這個 Service IP 去做請求，它的請求到宿主機的網絡之後，就會被 kube-proxy 所配置的 iptables 或者 IPVS 去做一層攔截處理，之後去負載均衡到每一個實際的後端 pod 上面去，這樣就實現了一個負載均衡以及服務發現。

對於外部的流量，比如說剛才通過公網訪問的一個請求。它是通過外部的一個負載均衡器 Cloud Controller Manager 去監聽 service 的變化之後，去配置的一個負載均衡器，然後轉發到節點上的一個 NodePort 上面去，NodePort 也會經過 kube-proxy 的一個配置的一個 iptables，把 NodePort 的流量轉換成 ClusterIP，緊接着轉換成後端的一個 pod 的 IP 地址，去做負載均衡以及服務發現。這就是整個 K8s 服務發現以及 K8s Service 整體的結構。

後續進階

後續再進階部分我們還會更加深入地去講解 K8s Service 的實現原理，以及在 service 網絡出問題之後，如何去診斷以及去修復的技巧。

本文總結

本文的主要內容就到此為止了，這裏為大家簡單總結一下：

1. 為什麼雲原生的場景需要服務發現和負載均衡，
2. 在 Kubernetes 中如何使用 Kubernetes 的 Service 做服務發現和負載均衡
3. Kubernetes 集群中 Service 涉及到的組件和大概實現原理

相信經過本文的學習與把握，大家能夠通過 Kubernetes Service 將複雜的企業級應用快速並標準地編排起來。

“阿里巴巴雲原生微信公眾號（ID：Alicloudnative）關注微服務、Serverless、容器、Service Mesh等技術領域、聚焦雲原生流行技術趨勢、雲原生大規模的落地實踐，做最懂雲原生開發者的技術公眾號。”

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

※高價收購3C產品,價格不怕你比較

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!