tomas-works

自己研究点技术没事上传下做个记录 Spring和MyBatis实现数据的读写分离 2016-04-26 10:07 1119人阅读评论(0) 收藏举报分类：网站架构（12）
版权声明：本文为博主原创文章，未经博主允许不得转载。目录(?)[+] 1.Spring实现数据库的读写分离现在大型的电子商务系统，在数据库层面大都采用读写分离技术，就是一个Master数据库，多个Slave数据库。Master库负责数据更新和实时数据查询，Slave库当然负责非实时数据查询。因为在实际的应用中，数据库都是读多写少（读取数据的频率高，更新数据的频率相对较少），而读取数据通常耗时比较长，占用数据库服务器的CPU较多，从而影响用户体验。我们通常的做法就是把查询从主库中抽取出来，采用多个从库，使用负载均衡，减轻每个从库的查询压力。

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

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

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

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

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

　　　在介绍实现方式之前，我们先准备一些必要的知识，spring 的AbstractRoutingDataSource 类

　　 AbstractRoutingDataSource这个类是spring2.0以后增加的，我们先来看下AbstractRoutingDataSource的定义：

　　　　public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {}

　　 AbstractRoutingDataSource继承了AbstractDataSource ，而AbstractDataSource 又是DataSource 的子类。DataSource 是javax.sql 的数据源接口，定义如下：

复制代码 public interface DataSource extends CommonDataSource,Wrapper {

/**

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

/**

Attempts to establish a connection with the data source that
this DataSource 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;

} 复制代码

　　DataSource 接口定义了2个方法，都是获取数据库连接。我们在看下AbstractRoutingDataSource 如何实现了DataSource接口：

复制代码 public Connection getConnection() throws SQLException { return determineTargetDataSource().getConnection(); }

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

复制代码

　　很显然就是调用自己的determineTargetDataSource() 方法获取到connection。determineTargetDataSource方法定义如下：

复制代码 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; } 复制代码

　我们最关心的还是下面2句话：

　　 Object lookupKey = determineCurrentLookupKey(); DataSource dataSource = this.resolvedDataSources.get(lookupKey);

determineCurrentLookupKey方法返回lookupKey,resolvedDataSources方法就是根据lookupKey从Map中获得数据源。resolvedDataSources 和determineCurrentLookupKey定义如下：

　　private Map<Object, DataSource> resolvedDataSources;

　　protected abstract Object determineCurrentLookupKey()

　　看到以上定义，我们是不是有点思路了，resolvedDataSources是Map类型，我们可以把MasterDataSource和SlaveDataSource存到Map中，如下：

　　　　key　　　　　　　　value

　　　　master　　 MasterDataSource

　　　　slave SlaveDataSource

　　我们在写一个类DynamicDataSource 继承AbstractRoutingDataSource，实现其determineCurrentLookupKey() 方法，该方法返回Map的key，master或slave。

　　好了，说了这么多，有点烦了，下面我们看下怎么实现。

　　上面已经提到了我们要使用的技术，我们先看下annotation的定义：

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

我们还需要实现spring的抽象类AbstractRoutingDataSource，就是实现determineCurrentLookupKey方法：

复制代码 public class DynamicDataSource extends AbstractRoutingDataSource {

@Override
protected Object determineCurrentLookupKey() {
    // TODO Auto-generated method stub
    return DynamicDataSourceHolder.getDataSouce();
}

}

public class DynamicDataSourceHolder { public static final ThreadLocal holder = new ThreadLocal();

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

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

} 复制代码

从DynamicDataSource 的定义看出，他返回的是DynamicDataSourceHolder.getDataSouce()值，我们需要在程序运行时调用DynamicDataSourceHolder.putDataSource()方法，对其赋值。下面是我们实现的核心部分，也就是AOP部分，DataSourceAspect定义如下:

复制代码 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
    }
}

} 复制代码

为了方便测试，我定义了2个数据库，shop模拟Master库，test模拟Slave库，shop和test的表结构一致，但数据不同，数据库配置如下：

复制代码

<bean id="slavedataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/test" />
    <property name="username" value="root" />
    <property name="password" value="yangyanping0615" />
</bean>

    <beans:bean id="dataSource" class="com.air.shop.common.db.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"/>  
</beans:bean>

<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>


<!-- 配置SqlSessionFactoryBean -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:config/mybatis-config.xml" />
</bean>

复制代码

　　在spring的配置中增加aop配置

复制代码

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<beans:bean id="manyDataSourceAspect" class="com.air.shop.proxy.DataSourceAspect" />
<aop:config>
    <aop:aspect id="c" ref="manyDataSourceAspect">
        <aop:pointcut id="tx" expression="execution(* com.air.shop.mapper.*.*(..))"/>
        <aop:before pointcut-ref="tx" method="before"/>
    </aop:aspect>
</aop:config>
<!-- 配置数据库注解aop -->

复制代码

　　下面是MyBatis的UserMapper的定义，为了方便测试，登录读取的是Master库，用户列表读取Slave库：

复制代码 public interface UserMapper { @DataSource("master") public void add(User user);

@DataSource("master")
public void update(User user);

@DataSource("master")
public void delete(int id);

@DataSource("slave")
public User loadbyid(int id);

@DataSource("master")
public User loadbyname(String name);

@DataSource("slave")
public List<User> list();

} 复制代码

　　好了，运行我们的Eclipse看看效果，输入用户名admin 登录看看效果

从图中可以看出，登录的用户和用户列表的数据是不同的，也验证了我们的实现，登录读取Master库，用户列表读取Slave库。

2.MyBatis多数据源配置实现读写分离

首先说明，本文的配置使用的最直接的方式，实际用起来可能会很麻烦。

实际应用中可能存在多种结合的情况，你可以理解本文的含义，不要死板的使用。

多数据源的可能情况

1.主从

通常是MySQL一主多从的情况，本文的例子就是主从的情况，但是只有两个数据源，所以采用直接配置不会太麻烦，但是不利于后续扩展，主要是作为一个例子来说明，实际操作请慎重考虑。

针对这种情况，一个更好的解决方法可以参考（本人没有实际尝试过）：

http://blog.csdn.net/lixiucheng005/article/details/17391857 还有一个通过SpringAbstractRoutingDataSource路由接口的方式：

http://blog.csdn.net/xtj332/article/details/43953699 2.分库

当业务独立性强，数据量大的时候的，为了提高并发，可能会对表进行分库，分库后，每一个数据库都需要配置一个数据源。

这种情况可以参考本文，但是需要注意每一个数据库对应的Mapper要在不同的包下方便区分和配置。

另外分库的情况下也会存在主从的情况，如果你的数据库从库过多，就参考上面提供的方法，或者寻找其他方式解决。

Mapper分包

分库的情况下，不同的数据库的Mapper一定放在不同的包下。

主从的情况下，同一个Mapper会同时存在读写的情况，创建两个并不合适，使用同一个即可。但是这种情况下需要注意，Spring对Mapper自动生成的名字是相同的，而且类型也相同，这是就不能直接注入Mapper接口。需要通过SqlSession来解决。

Spring基础配置

applicationContext.xml

这个文件，主要是引入了spring-datasource-master.xml和spring-datasource-slave.xml。

spring-datasource-master.xml

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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"> <bean id="dataSourceMaster" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> <property name="driverClassName" value="${master.jdbc.driverClass}"/> <property name="url" value="${master.jdbc.url}"/> <property name="username" value="${master.jdbc.user}"/> <property name="password" value="${master.jdbc.password}"/> <property name="filters" value="stat"/> <property name="maxActive" value="20"/> <property name="initialSize" value="1"/> <property name="maxWait" value="60000"/> <property name="minIdle" value="1"/> <property name="timeBetweenEvictionRunsMillis" value="60000"/> <property name="minEvictableIdleTimeMillis" value="300000"/> <property name="validationQuery" value="SELECT 'x'"/> <property name="testWhileIdle" value="true"/> <property name="testOnBorrow" value="false"/> <property name="testOnReturn" value="false"/> </bean> <bean id="sqlSessionFactory1" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSourceMaster"/> <property name="mapperLocations"> <array> <value>classpath:mapper/.xml</value> </array> </property> </bean> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.isea533.mybatis.mapper"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory1"/> </bean> <bean id="sqlSessionMaster" class="org.mybatis.spring.SqlSessionTemplate" scope="prototype"> <constructor-arg index="0" ref="sqlSessionFactory1"/> </bean> <aop:config> <aop:pointcut id="appService" expression="execution( com.isea533.mybatis.service..Service.(..))"/> <aop:advisor advice-ref="txAdvice1" pointcut-ref="appService"/> </aop:config> <tx:advice id="txAdvice1" transaction-manager="transactionManager1"> <tx:attributes> <tx:method name="select" read-only="true"/> <tx:method name="find*" read-only="true"/> <tx:method name="get*" read-only="true"/> <tx:method name="*"/> </tx:attributes> </tx:advice> <bean id="transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSourceMaster"/> </bean> </beans>

spring-datasource-slave.xml

和master区别不大，主要是id名字和数据源配置有区别。

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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"> <bean id="dataSourceSlave" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> <property name="driverClassName" value="${slave.jdbc.driverClass}"/> <property name="url" value="${slave.jdbc.url}"/> <property name="username" value="${slave.jdbc.user}"/> <property name="password" value="${slave.jdbc.password}"/> <property name="filters" value="stat"/> <property name="maxActive" value="20"/> <property name="initialSize" value="1"/> <property name="maxWait" value="60000"/> <property name="minIdle" value="1"/> <property name="timeBetweenEvictionRunsMillis" value="60000"/> <property name="minEvictableIdleTimeMillis" value="300000"/> <property name="validationQuery" value="SELECT 'x'"/> <property name="testWhileIdle" value="true"/> <property name="testOnBorrow" value="false"/> <property name="testOnReturn" value="false"/> </bean> <bean id="sqlSessionFactory2" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSourceSlave"/> <property name="mapperLocations"> <array> <value>classpath:mapper/.xml</value> </array> </property> </bean> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.isea533.mybatis.mapper"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory2"/> </bean> <bean id="sqlSessionSlave" class="org.mybatis.spring.SqlSessionTemplate" scope="prototype"> <constructor-arg index="0" ref="sqlSessionFactory2"/> </bean> <aop:config> <aop:pointcut id="appService" expression="execution( com.isea533.mybatis.service..Service.(..))"/> <aop:advisor advice-ref="txAdvice2" pointcut-ref="appService"/> </aop:config> <tx:advice id="txAdvice2" transaction-manager="transactionManager2"> <tx:attributes> <tx:method name="" read-only="true"/> </tx:attributes> </tx:advice> <bean id="transactionManager2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSourceSlave"/> </bean> </beans>

这里需要注意<tx:method name="*" read-only="true"/>是只读的。如果不是从库，可以按主库进行配置。

在下面代码中：

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.isea533.mybatis.mapper"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory2"/> </bean>

必须通过sqlSessionFactoryBeanName来指定不同的sqlSessionFactory。

config.properties

# 数据库配置 - Master master.jdbc.driverClass = com.mysql.jdbc.Driver master.jdbc.url = jdbc:mysql://192.168.1.11:3306/test master.jdbc.user = root master.jdbc.password = jj # - Slave slave.jdbc.driverClass = com.mysql.jdbc.Driver slave.jdbc.url = jdbc:mysql://192.168.1.22:3306/test slave.jdbc.user = root slave.jdbc.password = jj

使用Mapper

这里是针对主从的情况进行设置的，两个配置扫描的Mapper是一样的，所以没法直接注入，需要通过下面的麻烦方式注入。

@Service public class DemoService { private CountryMapper writeMapper; private CountryMapper readMapper; @Resource(name = "sqlSessionMaster") public void setWriteMapper(SqlSession sqlSession) { this.writeMapper = sqlSession.getMapper(CountryMapper.class); } @Resource(name = "sqlSessionSlave") public void setReadMapper(SqlSession sqlSession) { this.readMapper = sqlSession.getMapper(CountryMapper.class); } public int save(Country country){ return writeMapper.insert(country); } public List selectPage(int pageNum, int pageSize) { PageHelper.startPage(pageNum, pageSize); return readMapper.select(null); } }

因为sqlSession能通过name区分开，所以这里从sqlSession获取Mapper。

另外如果需要考虑在同一个事务中写读的时候，需要使用相同的writeMapper，这样在读的时候，才能获取事务中的最新数据。

以上是主从的情况。

在分库的情况时，由于不同Mapper在不同的包下，所以可以直接使用@Resource或者@Autowired注入Mapper，不需要通过sqlSession获取。

happytomas / tomas-works Goto Github PK

tomas-works's Introduction

tomas-works

tomas-works's People

Contributors

Watchers

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent