在应用层通过spring特性解决数据库读写分离

在应用层通过spring特性解决数据库读写分离 

 

如何配置mysql数据库的主从？

单机配置mysql主从：http://my.oschina.net/god/blog/496

 

常见的解决数据库读写分离有两种方案

1、应用层

http://neoremind.net/2011/06/spring实现数据库读写分离

目前的一些解决方案需要在程序中手动指定数据源，比较麻烦，后边我会通过AOP思想来解决这个问题。

 

2、中间件

mysql-proxy：http://hi.baidu.com/geshuai2008/item/0ded5389c685645f850fab07

Amoeba for MySQL：http://www.iteye.com/topic/188598和http://www.iteye.com/topic/1113437

 

此处我们介绍一种在应用层的解决方案，通过spring动态数据源和AOP来解决数据库的读写分离。

 

该方案目前已经在一个互联网项目中使用了，而且可以很好的工作。

 

该方案目前支持

一读多写；当写时默认读操作到写库、当写时强制读操作到读库。

 

考虑未来支持

读库负载均衡、读库故障转移等。

 

使用场景

不想引入中间件，想在应用层解决读写分离，可以考虑这个方案；

建议数据访问层使用jdbc、ibatis，不建议hibernate。

 

优势

应用层解决，不引入额外中间件；

在应用层支持『当写时默认读操作到写库』，这样如果我们采用这种方案，在写操作后读数据直接从写库拿，不会产生数据复制的延迟问题；

应用层解决读写分离，理论支持任意数据库。

 

 

缺点

1、不支持@Transactional注解事务，此方案要求所有读方法必须是read-only=true，因此如果是@Transactional，这样就要求在每一个读方法头上加@Transactional 且readOnly属性=true，相当麻烦。 :oops: 

2、必须按照配置约定进行配置，不够灵活。

 

两种方案

方案1：当只有读操作的时候，直接操作读库（从库）；

        当在写事务（即写主库）中读时，也是读主库（即参与到主库操作），这样的优势是可以防止写完后可能读不到刚才写的数据；

 

此方案其实是使用事务传播行为为：SUPPORTS解决的。

 

方案2：当只有读操作的时候，直接操作读库（从库）；

        当在写事务（即写主库）中读时，强制走从库，即先暂停写事务，开启读（读从库），然后恢复写事务。

此方案其实是使用事务传播行为为：NOT_SUPPORTS解决的。

 

核心组件

cn.javass.common.datasource.ReadWriteDataSource：读写分离的动态数据源，类似于AbstractRoutingDataSource，具体参考javadoc；

cn.javass.common.datasource.ReadWriteDataSourceDecision：读写库选择的决策者，具体参考javadoc；

cn.javass.common.datasource.ReadWriteDataSourceProcessor：此类实现了两个职责（为了减少类的数量将两个功能合并到一起了）：读/写动态数据库选择处理器、通过AOP切面实现读/写选择，具体参考javadoc。

 

具体配置

1、数据源配置

1.1、写库配置

Java代码  

  1.     <bean id="writeDataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">  
  2.     <property name="alias" value="writeDataSource"/>  
  3.     <property name="driver" value="${write.connection.driver_class}" />  
  4.     <property name="driverUrl" value="${write.connection.url}" />  
  5.     <property name="user" value="${write.connection.username}" />  
  6.     <property name="password" value="${write.connection.password}" />  
  7.     <property name="maximumConnectionCount" value="${write.proxool.maximum.connection.count}"/>  
  8.     <property name="minimumConnectionCount" value="${write.proxool.minimum.connection.count}" />  
  9.     <property name="statistics" value="${write.proxool.statistics}" />  
  10.     <property name="simultaneousBuildThrottle" value="${write.proxool.simultaneous.build.throttle}"/>  
  11. </bean>  

 

1.2、读库配置

Java代码  

  1. <bean id="readDataSource1" class="org.logicalcobwebs.proxool.ProxoolDataSource">  
  2.     <property name="alias" value="readDataSource"/>  
  3.     <property name="driver" value="${read.connection.driver_class}" />  
  4.     <property name="driverUrl" value="${read.connection.url}" />  
  5.     <property name="user" value="${read.connection.username}" />  
  6.     <property name="password" value="${read.connection.password}" />  
  7.     <property name="maximumConnectionCount" value="${read.proxool.maximum.connection.count}"/>  
  8.     <property name="minimumConnectionCount" value="${read.proxool.minimum.connection.count}" />  
  9.     <property name="statistics" value="${read.proxool.statistics}" />  
  10.     <property name="simultaneousBuildThrottle" value="${read.proxool.simultaneous.build.throttle}"/>  
  11. </bean>   

1.3、读写动态库配置   

通过writeDataSource指定写库，通过readDataSourceMap指定从库列表，从库列表默认通过顺序轮询来使用读库，具体参考javadoc；

Java代码  

  1. <bean id="readWriteDataSource" class="cn.javass.common.datasource.ReadWriteDataSource">  
  2.     <property name="writeDataSource" ref="writeDataSource"/>  
  3.     <property name="readDataSourceMap">  
  4.        <map>  
  5.           <entry key="readDataSource1" value-ref="readDataSource1"/>  
  6.           <entry key="readDataSource2" value-ref="readDataSource1"/>  
  7.           <entry key="readDataSource3" value-ref="readDataSource1"/>  
  8.           <entry key="readDataSource4" value-ref="readDataSource1"/>  
  9.        </map>  
  10.     </property>  
  11. </bean>   

 

2、XML事务属性配置

所以读方法必须是read-only（必须，以此来判断是否是读方法）。

Java代码  

  1. <tx:advice id="txAdvice" transaction-manager="txManager">  
  2.     <tx:attributes>  
  3.         <tx:method name="save*" propagation="REQUIRED" />  
  4.         <tx:method name="add*" propagation="REQUIRED" />  
  5.         <tx:method name="create*" propagation="REQUIRED" />  
  6.         <tx:method name="insert*" propagation="REQUIRED" />  
  7.         <tx:method name="update*" propagation="REQUIRED" />  
  8.         <tx:method name="merge*" propagation="REQUIRED" />  
  9.         <tx:method name="del*" propagation="REQUIRED" />  
  10.         <tx:method name="remove*" propagation="REQUIRED" />  
  11.           
  12.         <tx:method name="put*" read-only="true"/>  
  13.         <tx:method name="query*" read-only="true"/>  
  14.         <tx:method name="use*" read-only="true"/>  
  15.         <tx:method name="get*" read-only="true" />  
  16.         <tx:method name="count*" read-only="true" />  
  17.         <tx:method name="find*" read-only="true" />  
  18.         <tx:method name="list*" read-only="true" />  
  19.           
  20.         <tx:method name="*" propagation="REQUIRED"/>  
  21.     </tx:attributes>  
  22. </tx:advice>   

 

3、事务管理器

事务管理器管理的是readWriteDataSource

Java代码  

  1. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  2.         <property name="dataSource" ref="readWriteDataSource"/>  
  3.     </bean>   

 

4、读/写动态数据库选择处理器

根据之前的txAdvice配置的事务属性决定是读/写，具体参考javadoc；

forceChoiceReadWhenWrite：用于确定在如果目前是写（即开启了事务），下一步如果是读，是直接参与到写库进行读，还是强制从读库读，具体参考javadoc；

Java代码  

  1. <bean id="readWriteDataSourceTransactionProcessor" class="cn.javass.common.datasource.ReadWriteDataSourceProcessor">  
  2.    <property name="forceChoiceReadWhenWrite" value="false"/>  
  3. </bean>   

 

5、事务切面和读/写库选择切面

Java代码  

  1. <aop:config expose-proxy="true">  
  2.     <!-- 只对业务逻辑层实施事务 -->  
  3.     <aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" />  
  4.     <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>  
  5.       
  6.     <!-- 通过AOP切面实现读/写库选择 -->  
  7.     <aop:aspect order="-2147483648" ref="readWriteDataSourceTransactionProcessor">  
  8.        <aop:around pointcut-ref="txPointcut" method="determineReadOrWriteDB"/>  
  9.     </aop:aspect>  
  10. </aop:config>   

1、事务切面一般横切业务逻辑层；

2、此处我们使用readWriteDataSourceTransactionProcessor的通过AOP切面实现读/写库选择功能，order=Integer.MIN_VALUE(即最高的优先级)，从而保证在操作事务之前已经决定了使用读/写库。

 

6、测试用例

只要配置好事务属性（通过read-only=true指定读方法）即可，其他选择读/写库的操作都交给readWriteDataSourceTransactionProcessor完成。

 

可以参考附件的：

cn.javass.readwrite.ReadWriteDBTestWithForceChoiceReadOnWriteFalse

cn.javass.readwrite.ReadWriteDBTestWithNoForceChoiceReadOnWriteTrue

 

 

可以下载附件的代码进行测试，具体选择主/从可以参考日志输出。

 

暂不想支持@Transactional注解式事务。

 

PS：欢迎拍砖指正。   

 

 

 

时间： 2024-04-19 19:42:03

在应用层通过spring特性解决数据库读写分离的相关文章

spring aop实现mysql读写分离(可用于SAE的mysql数据库)

spring aop实现mysql读写分离(可用于SAE的mysql数据库)  发表于 2014-3-12 12:46:53 |只看该作者 |倒序浏览          前言:SAE的MySQL数据库提供了主从数据库,我们可以向主数据库写数据,同时从从库里面读取数.如果在程序中不做数据库的读写切换是无法正常使用SAE的MYSQL数据库的,我们可以使用spring的aop功能实现mysql主从数据库的切换          在application-datasource.xml中配置master和

Spring 实现数据库读写分离

[本文转载于 Spring 实现数据库读写分离] 现在大型的电子商务系统,在数据库层面大都采用读写分离技术,就是一个Master数据库,多个Slave数据库.Master库负责数据更新和实时数据查询,Slave库当然负责非实时数据查询.因为在实际的应用中,数据库都是读多写少(读取数据的频率高,更新数据的频率相对较少),而读取数据通常耗时比较长,占用数据库服务器的CPU较多,从而影响用户体验.我们通常的做法就是把查询从主库中抽取出来,采用多个从库,使用负载均衡,减轻每个从库的查询压力. 采用读写分

CYQ.Data V5 数据库读写分离功能介绍

前言 好多年没写关于此框架的新功能的介绍了,这些年一直在默默地更新,从Nuget上的记录就可以看出来: 这几天在看Java的一些东西,除了觉的Java和.NET的相似度实在太高之外,就是Java太原始,急需被拯救. 之后又回到.NET的思维来,想着怎么在框架里实现读写分离控制请求切换. 之前几个月一直都有在思考,想及对框架现有的代码改动可能较大,所以迟迟没怎么下手. 最近终于在厕所蹲下的一瞬间,灵光一闪,感觉思绪来了,然后一鼓作气,就把它给作了. 数据库读写分离的三步曲 1:实现主(读)从(写)

phalapi-进阶篇5(数据库读写分离以及多库使用)

phalapi-进阶篇5(数据库读写分离以及多库使用) 前言 先在这里感谢phalapi框架创始人@dogstar,为我们提供了这样一个优秀的开源框架. 读写分离是我们常用的一种解决方案,它可以解决大量读操作的时候数据库瓶颈的问题,我们在真正开发一个项目的过程中可能会遇一个接口或者一个操作中需要用到多个数据库操作的时候怎么办,今天的教程就从这个两个问题出来,来聊聊使用phalapi怎么解决这个问题. 附上: 官网地址:http://www.phalapi.net/ 开源中国Git地址:http:

thinkphp 3.2分布式数据库读写分离扩展阅读

        thinkphp 3.2分布式数据库读写分离扩展阅读        ThinkPHP内置了分布式数据库的支持,包括主从式数据库的读写分离,但是分布式数据库必须是相同的数据库类型.         配置DB_DEPLOY_TYPE 为1 可以采用分布式数据库支持.如果采用分布式数据库,定义数据库配置信息的方式如下:            //分布式数据库配置定义            'DB_DEPLOY_TYPE'=> 1, // 设置分布式数据库支持            'D

数据库读写分离

随着一 个网站的业务不断扩展,数据不断增加,数据库的压力也会越来越大,对数据库或者SQL的基本优化可能达不到最终的效果,我们可以采用读写分离的策略来改变 现状.读写分离现在被大量应用于很多大型网站,这个技术也不足为奇了.ebay就做得非常好.ebay用的是oracle,听说是用Quest Share Plex 来实现主从复制数据.      读写分离简单的说是把对数据库读和写的操作分开对应不同的数据库服务器,这样能有效地减轻数据库压力,也能减轻io压力.主数据库提供写操作,从数据库提 供读操作,

thinkphp下MySQL数据库读写分离代码剖析

当采用原生态的sql语句进行写入操作的时候,要用execute,读操作要用query. MySQL数据主从同步还是要靠MySQL的机制来实现,所以这个时候MySQL主从同步的延迟问题是需要优化,延迟时间太长不仅影响业务,还影响用户体验. thinkphp核心类Thinkphp/library/Model.class.php 中,query 方法,调用Thinkphp/library/Think/Db/Driver/Mysql.class.php /** * SQL查询 * @access pub

yii2 数据库读写分离配置示例

开始使用数据库首先需要配置数据库连接组件,通过添加 db 组件到应用配置实现("基础的" Web 应用是 config/web.PHP),DSN( Data Source Name )是数据源名称,用于指定数据库信息.如下所示: return [ // ... 'components' => [ // ... 'db' => [ 'class' => 'yii\db\Connection', 'dsn' => 'mysql:host=localhost;dbna

sql server2005实现数据库读写分离介绍_mssql2005

Internet的规模每一百天就会增长一倍,客户希望获得7天×24小时的不间断可用性及较快的系统反应时间,而不愿屡次看到某个站点"Server Too Busy"及频繁的系统故障. 随着业务量的提高,以及访问量和数据流量的快速增长,网络各个核心部分的处理性能和计算强度也相应增大,使得单一设备根本无法承担.在此情况下,如果扔掉现有设备去做大量的硬件升级,必将造成现有资源的浪费,而且下一次业务量的提升,又将导致再一次硬件升级的高额成本投入.于是,负载均衡机制应运而生. 对于负载均衡,笔者经