基于spring-Mybatis的读写分离配置

参考：

2.http://www.cnblogs.com/liujiduo/p/5004691.html

遗留问题

(1) master和slave都需要写DataSource，默认应该就是master吧 :这个原因应该是我方法内service不是接口的实现类

(2)AOP只在service有效，应该在dao层和service层都可以吧，同时注解该有有限级别原因：

还是我的AOP表达式问题：<aop:pointcut id="dataSourcePointcut" expression="execution(* wusc.edu.demo.common.core.dao.BaseDao.*(..))"/>

@DataSource既可以加在方法上，也可以加在接口或者接口的实现类上，优先级别：方法>实现类>接口。也就是说如果接口、接口实现类以及方法上分别加了@DataSource注解来指定数据源，则优先以方法上指定的为准。

比如在Dao实现类上添加，在具体方法上包括像basedao的方法上添加，即可实现： 方法>实现类>接口

扫描二维码关注公众号，回复： 327757 查看本文章

@Repository("pmsUserDao")
@DataSource("master")
public class PmsUserDaoImpl extends BaseDaoImpl<PmsUser> implements PmsUserDao {

	/**
	 * 根据用户登录名获取用户信息.
	 * 
	 * @param loginName
	 *            .
	 * @return user .
	 */
	@DataSource("slave")
	public PmsUser findByUserNo(String userNo) {
		return super.getSqlSession().selectOne(getStatement("findByUserNo"), userNo);
	}

}

BaseDaoImpl

/**
	 * 批量更新对象.
	 * 
	 * @param entity
	 *            .
	 * @return int .
	 */
	public int update(List<T> list) {

		if (list == null || list.size() <= 0) {
			return 0;
		}

		int result = sessionTemplate.update(getStatement(SQL_BATCH_UPDATE), list);
		if (result <= 0) {
			throw BizException.DB_UPDATE_RESULT_0.newInstance("数据库操作,update返回0.{%s}", getStatement(SQL_UPDATE));
		}
		return result;
	}

	/**
	 * 根据ID查找对象.
	 * 
	 * @param id
	 *            .
	 * @return T .
	 */
	@DataSource("slave")
	public T getById(long id) {
		return sessionTemplate.selectOne(getStatement(SQL_GET_BY_ID), id);
	}

(3) 提取：<bean id="abstractDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> 报错

概述：

大型的电子商务系统，在数据库层面大都采用读写分离技术，就是一个Master数据库，多个Slave数据库。Master库负责数据更新和实时数据查询，Slave库当然负责非实时数据查询。

为什么使用读写分离/作用

在实际的应用中，数据库都是读多写少，而读取数据通常耗时比较长，占用数据库服务器的CPU较多，从而影响用户体验。我们通常的做法就是把查询从主库中抽取出来，采用多个从库，使用负载均衡，减轻每个从库的查询压力。

实现读写分离的技术目标

有效减轻Master库的压力，又可以把用户查询数据的请求分发到不同的Slave库，从而保证系统的健壮性。我们看下采用读写分离的背景。

什么情况下使用读写分离
随着网站的业务不断扩展，数据不断增加，用户越来越多，数据库的压力也就越来越大，采用传统的方式，比如：数据库或者SQL的优化基本已达不到要求，这个时候可以采用读写分离的策略来改变现状。

具体到开发中，如何方便的实现读写分离呢?目前常用的有两种方式：

第一种方式是我们最常用的方式，就是定义2个数据库连接，一个是MasterDataSource,另一个是SlaveDataSource。更新数据时我们读取MasterDataSource，查询数据时我们读取SlaveDataSource。这种方式很简单，我就不赘述了。

---- 待实现

第二种方式动态数据源切换，就是在程序运行时，把数据源动态织入到程序中，从而选择读取主库还是从库。主要使用的技术是：annotation，Spring AOP ，反射。下面会详细的介绍实现方式。

基于spring来配置和使用多数据源还是比较简单的，因为spring框架已经预留了这样的接口可以方便数据源的切换

1.创建一个DynamicDataSource的类，继承AbstractRoutingDataSource并重写determineCurrentLookupKey方法，代码如下：

package wusc.edu.demo.common.core.base;

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

public class DynamicDataSource extends AbstractRoutingDataSource{

	@Override
	protected Object determineCurrentLookupKey() {
		
		return DynamicDataSourceHolder.getDataSouce();
	}

}

2.创建DynamicDataSourceHolder：用于持有当前线程中使用的数据源标识

代码如下：

package wusc.edu.demo.common.core.base;

public class DynamicDataSourceHolder {
	
    /**
     * 注意：数据源标识保存在线程变量中，避免多线程操作数据源时互相干扰
     */
	public static final ThreadLocal<String> holder = new ThreadLocal<String>();

    public static void putDataSource(String name) {
        holder.set(name);
    }

    public static String getDataSouce() {
        return holder.get();
    } 

}

3.配置多个数据源和第一步里创建的DynamicDataSource的bean

简化的配置如下：

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
   
   
	<!-- 基础数据源 -->
<!-- 	<bean id="abstractDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> -->
<!-- 		<property name="driverClassName" value="com.mysql.jdbc.Driver" /> -->
<!-- 		<property name="initialSize" value="2" /> -->
<!-- 		<property name="minIdle" value="2" /> -->
<!-- 		<property name="maxActive" value="30" /> -->
<!-- 		<property name="testWhileIdle" value="false" /> -->
<!-- 		<property name="maxWait" value="5000" /> -->
<!-- 		<property name="minEvictableIdleTimeMillis" value="30000" /> -->
<!-- 		<property name="timeBetweenEvictionRunsMillis" value="60000" /> -->
<!-- 		<property name="filters" value="config" /> -->
<!-- 		<property name="connectionProperties" value="config.decrypt=true" /> -->
<!--     </bean>      

 parent="abstractDataSource"-->
  	
  	<!-- 主库-->
    <bean id="masterdataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="url" value="${jdbc.url.master}" />
		<property name="username" value="${jdbc.username.master}" />
		<property name="password" value="${jdbc.password.master}" />
		
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="initialSize" value="2" />
		<property name="minIdle" value="2" />
		<property name="maxActive" value="30" />
		<property name="testWhileIdle" value="false" />
		<property name="maxWait" value="5000" />
		<property name="minEvictableIdleTimeMillis" value="30000" />
		<property name="timeBetweenEvictionRunsMillis" value="60000" />
		<property name="filters" value="config" />
		<property name="connectionProperties" value="config.decrypt=true" />
    </bean>   

  	<!-- 从库-->
    <bean id="slavedataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="url" value="${jdbc.url.slave}" />
		<property name="username" value="${jdbc.username.slave}" />
		<property name="password" value="${jdbc.password.slave}" />
		
		
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="initialSize" value="2" />
		<property name="minIdle" value="2" />
		<property name="maxActive" value="30" />
		<property name="testWhileIdle" value="false" />
		<property name="maxWait" value="5000" />
		<property name="minEvictableIdleTimeMillis" value="30000" />
		<property name="timeBetweenEvictionRunsMillis" value="60000" />
		<property name="filters" value="config" />
		<property name="connectionProperties" value="config.decrypt=true" />		
    </bean>   
    
     <bean id="dataSource" class="wusc.edu.demo.common.core.base.DynamicDataSource">
        <property name="targetDataSources"> 
              <map key-type="java.lang.String"> 
                  <!-- write -->
                 <entry key="master" value-ref="masterdataSource"/> 
                 <!-- read -->
                 <entry key="slave" value-ref="slavedataSource"/> 
              </map> 
        </property> 
        <property name="defaultTargetDataSource" ref="masterdataSource"/> 
    </bean>  
    
	<!-- 将数据源映射到sqlSessionFactory中 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- SqlSession模板类实例 -->
	<bean id="sessionTemplate" class="org.mybatis.spring.SqlSessionTemplate" destroy-method="close">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>

	<!--======= 事务配置 Begin ================= -->
	<!-- 事务管理器（由Spring管理MyBatis的事务） -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 关联数据源 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!--======= 事务配置 End =================== -->

</beans>

4.在操作数据库之前只要DynamicDataSourceHolder.setDataSource("dataSource2")即可切换到数据源2并对数据库db2进行操作了

@Service("pmsUserBiz")
public class PmsUserBiz {
	
	public static Logger logger = LoggerFactory.getLogger(PmsUserBiz.class);
	
	@Autowired
	private PmsUserDao pmsUserDao;
	
	/**
	 * 保存用户信息.
	 * @param pmsUser
	 */
	public void create(PmsUser pmsUser) {
		DynamicDataSourceHolder.setDataSource("master");
		pmsUserDao.insert(pmsUser);
	}
	
	/**
	 * 根据ID获取用户信息.
	 * @param userId
	 * @return
	 */
	public PmsUser getById(Long userId) {
                 DynamicDataSourceHolder.setDataSource("slave");
		return pmsUserDao.getById(userId);
	}
}

5.问题及改进每次切换数据源时都调用DynamicDataSourceHolder.setDataSource("xxx")就显得十分繁琐了，而且代码量大了很容易会遗漏，后期维护起来也比较麻烦直接通过注解的方式指定需要访问的数据源呢，比如在dao层使用@DataSource("xxx")就指定访问数据源xxx？

5.1 定义DataSource的注解

package wusc.edu.demo.common.core.base;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//@Target({ TYPE, METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSource {
    String value();
}

5.2 定义AOP切面：以便拦截所有带有注解@DataSource的方法，取出注解的值作为数据源标识放到DynamicDataSourceHolder的线程变量中

package wusc.edu.demo.common.aop;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import wusc.edu.demo.common.core.base.DataSource;
import wusc.edu.demo.common.core.base.DynamicDataSourceHolder;

public class DataSourceAspect {
	
	public static Logger logger = LoggerFactory.getLogger(DataSourceAspect.class);
/**
 * 拦截目标方法，获取由@DataSource指定的数据源标识，设置到线程存储中以便切换数据源
 * 
 * @param point
 * @throws Exception
 */
public void intercept(JoinPoint point) throws Exception {
    Class<?> target = point.getTarget().getClass();
    MethodSignature signature = (MethodSignature) point.getSignature();
    // 默认使用目标类型的注解，如果没有则使用其实现接口的注解
    for (Class<?> clazz : target.getInterfaces()) {
        resolveDataSource(clazz, signature.getMethod());
    }
    resolveDataSource(target, signature.getMethod());
}

/**
 * 提取目标对象方法注解和类型注解中的数据源标识
 * 
 * @param clazz
 * @param method
 */
private void resolveDataSource(Class<?> clazz, Method method) {
    try {
        Class<?>[] types = method.getParameterTypes();
        // 默认使用类型注解
        if (clazz.isAnnotationPresent(DataSource.class)) {
            DataSource source = clazz.getAnnotation(DataSource.class);
            DynamicDataSourceHolder.putDataSource(source.value());
        }
        // 方法注解可以覆盖类型注解
        Method m = clazz.getMethod(method.getName(), types);
        if (m != null && m.isAnnotationPresent(DataSource.class)) {
            DataSource source = m.getAnnotation(DataSource.class);
            DynamicDataSourceHolder.putDataSource(source.value());
            logger.info("注入数据源:"+source.value());
        }
    } catch (Exception e) {
        System.out.println(clazz + ":" + e.getMessage());
    }
}

}

5.3 在spring配置文件中配置拦截规则就可以了，比如拦截service层或者dao层的所有方法

	<bean id="dataSourceAspect" class="wusc.edu.demo.common.aop.DataSourceAspect"></bean>
	
	
    <aop:config>
        <aop:aspect ref="dataSourceAspect">
			<aop:pointcut id="dataSourcePointcut" expression="within(wusc.edu.demo.user.biz.*)"/> 
            <aop:before pointcut-ref="dataSourcePointcut" method="intercept" />
        </aop:aspect>
    </aop:config>

5.4在类或者方法上使用注解@DataSource来指定数据源，不需要每次都手动设置了。

最佳实践：(1) master和slave都需要写DataSource （2）AOP只在service有效这些需要再确认

注解@DataSource既可以加在方法上，也可以加在接口或者接口的实现类上，优先级别：方法>实现类>接口。也就是说如果接口、接口实现类以及方法上分别加了@DataSource注解来指定数据源，则优先以方法上指定的为准。

@Service("pmsUserBiz")
public class PmsUserBiz {
	
	public static Logger logger = LoggerFactory.getLogger(PmsUserBiz.class);
	
	@Autowired
	private PmsUserDao pmsUserDao;
	
	/**
	 * 保存用户信息.
	 * @param pmsUser
	 */
	@DataSource("master")
	public void create(PmsUser pmsUser) {
		logger.info("保存用户信息");
		pmsUserDao.insert(pmsUser);
	}
	
	/**
	 * 根据ID获取用户信息.
	 * @param userId
	 * @return
	 */
	@DataSource("slave")
	public PmsUser getById(Long userId) {
		return pmsUserDao.getById(userId);
	}
}

基于spring-Mybatis的读写分离配置

猜你喜欢