Spring 数据源配置三：多数据源

在上一节中，我们讲述了多数据的情况：

1. 数据源不同（数据库厂商不同， 业务范围不同， 业务数据不同）

2. SQL mapper 文件不同，

3. mybatis + 数据方言不同

即最为简单的多数据， 将多个数据源叠加在一起，不同service---》dao--->sessionFactory;

如果上述的所有条件都相同，仅仅是数据的的多个拷贝情况，想做主备（读写分离），那我们当然可以用2套复制的代码和配置，但是显然不是最佳的实现方式。

这里，我们就讲解一下多数据源的读写分离，怎么实现。

首先，我们从读写分离的入口来看，  读read (对应JAVA/ getXXX,  queryXXX),   写write(对应updateXXX,  insertXXX),  如果能在这些方法执行时，自动切换到只读数据库/只写数据，那么就可以实现读写分离， 那我们自然可以想到spring 的AOP， 并以annotation的方式实现。

具体实现步骤如下：

1.   实现自定义的数据源注解： @DataSource("read")  / @DataSource("write")

package com.robin.it.ds;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.ElementType;
/**  
 * RUNTIME  
 * 编译器将把注释记录在类文件中，在运行时 VM 将保留注释，因此可以反射性地读取。  
 * @author Robin.yi  
 *  
 */  

@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.METHOD)  
public @interface DataSource {
       String value();  
}

2.  实现一个数据库选择器ChooseDataSource

package com.robin.it.ds;

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

public class ChooseDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return HandleDataSource.getDataSource();
    }

}

============
package com.robin.it.ds;

public class HandleDataSource {
    
     public static final ThreadLocal<String> holder = new ThreadLocal<String>();  
     
        public static void putDataSource(String datasource) {  
            holder.set(datasource);  
        }  
          
        public static String getDataSource() {  
            return holder.get();  
        }      
}

3.   实现AOP 的的数据拦截，切换功能

package com.robin.it.ds;

import java.lang.reflect.Method;  

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
//@Aspect  
//@Component  
public class DataSourceAspect {  
    //@Pointcut("execution(* com.apc.cms.service.*.*(..))")    
    public void pointCut(){};    
      
  //  @Before(value = "pointCut()")  
     public void before(JoinPoint point)  
        {  
            Object target = point.getTarget();  
            System.out.println(target.toString());  
            String method = point.getSignature().getName();  
            System.out.println(method);  
            Class<?>[] classz = target.getClass().getInterfaces();  
            Class<?>[] parameterTypes = ((MethodSignature) point.getSignature())  
                    .getMethod().getParameterTypes();  
            try {  
                Method m = classz[0].getMethod(method, parameterTypes);  
                System.out.println(m.getName()); 
                if (m != null && m.isAnnotationPresent(DataSource.class)) {  
                    DataSource data = m.getAnnotation(DataSource.class); 
                    System.out.println("==============================={}"+data.value()); 
                    HandleDataSource.putDataSource(data.value());  
                }else{
                    System.out.println("000000000000000000000");
                }  
                  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
}  

 注意：  黄色高亮部分，利用反射读取 Interface的 的定义（包括annotation 的申明）；动态读取参数，进行数据源切换；

4.  定义接口服务

package com.robin.it.permission.service;

import com.robin.it.ds.DataSource;
import com.robin.it.permission.module.User;

/**
 * Created by Robin.yi  on 2015-4-11.
 */
public interface IUserService {
    
     @DataSource("read")
    public User getUser(Integer userId);

     @DataSource("read")  
    public User getUser(String account, String password);
     
     
     @DataSource("write")
    public void insertUser(User user);
}

 主意：上面是决定走读库/写库的语句：   @DataSource("write")   /  @DataSource("read")

  接口的实现无特别说明，此次省略。

5.  整个Spring 的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:tx="http://www.springframework.org/schema/tx"
          xmlns:aop="http://www.springframework.org/schema/aop"
          xmlns:util="http://www.springframework.org/schema/util"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
                                http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
                                http://www.springframework.org/schema/context
                                http://www.springframework.org/schema/context/spring-context-4.1.xsd
                                http://www.springframework.org/schema/tx
                                http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
                                http://www.springframework.org/schema/aop
                                http://www.springframework.org/schema/aop/spring-aop-4.1.xsd 
                                http://www.springframework.org/schema/util
                                http://www.springframework.org/schema/util/spring-util-4.1.xsd ">

    <description>
       This file is used to define the authority info.
    </description>

     <!-- 用于扫描 Spring 的各类annotation bean 变量:
        @autowired  ; @Resource
      -->
    <context:annotation-config/>

      <!-- 用于扫描类中组建：
         如： @Controller, @Service, @Component
     -->
     <context:component-scan base-package="com.robin.it.permission.*">
         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
     </context:component-scan>
     
     
     <tx:annotation-driven />  
     
     
     
     
     
     
     
     

    <bean  id="configProperties"  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="ignoreResourceNotFound" value="false" />
        <property name="locations">
            <list>
                <!-- 这里支持多种寻址方式：classpath和file -->
                 <value>classpath:/database.properties</value>
                 <value>classpath:/config.properties</value>  
                <!-- 推荐使用file的方式引入，这样可以将配置和代码分离 -->
               <!-- <value>file:/opt/demo/config/demo-message.properties</value>-->
            </list>
        </property>
    </bean>
    
    <util:properties  id="props" location="classpath:/config.properties"/>
    
    <!-- MYSQL 配置   -->
    
    <bean id="readDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName"><value>${mysql.jdbc.driverClassName}</value></property>
        <property name="url"><value>${mysql.jdbc.url}</value></property>
        <property name="username"><value>${mysql.jdbc.username}</value></property>
        <property name="password"><value>${mysql.jdbc.password}</value></property>
    </bean>
    
    <bean id="writeDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName"><value>${mysql2.jdbc.driverClassName}</value></property>
        <property name="url"><value>${mysql2.jdbc.url}</value></property>
        <property name="username"><value>${mysql2.jdbc.username}</value></property>
        <property name="password"><value>${mysql2.jdbc.password}</value></property>
    </bean>

    <bean id="dataSource" class="com.robin.it.ds.ChooseDataSource">  
        <property name="targetDataSources">    
              <map key-type="java.lang.String">    
                  <!-- write -->  
                 <entry key="write" value-ref="writeDataSource"/>    
                 <!-- read -->  
                 <entry key="read" value-ref="readDataSource"/>    
              </map>    
                
        </property>    
        <property name="defaultTargetDataSource" ref="writeDataSource"/>    
    </bean>  
   
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
       <property name="dataSource" ref="dataSource" />  
     </bean>  
   
   
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 指定sqlMapConfig总配置文件，订制的environment在spring容器中不在生效-->
         <property  name="configLocation"  value="classpath:mybatis-config-mysql.xml"/>
        <!--指定实体类映射文件，可以指定同时指定某一包以及子包下面的所有配置文件，mapperLocations和configLocation有一个即可，
         当需要为实体类指定别名时，可指定configLocation属性，再在mybatis总配置文件中采用mapper引入实体类映射文件 -->
         <property  name="mapperLocations">
               <list>
                <value>classpath*:/mysqlmapper/*Mapper.xml</value>
            </list>
         </property>
    </bean>

    <bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.robin.it.permission.dao" />
        <!-- optional unless there are multiple session factories defined -->
        <property name="sqlSessionFactoryBeanName" value="sessionFactory" />
    </bean>
     
     
     <aop:aspectj-autoproxy proxy-target-class="true"/> 
      
      <bean id="dataSourceAspect" class="com.robin.it.ds.DataSourceAspect" />  
          
       <aop:config>  
            <aop:aspect id="c" ref="dataSourceAspect">  
                <aop:pointcut id="tx" expression="execution(* com.robin.it.permission.service.*.*(..))"/>  
                <aop:before pointcut-ref="tx" method="before"/>  
            </aop:aspect>  
        </aop:config> 
</beans>

重点关注标为黄色的部分： 如何配置多数据源；  当知悉对应service  [com.robin.it.permission.service.*.*(..)] , 的相关方法之前（aop:before),  执行DataSourceAspect切面方法；

数据库配置文件database.properties 参考，上一章节。

到此，已完成多数据源的，读写分离配置。