1、背景

我們一般應用對數據庫而言都是“讀多寫少”，也就說對數據庫讀取數據的壓力比較大，有一個思路就是說採用數據庫集羣的方案，

其中一個是主庫，負責寫入數據，我們稱之爲：寫庫；

其它都是從庫，負責讀取數據，我們稱之爲：讀庫；

那麼，對我們的要求是：

讀庫和寫庫的數據一致；

寫數據必須寫到寫庫；

讀數據必須到讀庫；

2、方案

解決讀寫分離的方案有兩種：應用層解決和中間件解決。

2.1 應用層解決：

優點：

多數據源切換方便，由程序自動完成；

不需要引入中間件；

理論上支持任何數據庫；

缺點：

由程序員完成，運維參與不到；

不能做到動態增加數據源；

2.2 中間件解決

優點：

源程序不需要做任何改動就可以實現讀寫分離；

動態添加數據源不需要重啓程序；

缺點：

程序依賴於中間件，會導致切換數據庫變得困難；

由中間件做了中轉代理，性能有所下降；

相關中間件產品使用：

mysql-proxy：http://hi.baidu.com/geshuai2008/item/0ded5389c685645f850fab07

Amoeba for MySQL：http://www.iteye.com/topic/188598 和 http://www.iteye.com/topic/1113437

3、使用Spring基於應用層實現

3.1 原理

在進入Service之前，使用AOP來做出判斷，是使用寫庫還是讀庫，判斷依據可以根據方法名判斷，比如說以query、find、get等開頭的就走讀庫，其他的走寫庫。

3.2 DynamicDataSource

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 
 *  *
 * 定義動態數據源，實現通過集成Spring提供的AbstractRoutingDataSource，只需要實現determineCurrentLookupKey方法即可
 * 
 *  *
 * 
 *  *
 * 由於DynamicDataSource是單例的，線程不安全的，所以採用ThreadLocal保證線程安全，由DynamicDataSourceHolder完成。
 * 
 *  *
 *  
 */

public class DynamicDataSource extends AbstractRoutingDataSource {
	   
	@Override
    protected Object determineCurrentLookupKey() {
        // 使用DynamicDataSourceHolder保證線程安全，並且得到當前線程中的數據源key
        return DynamicDataSourceHolder.getDataSourceKey();
    }
}

3.3 DynamicDataSourceHolder

/**
 * 
 * 使用ThreadLocal技術來記錄當前線程中的數據源的key
 * 
 *
 */
public class DynamicDataSourceHolder {
    
    //寫庫對應的數據源key
    private static final String MASTER = "master";

    //讀庫對應的數據源key
    private static final String SLAVE = "slave";
    
    //使用ThreadLocal記錄當前線程的數據源key
    private static final ThreadLocal<String> holder = new ThreadLocal<String>();

    /**
     * 設置數據源key
     * @param key
     */
    public static void putDataSourceKey(String key) {
        holder.set(key);
    }

    /**
     * 獲取數據源key
     * @return
     */
    public static String getDataSourceKey() {
        return holder.get();
    }
    
    /**
     * 標記寫庫
     */
    public static void markMaster(){
        putDataSourceKey(MASTER);
    }
    
    /**
     * 標記讀庫
     */
    public static void markSlave(){
        putDataSourceKey(SLAVE);
    }

}

3.4 DataSourceAspect

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;

/**
 * 定義數據源的AOP切面，通過該Service的方法名判斷是應該走讀庫還是寫庫
 * 
 *
 */
public class DataSourceAspect {

    /**
     * 在進入Service方法之前執行
     * 
     * @param point 切面對象
     */
    public void before(JoinPoint point) {
        // 獲取到當前執行的方法名
        String methodName = point.getSignature().getName();
        if (isSlave(methodName)) {
            // 標記爲讀庫
            DynamicDataSourceHolder.markSlave();
        } else {
            // 標記爲寫庫
            DynamicDataSourceHolder.markMaster();
        }
    }

    /**
     * 判斷是否爲讀庫
     * 
     * @param methodName
     * @return
     */
    private Boolean isSlave(String methodName) {
        // 方法名以query、find、get開頭的方法名走從庫
        return StringUtils.startsWithAny(methodName, "query", "find", "get");
    }

}

3.5 配置2個數據源

3.5.1 jdbc.properties

jdbc.master.driver=com.mysql.jdbc.Driver

jdbc.master.url=jdbc:mysql://127.0.0.1:3306/mybatis_1128?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true

jdbc.master.username=root

jdbc.master.password=123456




jdbc.slave01.driver=com.mysql.jdbc.Driver

jdbc.slave01.url=jdbc:mysql://127.0.0.1:3307/mybatis_1128?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true

jdbc.slave01.username=root

jdbc.slave01.password=123456

3.5.2 定義連接池

 <!-- 配置連接池 -->

    <bean id="masterDataSource" class="com.jolbox.bonecp.BoneCPDataSource"

       destroy-method="close">

       <!-- 數據庫驅動 -->

       <property name="driverClass" value="${jdbc.master.driver}" />

       <!-- 相應驅動的jdbcUrl -->

       <property name="jdbcUrl" value="${jdbc.master.url}" />

       <!-- 數據庫的用戶名 -->

       <property name="username" value="${jdbc.master.username}" />

       <!-- 數據庫的密碼 -->

       <property name="password" value="${jdbc.master.password}" />

       <!-- 檢查數據庫連接池中空閒連接的間隔時間，單位是分，默認值：240，如果要取消則設置爲0 -->

       <property name="idleConnectionTestPeriod" value="60" />

       <!-- 連接池中未使用的鏈接最大存活時間，單位是分，默認值：60，如果要永遠存活設置爲0 -->

       <property name="idleMaxAge" value="30" />

       <!-- 每個分區最大的連接數 -->

       <property name="maxConnectionsPerPartition" value="150" />

       <!-- 每個分區最小的連接數 -->

       <property name="minConnectionsPerPartition" value="5" />

    </bean>

   

    <!-- 配置連接池 -->

    <bean id="slave01DataSource" class="com.jolbox.bonecp.BoneCPDataSource"

       destroy-method="close">

       <!-- 數據庫驅動 -->

       <property name="driverClass" value="${jdbc.slave01.driver}" />

       <!-- 相應驅動的jdbcUrl -->

       <property name="jdbcUrl" value="${jdbc.slave01.url}" />

       <!-- 數據庫的用戶名 -->

       <property name="username" value="${jdbc.slave01.username}" />

       <!-- 數據庫的密碼 -->

       <property name="password" value="${jdbc.slave01.password}" />

       <!-- 檢查數據庫連接池中空閒連接的間隔時間，單位是分，默認值：240，如果要取消則設置爲0 -->

       <property name="idleConnectionTestPeriod" value="60" />

       <!-- 連接池中未使用的鏈接最大存活時間，單位是分，默認值：60，如果要永遠存活設置爲0 -->

       <property name="idleMaxAge" value="30" />

       <!-- 每個分區最大的連接數 -->

       <property name="maxConnectionsPerPartition" value="150" />

       <!-- 每個分區最小的連接數 -->

       <property name="minConnectionsPerPartition" value="5" />

    </bean>

3.5.3 定義DataSource

<!-- 定義數據源，使用自己實現的數據源 -->

    <bean id="dataSource" class="cn.itcast.usermanage.spring.DynamicDataSource">

       <!-- 設置多個數據源 -->

       <property name="targetDataSources">

           <map key-type="java.lang.String">

              <!-- 這個key需要和程序中的key一致 -->

              <entry key="master" value-ref="masterDataSource"/>

              <entry key="slave" value-ref="slave01DataSource"/>

           </map>

       </property>

       <!-- 設置默認的數據源，這裏默認走寫庫 -->

       <property name="defaultTargetDataSource" ref="masterDataSource"/>

    </bean>

3.6 配置事務管理以及動態切換數據源切面

3.6.1 定義事務管理器

<!-- 定義事務管理器 -->

    <bean id="transactionManager"

       class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

       <property name="dataSource" ref="dataSource" />

    </bean>

3.6.2 定義事務策略

<!-- 定義事務策略 -->

    <tx:advice id="txAdvice" transaction-manager="transactionManager">

       <tx:attributes>

           <!--定義查詢方法都是隻讀的 -->

           <tx:method name="query*" read-only="true" />

           <tx:method name="find*" read-only="true" />

           <tx:method name="get*" read-only="true" />



           <!-- 主庫執行操作，事務傳播行爲定義爲默認行爲 -->

           <tx:method name="save*" propagation="REQUIRED" />

           <tx:method name="update*" propagation="REQUIRED" />

           <tx:method name="delete*" propagation="REQUIRED" />



           <!--其他方法使用默認事務策略 -->

           <tx:method name="*" />

       </tx:attributes>

    </tx:advice>

3.6.3 定義切面

  <!-- 定義AOP切面處理器 -->

    <bean class="cn.itcast.usermanage.spring.DataSourceAspect" id="dataSourceAspect" />



    <aop:config>

       <!-- 定義切面，所有的service的所有方法 -->

       <aop:pointcut id="txPointcut" expression="execution(* xx.xxx.xxxxxxx.service.*.*(..))" />

       <!-- 應用事務策略到Service切面 -->

       <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>

      

       <!-- 將切面應用到自定義的切面處理器上，-9999保證該切面優先級最高執行 -->

       <aop:aspect ref="dataSourceAspect" order="-9999">

           <aop:before method="before" pointcut-ref="txPointcut" />

       </aop:aspect>

    </aop:config>

4、改進切面實現，使用事務策略規則匹配

之前的實現我們是將通過方法名匹配，而不是使用事務策略中的定義，我們使用事務管理策略中的規則匹配。

4.1 改進後的配置

<!-- 定義AOP切面處理器 -->
	<bean class="cn.itcast.usermanage.spring.DataSourceAspect" id="dataSourceAspect">
		<!-- 指定事務策略 -->
		<property name="txAdvice" ref="txAdvice"/>
		<!-- 指定slave方法的前綴（非必須） -->
		<property name="slaveMethodStart" value="query,find,get"/>
	</bean>

4.2 改進後的實現

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import org.springframework.util.PatternMatchUtils;
import org.springframework.util.ReflectionUtils;

/**
 * 定義數據源的AOP切面，該類控制了使用Master還是Slave。
 * 
 * 如果事務管理中配置了事務策略，則採用配置的事務策略中的標記了ReadOnly的方法是用Slave，其它使用Master。
 * 
 * 如果沒有配置事務管理的策略，則採用方法名匹配的原則，以query、find、get開頭方法用Slave，其它用Master。
 * 
 *
 */
public class DataSourceAspect {

    private List<String> slaveMethodPattern = new ArrayList<String>();
    
    private static final String[] defaultSlaveMethodStart = new String[]{ "query", "find", "get" };
    
    private String[] slaveMethodStart;

    /**
     * 讀取事務管理中的策略
     * 
     * @param txAdvice
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public void setTxAdvice(TransactionInterceptor txAdvice) throws Exception {
        if (txAdvice == null) {
            // 沒有配置事務管理策略
            return;
        }
        //從txAdvice獲取到策略配置信息
        TransactionAttributeSource transactionAttributeSource = txAdvice.getTransactionAttributeSource();
        if (!(transactionAttributeSource instanceof NameMatchTransactionAttributeSource)) {
            return;
        }
        //使用反射技術獲取到NameMatchTransactionAttributeSource對象中的nameMap屬性值
        NameMatchTransactionAttributeSource matchTransactionAttributeSource = (NameMatchTransactionAttributeSource) transactionAttributeSource;
        Field nameMapField = ReflectionUtils.findField(NameMatchTransactionAttributeSource.class, "nameMap");
        nameMapField.setAccessible(true); //設置該字段可訪問
        //獲取nameMap的值
        Map<String, TransactionAttribute> map = (Map<String, TransactionAttribute>) nameMapField.get(matchTransactionAttributeSource);

        //遍歷nameMap
        for (Map.Entry<String, TransactionAttribute> entry : map.entrySet()) {
            if (!entry.getValue().isReadOnly()) {//判斷之後定義了ReadOnly的策略才加入到slaveMethodPattern
                continue;
            }
            slaveMethodPattern.add(entry.getKey());
        }
    }

    /**
     * 在進入Service方法之前執行
     * 
     * @param point 切面對象
     */
    public void before(JoinPoint point) {
        // 獲取到當前執行的方法名
        String methodName = point.getSignature().getName();

        boolean isSlave = false;

        if (slaveMethodPattern.isEmpty()) {
            // 當前Spring容器中沒有配置事務策略，採用方法名匹配方式
            isSlave = isSlave(methodName);
        } else {
            // 使用策略規則匹配
            for (String mappedName : slaveMethodPattern) {
                if (isMatch(methodName, mappedName)) {
                    isSlave = true;
                    break;
                }
            }
        }

        if (isSlave) {
            // 標記爲讀庫
            DynamicDataSourceHolder.markSlave();
        } else {
            // 標記爲寫庫
            DynamicDataSourceHolder.markMaster();
        }
    }

    /**
     * 判斷是否爲讀庫
     * 
     * @param methodName
     * @return
     */
    private Boolean isSlave(String methodName) {
        // 方法名以query、find、get開頭的方法名走從庫
        return StringUtils.startsWithAny(methodName, getSlaveMethodStart());
    }

    /**
     * 通配符匹配
     * 
     * Return if the given method name matches the mapped name.
     * <p>
     * The default implementation checks for "xxx*", "*xxx" and "*xxx*" matches, as well as direct
     * equality. Can be overridden in subclasses.
     * 
     * @param methodName the method name of the class
     * @param mappedName the name in the descriptor
     * @return if the names match
     * @see org.springframework.util.PatternMatchUtils#simpleMatch(String, String)
     */
    protected boolean isMatch(String methodName, String mappedName) {
        return PatternMatchUtils.simpleMatch(mappedName, methodName);
    }

    /**
     * 用戶指定slave的方法名前綴
     * @param slaveMethodStart
     */
    public void setSlaveMethodStart(String[] slaveMethodStart) {
        this.slaveMethodStart = slaveMethodStart;
    }

    public String[] getSlaveMethodStart() {
        if(this.slaveMethodStart == null){
            // 沒有指定，使用默認
            return defaultSlaveMethodStart;
        }
        return slaveMethodStart;
    }
    
}

5、一主多從的實現

很多實際使用場景下都是採用“一主多從”的架構的，所有我們現在對這種架構做支持，目前只需要修改DynamicDataSource即可。

5.1 實現

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.concurrent.atomic.AtomicInteger;



import javax.sql.DataSource;



import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import org.springframework.util.ReflectionUtils;



/**

 * 定義動態數據源，實現通過集成Spring提供的AbstractRoutingDataSource，只需要實現determineCurrentLookupKey方法即可

 *

 * 由於DynamicDataSource是單例的，線程不安全的，所以採用ThreadLocal保證線程安全，由DynamicDataSourceHolder完成。

 *

 * @author zhijun

 *

 */

public class DynamicDataSource extends AbstractRoutingDataSource {



    private static final Logger LOGGER = LoggerFactory.getLogger(DynamicDataSource.class);



    private Integer slaveCount;



    // 輪詢計數,初始爲-1,AtomicInteger是線程安全的

    private AtomicInteger counter = new AtomicInteger(-1);



    // 記錄讀庫的key

    private List<Object> slaveDataSources = new ArrayList<Object>(0);



    @Override

    protected Object determineCurrentLookupKey() {

        // 使用DynamicDataSourceHolder保證線程安全，並且得到當前線程中的數據源key

        if (DynamicDataSourceHolder.isMaster()) {

            Object key = DynamicDataSourceHolder.getDataSourceKey();

            if (LOGGER.isDebugEnabled()) {

                LOGGER.debug("當前DataSource的key爲: " + key);

            }

            return key;

        }

        Object key = getSlaveKey();

        if (LOGGER.isDebugEnabled()) {

            LOGGER.debug("當前DataSource的key爲: " + key);

        }

        return key;



    }



    @SuppressWarnings("unchecked")

    @Override

    public void afterPropertiesSet() {

        super.afterPropertiesSet();



        // 由於父類的resolvedDataSources屬性是私有的子類獲取不到，需要使用反射獲取

        Field field = ReflectionUtils.findField(AbstractRoutingDataSource.class, "resolvedDataSources");

        field.setAccessible(true); // 設置可訪問



        try {

            Map<Object, DataSource> resolvedDataSources = (Map<Object, DataSource>) field.get(this);

            // 讀庫的數據量等於數據源總數減去寫庫的數量

            this.slaveCount = resolvedDataSources.size() - 1;

            for (Map.Entry<Object, DataSource> entry : resolvedDataSources.entrySet()) {

                if (DynamicDataSourceHolder.MASTER.equals(entry.getKey())) {

                    continue;

                }

                slaveDataSources.add(entry.getKey());

            }

        } catch (Exception e) {

            LOGGER.error("afterPropertiesSet error! ", e);

        }

    }



    /**

     * 輪詢算法實現

     *

     * @return

     */

    public Object getSlaveKey() {

        // 得到的下標爲：0、1、2、3……

        Integer index = counter.incrementAndGet() % slaveCount;

        if (counter.get() > 9999) { // 以免超出Integer範圍

            counter.set(-1); // 還原

        }

        return slaveDataSources.get(index);

    }



}

6、MySQL主從複製

6.1 原理

mysql主(稱master)從(稱slave)複製的原理：

master將數據改變記錄到二進制日誌(binary log)中,也即是配置文件log-bin指定的文件(這些記錄叫做二進制日誌事件，binary log events)

slave將master的binary log events拷貝到它的中繼日誌(relay log)

slave重做中繼日誌中的事件,將改變反映它自己的數據(數據重演)

6.2 主從配置需要注意的地方

主DB server和從DB server數據庫的版本一致

主DB server和從DB server數據庫數據一致[ 這裏就會可以把主的備份在從上還原，也可以直接將主的數據目錄拷貝到從的相應數據目錄]

主DB server開啓二進制日誌,主DB server和從DB server的server_id都必須唯一

6.3 主庫配置（windows，Linux下也類似）

在my.ini修改：

#開啓主從複製，主庫的配置

log-bin = mysql3306-bin

#指定主庫serverid

server-id=101

#指定同步的數據庫，如果不指定則同步全部數據庫

binlog-do-db=mybatis_1128

執行SQL語句查詢狀態：
SHOW MASTER STATUS
需要記錄下Position值，需要在從庫中設置同步起始值。

6.4 在主庫創建同步用戶

#授權用戶slave01使用123456密碼登錄mysql

grant replication slave on *.* to 'slave01'@'127.0.0.1' identified by '123456';

flush privileges;

6.5 從庫配置

在my.ini修改：

#指定serverid，只要不重複即可，從庫也只有這一個配置，其他都在SQL語句中操作

server-id=102

以下執行SQL：

CHANGE MASTER TO

 master_host='127.0.0.1',

 master_user='slave01',

 master_password='123456',

 master_port=3306,

 master_log_file='mysql3306-bin.000006',

 master_log_pos=1120;



#啓動slave同步

START SLAVE;



#查看同步狀態

SHOW SLAVE STATUS;

7、參考資料

http://www.iteye.com/topic/1127642

http://634871.blog.51cto.com/624871/1329301

Mysql——使用Spring實現讀寫分離（MySQL實現主從複製）

1、背景

2、方案

2.1 應用層解決：

2.2 中間件解決

3、使用Spring基於應用層實現

3.1 原理

3.2 DynamicDataSource

3.3 DynamicDataSourceHolder

3.4 DataSourceAspect

3.5 配置2個數據源

3.5.1 jdbc.properties

3.5.2 定義連接池

3.5.3 定義DataSource

3.6 配置事務管理以及動態切換數據源切面

3.6.1 定義事務管理器

3.6.2 定義事務策略

3.6.3 定義切面

4、改進切面實現，使用事務策略規則匹配

4.1 改進後的配置

4.2 改進後的實現

5、一主多從的實現

5.1 實現

6、MySQL主從複製

6.1 原理

6.2 主從配置需要注意的地方

6.3 主庫配置（windows，Linux下也類似）

6.4 在主庫創建同步用戶

6.5 從庫配置

7、參考資料