java實現mysql數據庫讀寫分離

 第一中方式：定義2個數據庫連接，一個是MasterDataSource,另一個是SlaveDataSource。更新數據時我們讀取MasterDataSource，查詢數據時我們讀取SlaveDataSource

該示例是基於spring提供的AbstractRoutingDataSource，實現了一個動態數據源的功能，在spring配置中定義多個數據庫分為主、從數據庫，實現效果為當進行保存和修改記錄時則對主表操作，查詢則對從表進行操作，從而實現對數據庫表的讀寫分離。這樣做有利於提高網站的性能，特別是在數據庫這一層。因為在實際的應用中，數據庫都是讀多寫少（讀取數據的頻率高，更新數據的頻率相對較少），而讀取數據通常耗時比較長，占用數據庫服務器的CPU較多，從而影響用戶體驗。我們通常的做法就是把查詢從主庫中抽取出來，采用多個從庫，使用負載均衡，減輕每個從庫的查詢壓力。該示例並未對數據庫同步進行說明，只對讀寫操作的分離實現：

在進行操作之前，先簡單說一下AbstractRoutingDataSource相關的東西：

AbstractRoutingDataSource繼承了AbstractDataSource ，而AbstractDataSource 又是DataSource 的子類。DataSource   是javax.sql 的數據源接口，定義如下：

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean  {}

public interface DataSource  extends CommonDataSource,Wrapper {

  /**
   * <p>Attempts to establish a connection with the data source that
   * this <code>DataSource</code> object represents.
   *
   * @return  a connection to the data source
   * @exception SQLException if a database access error occurs
   */
  Connection getConnection() throws SQLException;

  /**
   * <p>Attempts to establish a connection with the data source that
   * this <code>DataSource</code> object represents.
   *
   * @param username the database user on whose behalf the connection is
   *  being made
   * @param password the user's password
   * @return  a connection to the data source
   * @exception SQLException if a database access error occurs
   * @since 1.4
   */
  Connection getConnection(String username, String password)
    throws SQLException;

}


public Connection getConnection() throws SQLException {
        return determineTargetDataSource().getConnection();
    }

    public Connection getConnection(String username, String password) throws SQLException {
        return determineTargetDataSource().getConnection(username, password);
    }

protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        Object lookupKey = determineCurrentLookupKey();
        DataSource dataSource = this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }
        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        }
        return dataSource;
    }

從上面的代碼中不難看出，獲取數據源首先是通過對determineCurrentLookupKey（）的調用獲取resolvedDataSources對應key的值，故執行創建一個動態數據源類繼承AbstractRoutingDataSource，復寫determineCurrentLookupKey（）去自定義設置和獲取resolvedDataSources的key就可以實現了

具體步驟如下：

第一步：

<?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:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
    default-lazy-init="true">
    <!-- 引入配置文件 -->  
    <context:component-scan base-package="com.he" />  
     <bean id="masterdataSource"
       class="org.apache.commons.dbcp.BasicDataSource"  
        destroy-method="close">  
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/test" />
        <property name="username" value="root" />
        <property name="password" value="111111" />
    </bean>

    <bean id="slavedataSource"
      class="org.apache.commons.dbcp.BasicDataSource"  
        destroy-method="close">  
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/test2" />
        <property name="username" value="root" />
        <property name="password" value="111111" />
    </bean>
    
    <bean id="dataSource" class="com.he.mysql.test.DynamicDataSource">
        <property name="targetDataSources">  
              <map key-type="java.lang.String">  
                  <!-- write -->
                 <entry key="masterdataSource" value-ref="masterdataSource"/>  
                 <!-- read -->
                 <entry key="slavedataSource" value-ref="slavedataSource"/>  
              </map>  
              
        </property>  
        <property name="defaultTargetDataSource" ref="masterdataSource"/>  
    </bean>
       
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <property name="mapperLocations" value="classpath:com/he/dao/*.xml"></property>  
    </bean>  

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="com.he.dao" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
    </bean>  
    
    <bean id="transactionManager"  
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean> 
   
    <!-- 注解式事務管理，需要在Service類上標注@Transactional -->
    <tx:annotation-driven transaction-manager="transactionManager" />
     
</beans>  

 

第二步：

public class DynamicDataSource extends AbstractRoutingDataSource {

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

}

第三步：

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();
    }
}

第四步：

@Service("userService")  
@Transactional
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userDao;public void add(User user) {
        
        DynamicDataSourceHolder.putDataSource("masterdataSource");
        userDao.add(user);
    }

    public void update(User user) {
        
        DynamicDataSourceHolder.putDataSource("masterdataSource");
        userDao.updates(user);
    
        
    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public List<User> query() {
        
        DynamicDataSourceHolder.putDataSource("slavedataSource");
        List<User> user = userDao.query();
        return user;
        
    }

    
    
    
}

 第二種實現方式：基於上述的配置，只需要做部分的更改即可，主要是結合springAOP思想和反射機制去實現

第一步：基於上面的spring配置中加入aop相關配置

<!-- 配置數據庫注解aop -->
    <bean id="manyDataSourceAspect" class="com.he.aspect.DataSourceAspect" />
    <aop:config>
        <aop:aspect id="c" ref="manyDataSourceAspect">
            <aop:pointcut id="tx" expression="execution(* com.he.dao.*.*(..))"/>
            <aop:before pointcut-ref="tx" method="before"/>
        </aop:aspect>
    </aop:config>

第二步：構建DataSource和DataSourceAspect

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

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

 

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

import com.he.mysql.test.DataSource;
import com.he.mysql.test.DynamicDataSourceHolder;


public class DataSourceAspect {
      public void before(JoinPoint point)
        {
            Object target = point.getTarget();
            String method = point.getSignature().getName();

            Class<?>[] classz = target.getClass().getInterfaces();

            Class<?>[] parameterTypes = ((MethodSignature) point.getSignature())
                    .getMethod().getParameterTypes();
            try {
                Method m = classz[0].getMethod(method, parameterTypes);
                if (m != null && m.isAnnotationPresent(DataSource.class)) {
                    DataSource data = m
                            .getAnnotation(DataSource.class);
                    DynamicDataSourceHolder.putDataSource(data.value());
                    System.out.println(data.value());
                }
                
            } catch (Exception e) {
                // TODO: handle exception
            }
        }

}

 

第三步：將serviceImpl中手動植入的代碼移除，在dao層接口加入注解

@Repository
public interface UserMapper {
    @DataSource("masterdataSource")
    public void add(User user);
    @DataSource("masterdataSource")
    public void updates(User user);
    @DataSource("slavedataSource")
    public List<User> query();
}

 

上述為實現讀寫分離的關鍵部分，只是為了簡單的做一個示例，完成上面操作以后，可自行的對數據庫進行新增和查詢操作，查看效果