spring+springmvc+mybatis+maven+mysql 数据库读写分离
spring+springmvc+mybatis+maven+mysql数据库读写分离
- 一、Spring+Springmvc+Mybatis+Maven创建Web项目
- 二、使用Spring AOP实现MySQL数据库读写分离
- 2.1 前言
- 2.2 实现读写分离的两种方法
- 三、Aop实现主从数据库的读写分离
- 3.1 首先配置 jdbc.properties 两个数据库 ReaddataSource 和 WritedataSource
- 3.2 配置applicationContent.xml文件
- 3.3 ChooseDataSource.java
- 3.4 DataSourceAspect.java进行具体方法的AOP拦截
- 3.5 DataSourceHandler.java，数据源的Handler类
- 四、效果展示
- 4.1 查询用户
- 4.2 添加一本书
- 五、代码资源
一、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();
}
}
配置成功，启动项目试试
四、效果展示
4.1 查询用户
get关键字，读取slave数据库，没有问题
4.2 添加一本书
add关键字，读取的是主数据库，没有问题
五、代码资源
spring+springmvc+mybatis+maven+mysql 数据库读写分离