一、Spring+Springmvc+Mybatis+Maven创建Web项目

参考Spring+Springmvc+Mybatis+Maven创建Web项目实践

二、使用Spring AOP实现MySQL数据库读写分离

2.1 前言

在进行数据库读写分离的时候，我们首先要进行数据库的主从配置，最简单的是一台Master和一台Slave（大型网站系统的话，当然会很复杂，这里只是分析了最简单的情况）。通过主从配置主从数据库保持了相同的数据，我们在进行读操作的时候访问从数据库Slave，在进行写操作的时候访问主数据库Master。这样的话就减轻了一台服务器的压力。
在进行读写分离前，首先，配置数据库的主从复制：
Windows下mysql5.5主从复制

2.2 实现读写分离的两种方法

具体到开发中，实现读写分离常用的有两种方式：

1、第一种方式是我们最常用的方式，就是定义2个数据库连接，一个是MasterDataSource,另一个是SlaveDataSource。更新数据时我们读取MasterDataSource，查询数据时我们读取SlaveDataSource。

2、第二种方式动态数据源切换，就是在程序运行时，把数据源动态织入到程序中，从而选择读取主库还是从库。主要使用的技术是：Annotation，Spring AOP ，反射。

下面会详细的介绍实现方式。

三、Aop实现主从数据库的读写分离

3.1 首先配置 jdbc.properties 两个数据库 ReaddataSource 和 WritedataSource

driver =com.mysql.jdbc.Driver
writeurl=jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf8
writeusername=root
writepassword=123456

readurl=jdbc:mysql://192.168.216.129:3306/test1?useUnicode=true&characterEncoding=utf8
readusername=root
readpassword=123456

#定义初始连接数
initialSize=0
#定义最大连接数  
maxActive=20
#定义最大空闲  
maxIdle=20
#定义最小空闲  
minIdle=1
#定义最长等待时间  
maxWait=60000

3.2 配置applicationContent.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
                     http://www.springframework.org/schema/beans/spring-beans.xsd 
                     http://www.springframework.org/schema/context
					 http://www.springframework.org/schema/context/spring-context.xsd
                     http://www.springframework.org/schema/tx 
                     http://www.springframework.org/schema/tx/spring-tx.xsd 
                     http://www.springframework.org/schema/aop 
                     http://www.springframework.org/schema/aop/spring-aop.xsd">


	<!-- 自动扫描 -->
	<context:annotation-config />
	<context:component-scan base-package="com.demo.biz" />
	<context:component-scan base-package="com.demo.dao" />

	<!-- 引入配置文件 -->
	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="classpath:jdbc.properties" />
	</bean>

	<!-- 主数据源，支持写 -->
	<bean id="WritedataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${driver}" />
		<property name="url" value="${writeurl}" />
		<property name="username" value="${writeusername}" />
		<property name="password" value="${writepassword}" />
		<!-- 初始化连接大小 -->
		<property name="initialSize" value="${initialSize}"></property>
		<!-- 连接池最大数量 -->
		<property name="maxActive" value="${maxActive}"></property>
		<!-- 连接池最大空闲 -->
		<property name="maxIdle" value="${maxIdle}"></property>
		<!-- 连接池最小空闲 -->
		<property name="minIdle" value="${minIdle}"></property>
		<!-- 获取连接最大等待时间 -->
		<property name="maxWait" value="${maxWait}"></property>
	</bean>
	
	<!--附属数据源，用于读 -->
	<bean id="ReaddataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${driver}" />
		<property name="url" value="${readurl}" />
		<property name="username" value="${readusername}" />
		<property name="password" value="${readpassword}" />
		<!-- 初始化连接大小 -->
		<property name="initialSize" value="${initialSize}"></property>
		<!-- 连接池最大数量 -->
		<property name="maxActive" value="${maxActive}"></property>
		<!-- 连接池最大空闲 -->
		<property name="maxIdle" value="${maxIdle}"></property>
		<!-- 连接池最小空闲 -->
		<property name="minIdle" value="${minIdle}"></property>
		<!-- 获取连接最大等待时间 -->
		<property name="maxWait" value="${maxWait}"></property>
	</bean>
	
	<!-- 配置动态分配的读写 数据源 -->
    <bean id="dataSource" class="com.demo.util.ChooseDataSource" lazy-init="true">
    	<!-- 设置默认的数据源，这里默认走写库 -->
        <property name="defaultTargetDataSource" ref="WritedataSource"/>
        <property name="targetDataSources">
            <map key-type="java.lang.String" value-type="javax.sql.DataSource">
            	<!-- read -->
                <entry key="read" value-ref="ReaddataSource"/>
                <!-- write -->
                <entry key="write" value-ref="WritedataSource"/>
            </map>
        </property>
		
        <property name="methodType">
            <map key-type="java.lang.String">
                <!-- read -->
                <entry key="read" value="get,select,count,list,query"/>
                <!-- write -->
                <entry key="write" value="add,create,update,delete,remove"/>
            </map>
        </property>
    </bean>
    
    <!-- 使AspectJ注解起作用：自动为匹配的类生成代理对象 -->
    <!-- 加入 aop 自动扫描 DataSourceAspect 配置数据库注解aop -->
	<aop:aspectj-autoproxy proxy-target-class="true"/>
	<!--切面-->
    <bean id="DataSourceAspect" class="com.demo.util.DataSourceAspect"></bean>

	<!-- SqlSessionFactoryBean 是用于创建 SqlSessionFactory -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:myBatis.xml" />
	</bean>
	
	 <!-- DAO接口所在包名，Spring会自动查找其下的类 -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="com.demo.dao.mybatis" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
    </bean>  

	<!-- 事 务 处 理 -->
	<tx:annotation-driven transaction-manager="transactionManager" />
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

</beans>

上述配置中，配置了ReaddataSource和WritedataSource两个数据源，但是交给sqlSessionFactory进行管理的只有dataSource，其中使用到了：com.demo.util.ChooseDataSource这个是进行数据库选择的。

<property name="methodType">
    <map key-type="java.lang.String">
        <!-- read -->
        <entry key="read" value="get,select,count,list,query"/>
        <!-- write -->
        <entry key="write" value="add,create,update,delete,remove"/>
    </map>
</property>

配置了数据库具体的那些是读哪些是写的前缀关键字。ChooseDataSource的具体代码如下：

3.3 ChooseDataSource.java

package com.demo.util;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 获取数据源，用于动态切换数据源
 */
public class ChooseDataSource extends AbstractRoutingDataSource {

	public static Map<String, List<String>> METHOD_TYPE_MAP = new HashMap<String, List<String>>();

	/**
	 * 实现父类中的抽象方法，获取数据源名称
	 * @return
	 */
	@Autowired
	protected Object determineCurrentLookupKey() {
		return DataSourceHandler.getDataSource();
	}

	// 设置方法名前缀对应的数据源
	// 这个是用过set方法为methodType属性注入值，注入的配置是在applicationContent.xml文件中配置的
	public void setMethodType(Map<String, String> map) {
		for (String key : map.keySet()) {
			List<String> v = new ArrayList<String>();
			String[] types = map.get(key).split(",");
			for (String type : types) {
				if (StringUtils.isNotBlank(type)) {
					v.add(type);
				}
			}
			METHOD_TYPE_MAP.put(key, v);
		}
	}
}

3.4 DataSourceAspect.java进行具体方法的AOP拦截

package com.demo.util;

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切换数据源(不同方法调用不同数据源)
 */
@Aspect
@Component
@EnableAspectJAutoProxy(proxyTargetClass = true)
@Order(1)
public class DataSourceAspect {

	protected Logger logger = LoggerFactory.getLogger(this.getClass());

	// 1、execution(): 表达式主体。
	// 2、第一个*号：表示返回类型， *号表示所有的类型。
	// 3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.demo.biz包、子孙包下所有类的方法。
	// 4、第二个*号：表示类名，*号表示所有的类。
	// 5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数
	@Pointcut("execution(* com.demo.biz..*.*(..))")
	public void aspect() {
	}

	/**
	 * 配置前置通知,使用在方法aspect()上注册的切入点
	 */
	@Before("aspect()")
	public void before(JoinPoint point) {
		String className = point.getTarget().getClass().getName();
		String method = point.getSignature().getName();
		logger.info(className + "." + method + "(" + StringUtils.join(point.getArgs(), ",") + ")");
		try {
			for (String key : ChooseDataSource.METHOD_TYPE_MAP.keySet()) {
				for (String type : ChooseDataSource.METHOD_TYPE_MAP.get(key)) {
					if (method.startsWith(type)) {
						DataSourceHandler.clearDataSource();
						DataSourceHandler.putDataSource(key);
						System.out.println("数据源--------" + key);
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

@Pointcut("execution(* com.demo.biz..*.*(..))")

1、execution(): 表达式主体。
2、第一个*号：表示返回类型，号表示所有的类型。
3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.demo.biz包、子孙包下所有类的方法。
4、第二个号：表示类名，号表示所有的类。
5、(…):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数

这里一定要注意一个问题，在类的头部加上@Order(1)，不然程序在执行的时候会在aop截面之前调用ChooseDataSource.java中的determineCurrentLookupKey()方法

protected Object determineCurrentLookupKey() {
	return DataSourceHandler.getDataSource();
}
结果导致，虽然拦截到了，也设置了，但是数据库切换的时候出现了问题。

3.5 DataSourceHandler.java，数据源的Handler类

package com.demo.util;

/**
 * 数据源的Handler类
 */
public class DataSourceHandler {

	// 使用ThreadLocal记录当前线程的数据源key
	public static final ThreadLocal<String> holder = new ThreadLocal<String>();

	/**
	 * 在项目启动的时候将配置的读、写数据源加到holder中
	 */
	public static void putDataSource(String datasource) {
		holder.set(datasource);
	}

	/**
	 * 从holer中获取数据源字符串
	 */
	public static String getDataSource() {
		return holder.get();
	}

	// 清除数据库连接
	public static void clearDataSource() {
		holder.remove();
	}
}