前言

本文討論Connector/J 的loadbalance模塊，我們先觀察整個模塊的大概邏輯結構和每一個大組件的作用，然后在代碼層面分析對于例外的控制，這里會有兩個“區分”：1）區分構造連接程序和使用連接程序；2）區分通訊例外和資料例外，最終分析此模式的實用性，

本次分析的版本為5.1.46，若通過maven下載，可添加以下依賴：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.46</version>
</dependency>

我們獲取連接的例子如下：

 Connection conn = null;
    URL ＝“jdbc:mysql:loadbalance://ip1:port1,ip2:port2,ip3:port3/dbname”；
    try{
        // 注冊 JDBC 驅動
        Class.forName("com.mysql.jdbc.Driver");

        // 打開鏈接
        conn = DriverManager.getConnection(DB_URL,USER,PASS);
    ....

名詞定義

Mysql：Mysql資料庫管理軟體

Mysql服務器：安裝了Mysql資料庫管理軟體的服務器

呼叫方：呼叫DriverManager#getConnection命令獲取連接的一方

一、Loadbalance的邏輯結構

Loadbalance模塊的UML類圖如下：
主要組件功能如下：

• MysqlIO：負責與Mysql服務器建立tcp鏈接，
• ConnectionImpl、JDBC4Connection：通過MysqlIO控制與Mysql服務器間的連接，并設定和記錄各種連接時間
• MultiHostMySQLConnection、LoadBalancedMySQLConnection、JDBC4LoadBalancedMySQLConnection：通過代理物件LoadBalancedConnectionProxy獲取JDBC4Connection物件，并呼叫JDBC4Connection物件對應的介面方法（從JDBC4MySQLConnection到java.sql.Connection宣告的方法），或者呼叫LoadBalancedConnectionProxy對應的方法，
• BalanceStrategy介面以及其實作類，以各自的演算法回傳合適的連接物件JDBC4Connection，
• MultiHostConnectionProxy：作為各種動態類的父類，實作了各種動態類的公共方法，最常見的就是回傳當前連接物件給到MultiHostMySQLConnection及其子類，它還是InvocationHandler介面的直接實作類，它多載了invoke方法，并宣告了由其子類實作的虛方法invokeMore，invoke方法的實作使用了模板方法這種設計模式，通過invoke方法和類的invokeMore方法，一起實作了代理模式，即在被代理方法執行之前和之后都添加了一些行為，
• LoadBalancedConnectionProxy作為MultiHostMySQLConnection的子類多載了invokeMore方法，在被代理方法執行后，會通過策略物件計算和更新當前連接物件，以供下次使用，

組件呼叫順序：

• 構造連接時各組件呼叫順序：

• 使用連接時各組件呼叫順序：

二、例外處理機制

1.構造階段

在我們的例里，url以jdbc:mysql:loadbalance:作為前綴，當我們使用DriverManager#getConnection命令獲取連接的時候，跟蹤呼叫鏈會一直來到NonRegisteringDriver#connect方法，而該方法分析引數url后，知道這是使用loadbalance模塊，因此就會進入NonRegisteringDriver#connectLoadBalanced方法，該方法將呼叫LoadBalancedConnectionProxy#createProxyInstance方法獲取連接，

在上述呼叫鏈的程序中，并沒有捕獲例外的行為，因此，如果LoadBalancedConnectionProxy#createProxyInstance方法的底層拋出的任何例外都會直接拋向呼叫方，所以呼叫方通常都會有一個獲取SQLException例外的行為，
我們觀察下LoadBalancedConnectionProxy#createProxyInstance方法：

public static LoadBalancedConnection createProxyInstance(List<String> hosts, Properties props) throws SQLException {
        LoadBalancedConnectionProxy connProxy = new LoadBalancedConnectionProxy(hosts, props);

        return (LoadBalancedConnection) java.lang.reflect.Proxy.newProxyInstance(LoadBalancedConnection.class.getClassLoader(), INTERFACES_TO_PROXY, connProxy);
    }

這里只有兩行命令，第一行構造LoadBalancedConnectionProxy物件，根據命令的宣告，它有可能拋出SQLException；第二句是創建動態代理物件，根據命令的宣告，它有可能拋出IllegalArgumentException，這例外是RuntimeException的子類，因此我們只需要著重觀察LoadBalancedConnectionProxy物件的構造程序，

private LoadBalancedConnectionProxy(List<String> hosts, Properties props) throws SQLException {
        super();
	....
        
    }

私有的建構式首先會呼叫父類的建構式，里面JDBC4LoadBalancedMySQLConnection物件，并作為thisAsConnection屬性值，而當前的LoadBalancedConnectionProxy物件作為JDBC4LoadBalancedMySQLConnection物件的thisAsProxy屬性值，在這個程序中，其實不會拋出SQLException例外，
我們再回到LoadBalancedConnectionProxy建構式：

private LoadBalancedConnectionProxy(List<String> hosts, Properties props) throws SQLException {
        super();
	....
        // hosts specifications may have been reset with settings from a previous connection group
        int numHosts = initializeHostsSpecs(hosts, props);

        this.liveConnections = new HashMap<String, ConnectionImpl>(numHosts);
        this.hostsToListIndexMap = new HashMap<String, Integer>(numHosts);
        for (int i = 0; i < numHosts; i++) {
            this.hostsToListIndexMap.put(this.hostList.get(i), i);
        }
        this.connectionsToHostsMap = new HashMap<ConnectionImpl, String>(numHosts);
    ....
        String strategy = this.localProps.getProperty("loadBalanceStrategy", "random");
        if ("random".equals(strategy)) {
            this.balancer = (BalanceStrategy) Util.loadExtensions(null, props, RandomBalanceStrategy.class.getName(), "InvalidLoadBalanceStrategy", null)
                    .get(0);
        } else if ("bestResponseTime".equals(strategy)) {
            this.balancer = (BalanceStrategy) Util
                    .loadExtensions(null, props, BestResponseTimeBalanceStrategy.class.getName(), "InvalidLoadBalanceStrategy", null).get(0);
        } else if ("serverAffinity".equals(strategy)) {
            this.balancer = (BalanceStrategy) Util.loadExtensions(null, props, ServerAffinityStrategy.class.getName(), "InvalidLoadBalanceStrategy", null)
                    .get(0);
        } else {
            this.balancer = (BalanceStrategy) Util.loadExtensions(null, props, strategy, "InvalidLoadBalanceStrategy", null).get(0);
        }
        
		String lbExceptionChecker = this.localProps.getProperty("loadBalanceExceptionChecker", "com.mysql.jdbc.StandardLoadBalanceExceptionChecker");
        this.exceptionChecker = (LoadBalanceExceptionChecker) Util.loadExtensions(null, props, lbExceptionChecker, "InvalidLoadBalanceExceptionChecker", null)
                .get(0);
    ....
        pickNewConnection();
    }

它根據url里的ip:port集合填充了hostsToListIndexMap屬性，key為ip:port的值，value為從0開始的下標值，同時也構造了與ConnectionImpl有關的屬性：liveConnections和connectionsToHostsMap，這兩屬性會在后面添加ConnectionImpl物件，
隨后還會根據url里的loadBalanceStrategy選項構造對應的策略物件，并作為balance屬性值，
最后初始化了例外檢查器exceptionChecker，如果url里有指定的就使用指定的類來構造，沒有的話就使用默認的com.mysql.jdbc.StandardLoadBalanceExceptionChecker物件，
在建構式的方法體里，pickNewConnection方法之前，雖然有些呼叫的方法會拋出例外，但都有捕獲行為，因此到目前為止仍然安全，我們接著進入非常眼熟的pickNewConnection方法一探究竟：

@Override
    synchronized void pickNewConnection() throws SQLException {
    ....
        for (int hostsTried = 0, hostsToTry = this.hostList.size(); hostsTried < hostsToTry; hostsTried++) {
            ConnectionImpl newConn = null;
            try {
                newConn = this.balancer.pickConnection(this, Collections.unmodifiableList(this.hostList), Collections.unmodifiableMap(this.liveConnections),
                        this.responseTimes.clone(), this.retriesAllDown);

                if (this.currentConnection != null) {
                    if (pingBeforeReturn) {
                        if (pingTimeout == 0) {
                            newConn.ping();
                        } else {
                            newConn.pingInternal(true, pingTimeout);
                        }
                    }

                    syncSessionState(this.currentConnection, newConn);
                }

                this.currentConnection = newConn;
                return;

            } catch (SQLException e) {
                if (shouldExceptionTriggerConnectionSwitch(e) && newConn != null) {
                    // connection error, close up shop on current connection
                    invalidateConnection(newConn);
                }
            }
        }

        // no hosts available to swap connection to, close up.
   ....
    }

該方法有一個很大的for回圈，嵌套其內的是很大的一個try catch 代碼塊，這段代碼的意思就是試圖通過策略物件來獲取連接物件，而最大次數為url里ip:port的數量，獲取到連接物件后，還要通過ping的行為確保連接正常，如果連接被成功構造，那么就作為currentConnection屬性值，因為這些行為都需要發生網路連接以及與mysql發生資料互動，所以都有可能產生例外，而根據《Mysql Connector/J 原始碼分析（普通Connection）》所述，構造連接程序中產生的通訊例外和資料例外都會統一以SQLException形式往外拋，因此，在此處就會被捕獲，例外的處理是本節關注的內容，所以我們先觀察catch部分，此處先呼叫shouldExceptionTriggerConnectionSwitch命令判斷例外，然后再判斷連接物件是否已經構造了，為什么要判斷連接物件是否已經構造了呢？貌似多余，實際是安全的做法，因為上面提過，是先構造連接，然后通過連接發送ping命令，這兩步是一前一后，可能在構造連接的時候網路是正常的，但發送ping命令時現狀況是有可能的，所以就會出現構造了連接物件但又會拋出例外的情況，

@Override
    boolean shouldExceptionTriggerConnectionSwitch(Throwable t) {
        return t instanceof SQLException && this.exceptionChecker.shouldExceptionTriggerFailover((SQLException) t);
    }

我們假設使用的是默認的例外檢查器com.mysql.jdbc.StandardLoadBalanceExceptionChecker，該類有兩個集合sqlStateList和sqlExClassList，而集合的元素分別來自于url的loadBalanceSQLStateFailover和loadBalanceSQLExceptionSubclassFailover選項，看客可以通過官網了解這兩選項，在此不詳述，
shouldExceptionTriggerFailover方法在以下情況此方法會回傳true：

• 錯誤碼以08開頭
• 錯誤碼雖然不以08開頭，但錯誤碼以sqlStateList任一元素值開頭
• 拋出的例外是通訊例外CommunicationsException
• 拋出的例外型別是sqlExClassList任一元素的例外型別相等或者是子類，
  也就是說，只要是通訊例外或者用戶指定的例外，該方法都會回傳true，
  我們把目光拉回到LoadBalancedConnectionProxy#pickNewConnection方法的捕獲例外位置：

@Override
    synchronized void pickNewConnection() throws SQLException {
        ....
        for (int hostsTried = 0, hostsToTry = this.hostList.size(); hostsTried < hostsToTry; hostsTried++) {
            ConnectionImpl newConn = null;
            try {
                ....

            } catch (SQLException e) {
                if (shouldExceptionTriggerConnectionSwitch(e) && newConn != null) {
                    // connection error, close up shop on current connection
                    invalidateConnection(newConn);
                }
            }
        }

        // no hosts available to swap connection to, close up.
        this.isClosed = true;
        this.closedReason = "Connection closed after inability to pick valid new connection during load-balance.";
    }

總的來說，當一個ip:port相對應的連接構造時或者執行ping命令時，底層拋出了SQLException后都會嘗試另一個ip:port，每個被嘗試建立的連接哪怕拋出SQLException（通訊例外和資料例外）都會被捕獲，如果每一組的ip:port都未能成功構造連接，那么currentConnection屬性值為null，isClosed為true，呼叫者是無法正常使用連接的，
經過上面的分析，在構造連接代理LoadBalancedConnectionProxy物件時，底層拋出的SQLException例外不會傳導到呼叫者，

2.使用階段

MultiHostConnectionProxy直接多載了java.lang.reflect.InvocationHandler介面的invoke方法，我們先觀察一下：

public synchronized Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ....
        try {
            return invokeMore(proxy, method, args);
        } catch (InvocationTargetException e) {
            throw e.getCause() != null ? e.getCause() : e;
        } catch (Exception e) {
            // Check if the captured exception must be wrapped by an unchecked exception.
            Class<?>[] declaredException = method.getExceptionTypes();
            for (Class<?> declEx : declaredException) {
                if (declEx.isAssignableFrom(e.getClass())) {
                    throw e;
                }
            }
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

該方法的省略部分不會拋例外，但它對invokeMore有一個獲取例外的行為，并且區分了InvocationTargetException和其他的情況的例外，從這里來看，底層拋上來的例外都會往呼叫者拋，而invokeMore方法被LoadBalancedConnectionProxy多載，我們進一步觀察下：

@Override
    public synchronized Object invokeMore(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();

        if (this.isClosed && !allowedOnClosedConnection(method) && method.getExceptionTypes().length > 0) {
            if (this.autoReconnect && !this.closedExplicitly) {
                // try to reconnect first!
                this.currentConnection = null;
                pickNewConnection();
                this.isClosed = false;
                this.closedReason = null;
       ....

        Object result = null;

        try {
            result = method.invoke(this.thisAsConnection, args);

            if (result != null) {
                if (result instanceof com.mysql.jdbc.Statement) {
                    ((com.mysql.jdbc.Statement) result).setPingTarget(this);
                }
                result = proxyIfReturnTypeIsJdbcInterface(method.getReturnType(), result);
            }

        } catch (InvocationTargetException e) {
            dealWithInvocationException(e);

        } finally {
           ....
                pickNewConnection();
           ....
        }

        return result;
    }

在方法里我們看到有兩處呼叫了pickNewConnection方法，前文已經分析過，里面不會有例外拋出，那么，我們需要分析的點就集中在try catch 里了，因為以反射的形式呼叫，所以一旦有問題會以InvocationTargetException的形式拋出，然后進入MultiHostConnectionProxy#dealWithInvocationException方法進一步分析原始例外型別：

void dealWithInvocationException(InvocationTargetException e) throws SQLException, Throwable, InvocationTargetException {
        Throwable t = e.getTargetException();

        if (t != null) {
            if (this.lastExceptionDealtWith != t && shouldExceptionTriggerConnectionSwitch(t)) {
                invalidateCurrentConnection();
                pickNewConnection();
                this.lastExceptionDealtWith = t;
            }
            throw t;
        }
        throw e;
    }

從代碼結構上看，例外是一定會往上拋，因為MultiHostConnectionProxy#dealWithInvocationException方法是在LoadBalancedConnectionProxy#invokeMore的catch代碼塊里呼叫，而該catch代碼塊沒有進一步捕獲例外，因此例外將到達MultiHostConnectionProxy#invoke方法里的捕獲例外的代碼塊，前文通過觀察它的捕獲例外代碼塊可知道，例外最侄訓繼續向上層拋，也就是說，在使用連接的程序中，一旦遇到通訊例外或者資料例外，呼叫者都會感知到，當例外發生時，我們可以基本知道它經過的地方：

我們把目光放回到MultiHostConnectionProxy#dealWithInvocationException:

void dealWithInvocationException(InvocationTargetException e) throws SQLException, Throwable, InvocationTargetException {
        Throwable t = e.getTargetException();

        if (t != null) {
            if (this.lastExceptionDealtWith != t && shouldExceptionTriggerConnectionSwitch(t)) {
                invalidateCurrentConnection();
                pickNewConnection();
                this.lastExceptionDealtWith = t;
            }
            throw t;
        }
        throw e;
    }

呼叫的shouldExceptionTriggerConnectionSwitch被LoadBalanceConnectionProxy多載了：

@Override
    boolean shouldExceptionTriggerConnectionSwitch(Throwable t) {
        return t instanceof SQLException && this.exceptionChecker.shouldExceptionTriggerFailover((SQLException) t);
    }

我們假設exceptionChecker使用的是默認的com.mysql.jdbc.StandardLoadBalanceExceptionChecker
該類有兩個集合sqlStateList和sqlExClassList，而集合的元素分別來自于url的loadBalanceSQLStateFailover和loadBalanceSQLExceptionSubclassFailover選項，看官可以通過官網了解這兩選項，在此不詳述，
shouldExceptionTriggerFailover方法在以下情況此方法會回傳true：

• 錯誤碼以08開頭
• 錯誤碼雖然不以08開頭，但錯誤碼以sqlStateList任一元素值開頭
• 拋出的例外是通訊例外CommunicationsException
• 拋出的例外型別是sqlExClassList任一元素的例外型別相等或者是子類，
  也就是說，只要是通訊例外或者用戶指定的例外，該方法都會回傳true，
  我們再次結合MultiHostConnectionProxy#dealWithInvocationException來看：

void dealWithInvocationException(InvocationTargetException e) throws SQLException, Throwable, InvocationTargetException {
        Throwable t = e.getTargetException();

        if (t != null) {
            if (this.lastExceptionDealtWith != t && shouldExceptionTriggerConnectionSwitch(t)) {
                invalidateCurrentConnection();
                pickNewConnection();
                this.lastExceptionDealtWith = t;
            }
            throw t;
        }
        throw e;
    }

如果例外屬于通訊例外以及用戶指定的情況一旦發生，首先更新連接，然后將例外往上拋，

小結

動態代理連接在構造階段即使底層無法成功建立連接，但動態代理連接是能夠成功構造并被呼叫者持有，而動態代理連接在使用程序中，一旦遇到任何例外，都會被呼叫者感知到，這一點與failover確實不一樣，呼叫者可以馬上停止當前事務程序而重新再來，這樣會讓事務操作變得可以掌控，也可以說事務的原子性得以保證，它的這種特性，也符合我們使用普通Connection時的編程規范（try…事務操作…catch…回滾事務…finally…關閉資源…），因此，如果我們專案一開始比較小，使用普通的Connection模式，到后來需要資料庫結構升級為支持負載均衡的時候，我們不需要修改代碼，只需要修改下url配置即可，

三、autoReconnect選項

根據官網介紹autoReconnect選項是failover模塊重要選項之一，在loadbalance的描述部分只字未提，但我們通過閱讀代碼時會看到它的身影，本節就一起分析該選項所起到的作用，
該選項對應著autoReconnect屬性，而該項屬性被使用到的地方僅在于
LoadBalancedConnectionProxy#invokeMore方法：

@Override
    public synchronized Object invokeMore(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        if (this.isClosed && !allowedOnClosedConnection(method) && method.getExceptionTypes().length > 0) {
            if (this.autoReconnect && !this.closedExplicitly) {
                // try to reconnect first!
                this.currentConnection = null;
                pickNewConnection();
        	....
        Object result = null;
        try {
            result = method.invoke(this.thisAsConnection, args);
           ....
        return result;
    }

在Method#invke前，它是呼叫pickNewConnection的條件之一，我們分析下各項條件成立的因素：

• this.isClosed為真值
  該值為真值的地方出現在：
  1）pickNewConnection方法體里，如果url的ip:port都不能成功建立連接，就為真值，
  2）doPing方法體里，如果未能ping成功，就為真值，
  3）執行連接的close方法
  4）執行連接的abortInternal方法
  5）執行連接的abort方法
• !allowedOnClosedConnection為真值
  只要不執行連接的以下方法就會成立：
  1）連接的getAutoCommit方法
  2）連接的getCatalog方法
  3）連接的getTransactionIsolation方法
  4）連接的getSessionMaxRows方法
• method.getExceptionTypes().length > 0
  只要方法宣告會拋例外即滿足，
• this.autoReconnect
  url上添加autoReconnect=true選項即滿足，
• !this.closedExplicitly
  不執行連接的close方法即可為真：

作用分析

所以假設用戶在url添加了autoReconnect=true的情況下，并且呼叫方呼叫動態連接的上一條命令不是close方法情況下,大致可以梳理出以下3個場景：
1）當用戶獲取連接動態代理時會執行pickNewConnection方法，當url里所有的ip:port都不能成功建立連接時isClosed為true，因為呼叫方不主動呼叫LoadBalancedConnectionProxy#getCurrentActiveHost方法是感知不到底層連接沒有建立，所以當他繼續使用動態代理連接執行查詢或者更新資料的SQL命令時，會先嘗試更新連接，
2）用戶已經成功獲取動態代理，在使用時由于網路原因使得url里所有的ip:port都不能成功建立連接，前文講述過遇到通訊例外時，會執行pickNewConnection方法并拋出通訊例外，如果url里所有的ip:port都未能成功建立連接，isClosed為true，當網路恢復正常，重新執行的操作會先嘗試更新連接，
3）呼叫者先呼叫接連的abort或者abortInternal方法，然后再執行增刪改查的命令，也就是說呼叫方可能通過呼叫abort或者abortInternal方法主動地更換連接，然后再操作資料，

對于前兩點，當網路出現極端情況下，極大方便了開發人員，因為他們不必考慮如何解決這種情況下的重連，另外，也可以理解為是一個兜底的保障作用，確保一旦網路恢復后，仍能正常執行SQL操作，
對于第三點，可理解為給呼叫者提供更靈活的手段，在需要的時候呼叫abort或者abortInternal命令更換連接，然后再進行SQL操作，所以說它是讓這個機制更完善，

所以，基于上面的分析，官網上其實可以多作介紹的，

四、何時重建連接

重建連接的操作以LoadBalancedConnectionProxy#pickNewConnection為入口，該方法會輪循url各組ip:port，只要有一組能夠連接成功就算建立了與Mysql的連接，如果沒有一組能夠成功建立連接，設定isClosed為true，
那么該方法中哪些時間點上會被呼叫呢？

1. 構造動態代理連接j時，LoadBalancedConnectionProxy的建構式會呼叫該方法，
2. 正式呼叫Method#invoke方法前，請看上一節，
3. 呼叫Method#invoke方法出現了通訊例外，
4. 執行完commit或者rollback方法后，

五、實用性分析

動態代理連接在使用中遇到例外能夠被呼叫方即時感知到，這使得loadbalance模式具有使用的價值，故名思義，此模式還能起到負載均衡的效果，用戶只需要在url上多配置幾組ip:port（mysql的服務器得跟上）， 這樣就可以均衡各臺資料庫服務器的壓力，至少系統進行極力測驗時可以輕松過關^_，
Loadbalance模式是依賴Strategy組件來分配任務到某一組ip:port對應的Mysql服務器上，而不并會區分任務是寫操作還是讀操作，所以這就要求Mysql服務器間必須具備資料同步功能，以保證各臺服務器上的資料是一致的，而且需要實作強一致性，否則無法達到事務隔離的Repeatable級別的要求，

• 對于微型專案，可以采用如下結構：
  讓兩臺Mysql服務器互為高備，

• 讓高可用性上一個臺階，可使用Percona XtraDB：
  它可實作集群內所有Mysql服務器資料的強一致性，但是如果成員太多，為保持資料的一致性會導致性能有所下降，

• 使用資料庫中間件和集群
  此方法由中間件分析出SQL操作是讀操作還是寫操作，然后將操作分配給專門用于讀的服務器或者專門用于接受寫命令的服務器，此方案要求最高，但它兼顧了高可用和性能，

小結

Loadbalance模式強調的是壓力的均衡，所以要使用好這種連接模式，用戶還需要考慮Mysql的拓撲和資料同步問題，這樣才能夠符合當代應用對于資料高可用的要求，如果用戶對于資料寫操作的耗時不敏感，用戶完全可以采用此模式，

六、總結

Loadbalance模式具有使用價值，其特點如下：

• 呼叫者在使用程序中能夠感知到底層發生的例外，另外呼叫者只需構造一個動態代理連接即可，
• 呼叫者在使用程序中遇到例外，處理方法與使用普通的Connection一樣，使用者如果想從普通的Connection升級到Loadbalance模式，在應用層面只需要修改url，無需改代碼，
• 可擴展性強，用戶發現資料庫資源占用高，可以多安排設備，然后在url里添加更多的ip:port即可，
• Loadbalance模式強調的是壓力的均衡，所以需要部署多臺Mysql服務器，另外，當要執行一批的SQL 命令時，前后命令有可能會分配給不同的Mysql服務器執行，所以這里存在資料同步問題，所以使用此模式，需要掌握Mysql多機的部署知識，而且必須要將資料的一致性放在最首要的位置來考慮，
• 高可用性，根據上一點，使用好Loadbalance模式，無形中實作了資料的高可用性，
• 穩定性，因為將執行任務安排到不同的Mysql服務器上，降低各臺服務器的資源占用，從而為整個應用系統的穩定運行起到了一定的作用，

Loadbalace模式以將任務分配到不同的服務器上執行作為手段，實作整個資料庫系統的穩定運行，這種模式強調的是穩定性，如果用戶對回應速度要求極高，這種模式就不能勝任了，后續文章將介紹replication模式，看看它在提高回應速度方面有何設計良方，