Spring MVC+jdbcTemplate+MySql实现读写分离

现如今，数据库读写分离已经不在是新鲜的话题，很多数据统计网站 、访问量高的网站都会使用这项技术。解决网站响应慢、服务器承载压力过大的方案其实有很多，而读写分离只是其中一种实现方案。有的时候读写分离并不能完美解决。此文章记录了笔者使用@Aspect注解方式实现Spring MVC+jdbcTemplate+MySql实现读写分离的过程。
既然要读写分离，那么数据库至少就要又两个，一个主数据库，负责读写，多个重数据库，负责读取。
既然是读写分离，为什么主数据库还要负责读和写呢？
在实际的应用场景种，
一、我写入数据的同时往往要读取一些基础数据。
二、数据在写入之后要读取出相关信息，读写分离再及时，也会产生延迟，这样程序上就会异常了。
所以，主数据库不仅需要写入的能力，还要有读取的能力。

笔者实用MySql数据库，jdbc.properties配置如下

mysqlM.url=jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf8
mysqlM.username=root
mysqlM.password=root

mysqlC.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf8
mysqlC.username=root
mysqlC.password=root

mysql.driverClassName=com.mysql.jdbc.Driver
mysql.filters=stat
mysql.maxActive=20
mysql.initialSize=1
mysql.maxWait=60000
mysql.minIdle=10
mysql.maxIdle=15
mysql.timeBetweenEvictionRunsMillis=60000
mysql.minEvictableIdleTimeMillis=300000
mysql.validationQuery=SELECT 'x'
mysql.testWhileIdle=true
mysql.testOnBorrow=false
mysql.testOnReturn=false
mysql.maxOpenPreparedStatements=20
mysql.removeAbandoned=true
mysql.removeAbandonedTimeout=1800
mysql.logAbandoned=true

其中，mysqlM是主数据库，mysqlC是重数据库。
spring-dao.xml配置如下

<!-- 数据库基本信息配置 -->
    <bean id="parentDataSource" class="com.alibaba.druid.pool.DruidDataSource" abstract="true">
        <property name="driverClassName" value="${mysql.driverClassName}" />
        <property name="filters" value="${mysql.filters}" />
        <property name="maxActive" value="${mysql.maxActive}" />
        <property name="initialSize" value="${mysql.initialSize}" />
        <property name="maxWait" value="${mysql.maxWait}" />
        <property name="minIdle" value="${mysql.minIdle}" />
        <property name="timeBetweenEvictionRunsMillis" value="${mysql.timeBetweenEvictionRunsMillis}" />
        <property name="minEvictableIdleTimeMillis" value="${mysql.minEvictableIdleTimeMillis}" />
        <property name="validationQuery" value="${mysql.validationQuery}" />  
        <property name="testWhileIdle" value="${mysql.testWhileIdle}" />  
        <property name="testOnBorrow" value="${mysql.testOnBorrow}" />  
        <property name="testOnReturn" value="${mysql.testOnReturn}" />  
        <property name="maxOpenPreparedStatements" value="${mysql.maxOpenPreparedStatements}" />
        <property name="removeAbandoned" value="${mysql.removeAbandoned}" />
        <property name="removeAbandonedTimeout" value="${mysql.removeAbandonedTimeout}" />
        <property name="logAbandoned" value="${mysql.logAbandoned}" />
        <property name="poolPreparedStatements" value="false" />
    </bean>
    <!-- 主数据库 -->
    <bean id="dataSourceM" parent="parentDataSource">
         <property name="url" value="${mysqlM.url}" />  
         <property name="username" value="${mysqlM.username}" />
         <property name="password" value="${mysqlM.password}" />
    </bean>
    <!-- 从数据库 -->
    <bean id="dataSourceC" parent="parentDataSource">
         <property name="url" value="${mysqlC.url}" />
         <property name="username" value="${mysqlC.username}" />
         <property name="password" value="${mysqlC.password}" />
    </bean>
    <!-- 启用CGliB -->
    <aop:aspectj-autoproxy/>
    <!--切面注入spring自定义标签-->
    <bean id="dsChangeAspect" class="com.org.util.DataSourceAspect"/>
    <!--动态数据源、主从库选择-->
    <bean id="dynamicDataSource" class="com.org.util.DynamicDataSource">
        <property name="master" ref="dataSourceM"/>
        <property name="slaves">
            <list>
                <ref bean="dataSourceC"/>
            </list>
        </property>
    </bean>
    <!-- 配置Jdbc模板 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dynamicDataSource"></property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" p:dataSource-ref="dataSourceM" />
    <!-- 启用基于注解的事务管理 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" />
            <tx:method name="get*" propagation="REQUIRED" read-only="true" />
            <tx:method name="add*" propagation="NESTED" isolation="REPEATABLE_READ" />
            <tx:method name="init*" propagation="NESTED" isolation="REPEATABLE_READ" />
            ....
        </tx:attributes>
    </tx:advice>

注解：
1、<aop:aspectj-autoproxy/>
spring默认是不开启Aspect（自定义标签注入）模式的，需要手动开启。
2、<bean id="dsChangeAspect" class="com.org.util.DataSourceAspect"/>
自定义类：DataSourceAspect，目的是创建自定义标签、绑定标签实现方法。代码如下：

package com.org.util;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
/**
 * 有{@DataSourceChange}注解的方法，调用时会切换到指定的数据源
 * @author zbr
 * @date 2016年12月28日
 */
@Aspect
public class DataSourceAspect {
    @Pointcut(value = "@annotation(com.org.util.DataSourceChange)")
    private void changeDS() {
    }

    @Around(value = "changeDS() ", argNames = "pjp")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        Object retVal = null;
        MethodSignature ms = (MethodSignature) pjp.getSignature();
        Method method = ms.getMethod();
        DataSourceChange annotation = method.getAnnotation(DataSourceChange.class);
        boolean selectedDataSource = false;
        try {
            if (null != annotation) {
                selectedDataSource = true;
                if (annotation.slave()) {
                    DynamicDataSource.useSlave();
                } else {
                    DynamicDataSource.useMaster();
                }
            }
            retVal = pjp.proceed();
        } catch (Throwable e) {
            throw e;
        } finally {
            if (selectedDataSource) {
                DynamicDataSource.reset();
            }
        }
        return retVal;
    }
}

DataSourceChange 类

package com.org.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceChange {
    boolean slave() default false;
}

3、com.org.util.DynamicDataSource
自定义类DynamicDataSource，动态数据源、主从库选择。这一切都要靠spring的AbstractRoutingDataSource，所以我们要继承AbstractRoutingDataSource。其实可以想一下，如果我们自己要实现读写分离，我们自己的思路是什么。
问题一、什么时候使用主库，什么时候使用重库。
问题二、什么时候去切换数据库。
第一个问题其实很好解释，主重的选择完全靠人为来决定，我们给方法、类或者接口加上自定义标签后，我们的程序就能判断出你期望使用的数据源。
第二个问题、很多人都会想到是在dao层查询的时候去选择dataSource,没错，spring也是这么想的，所以它提供了我们一个类：AbstractRoutingDataSource。
方法1：afterPropertiesSet，数据源初始化
方法2：determineCurrentLookupKey，翻译过来的意思是：根据key来选择数据源，就是说我们要访问数据库前，AbstractRoutingDataSource中的determineCurrentLookupKey方法，帮我们去选择dataSource，我们需要告诉spring我们要使用哪个数据源，也就是Key。

package com.org.util;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 动态数据源
 * 配置主从数据源后，根据选择，返回对应的数据源。多个从库的情况下，会平均的分配从库，用于负载均衡。
 * @author zbr
 * @date 2016年12月28日
 */
public class DynamicDataSource extends AbstractRoutingDataSource{
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamicDataSource.class);

    private DataSource master; // 主库，只允许有一个
    private List<DataSource> slaves; // 从库，允许有多个
    private AtomicLong slaveCount = new AtomicLong();
    private int slaveSize = 0;

    private Map<Object, Object> dataSources = new HashMap<Object, Object>();

    private static final String DEFAULT = "master";//主数据库的Key
    private static final String SLAVE = "slave";//重数据库的key

    private static final ThreadLocal<LinkedList<String>> datasourceHolder = new ThreadLocal<LinkedList<String>>() {
        @Override
        protected LinkedList<String> initialValue() {
            return new LinkedList<String>();
        }

    };
    /**
     * 初始化
     */
    @Override
    public void afterPropertiesSet() {
        if (null == master) {
            throw new IllegalArgumentException("主数据库加载失败！");
        }
        dataSources.put(DEFAULT, master);
        if (null != slaves && slaves.size() > 0) {
            for (int i = 0; i < slaves.size(); i++) {
                dataSources.put(SLAVE + (i + 1), slaves.get(i));
            }
            slaveSize = slaves.size();
        }
        this.setDefaultTargetDataSource(master);
        this.setTargetDataSources(dataSources);
        super.afterPropertiesSet();
    }
    /**
     * 选择使用主库，并把选择放到当前ThreadLocal的栈顶
     */
    public static void useMaster() {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("数据源使用:" + datasourceHolder.get());
        }
        LinkedList<String> m = datasourceHolder.get();
        m.offerFirst(DEFAULT);
    }
    /**
     * 选择使用从库，并把选择放到当前ThreadLocal的栈顶
     */
    public static void useSlave() {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("数据源使用:" + datasourceHolder.get());
        }
        LinkedList<String> m = datasourceHolder.get();
        m.offerFirst(SLAVE);
    }
    /**
     * 重置当前栈
     */
    public static void reset() {
        LinkedList<String> m = datasourceHolder.get();
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("重置数据源 {}", m);
        }
        if (m.size() > 0) {
            m.poll();
        }
    }
    /**
     * 如果是选择使用从库，且从库的数量大于1，则通过取模来控制从库的负载,
     * 计算结果返回AbstractRoutingDataSource
     */
    @Override
    protected Object determineCurrentLookupKey() {
        LinkedList<String> m = datasourceHolder.get();
        String key = m.peekFirst() == null ? "" : m.peekFirst();
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("当前数据源:" + key);
        }
        if (null != key) {
            if (DEFAULT.equals(key)) {
                return key;
            } else if (SLAVE.equals(key)) {
                if (slaveSize > 1) {
                    long c = slaveCount.incrementAndGet();
                    c = c % slaveSize;
                    return SLAVE + (c + 1);
                } else {
                    return SLAVE + "1";
                }
            }
            return null;
        } else {
            return null;
        }
    }
    public DataSource getMaster() {
        return master;
    }
    public List<DataSource> getSlaves() {
        return slaves;
    }
    public void setMaster(DataSource master) {
        this.master = master;
    }
    public void setSlaves(List<DataSource> slaves) {
        this.slaves = slaves;
    }
}

以上就是读写分离的基本配置。

在我们需要读取重数据库的方法上加入注解：@DataSourceChange(slave = true)

在程序中断点一下，可以看到每个类的先后执行顺序。
多个数据库之间的建立关系，后续会补上。