在应用层通过spring解决数据库读写分离
- - CSDN博客推荐文章如何配置mysql数据库的主从. 单机配置mysql主从： http://my.oschina.net/god/blog/496. 常见的解决数据库读写分离有两种方案. http://neoremind.net/2011/06/spring实现数据库读写分离. 目前的一些解决方案需要在程序中手动指定数据源，比较麻烦，后边我会通过AOP思想来解决这个问题.
在应用层通过spring解决数据库读写分离
标签：
应用层
spring
数据库
| 发表时间：2012-11-08 21:01 | 作者：jinnianshilongnian
出处：http://blog.csdn.net
如何配置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：当只有读操作的时候，直接操作读库（从库）；
当在写事务（即写主库）中读时，也是读主库（即参与到主库操作），这样的优势是可以防止写完后可能读不到刚才写的数据；
此方案其实是使用事务传播行为为：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、写库配置
<bean id="writeDataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource"> <property name="alias" value="writeDataSource"/> <property name="driver" value="${write.connection.driver_class}" /> <property name="driverUrl" value="${write.connection.url}" /> <property name="user" value="${write.connection.username}" /> <property name="password" value="${write.connection.password}" /> <property name="maximumConnectionCount" value="${write.proxool.maximum.connection.count}"/> <property name="minimumConnectionCount" value="${write.proxool.minimum.connection.count}" /> <property name="statistics" value="${write.proxool.statistics}" /> <property name="simultaneousBuildThrottle" value="${write.proxool.simultaneous.build.throttle}"/> </bean>
1.2、读库配置
<bean id="readDataSource1" class="org.logicalcobwebs.proxool.ProxoolDataSource"> <property name="alias" value="readDataSource"/> <property name="driver" value="${read.connection.driver_class}" /> <property name="driverUrl" value="${read.connection.url}" /> <property name="user" value="${read.connection.username}" /> <property name="password" value="${read.connection.password}" /> <property name="maximumConnectionCount" value="${read.proxool.maximum.connection.count}"/> <property name="minimumConnectionCount" value="${read.proxool.minimum.connection.count}" /> <property name="statistics" value="${read.proxool.statistics}" /> <property name="simultaneousBuildThrottle" value="${read.proxool.simultaneous.build.throttle}"/> </bean>
1.3、读写动态库配置
通过writeDataSource指定写库，通过readDataSourceMap指定从库列表，从库列表默认通过顺序轮询来使用读库，具体参考javadoc；
<bean id="readWriteDataSource" class="cn.javass.common.datasource.ReadWriteDataSource"> <property name="writeDataSource" ref="writeDataSource"/> <property name="readDataSourceMap"> <map> <entry key="readDataSource1" value-ref="readDataSource1"/> <entry key="readDataSource2" value-ref="readDataSource1"/> <entry key="readDataSource3" value-ref="readDataSource1"/> <entry key="readDataSource4" value-ref="readDataSource1"/> </map> </property> </bean>
2、XML事务属性配置
所以读方法必须是read-only（必须，以此来判断是否是读方法）。
<tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="save*" propagation="REQUIRED" /> <tx:method name="add*" propagation="REQUIRED" /> <tx:method name="create*" propagation="REQUIRED" /> <tx:method name="insert*" propagation="REQUIRED" /> <tx:method name="update*" propagation="REQUIRED" /> <tx:method name="merge*" propagation="REQUIRED" /> <tx:method name="del*" propagation="REQUIRED" /> <tx:method name="remove*" propagation="REQUIRED" /> <tx:method name="put*" read-only="true"/> <tx:method name="query*" read-only="true"/> <tx:method name="use*" read-only="true"/> <tx:method name="get*" read-only="true" /> <tx:method name="count*" read-only="true" /> <tx:method name="find*" read-only="true" /> <tx:method name="list*" read-only="true" /> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice>
3、事务管理器
事务管理器管理的是readWriteDataSource
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="readWriteDataSource"/> </bean>
4、读/写动态数据库选择处理器
根据之前的txAdvice配置的事务属性决定是读/写，具体参考javadoc；
forceChoiceReadWhenWrite：用于确定在如果目前是写（即开启了事务），下一步如果是读，是直接参与到写库进行读，还是强制从读库读，具体参考javadoc；
<bean id="readWriteDataSourceTransactionProcessor" class="cn.javass.common.datasource.ReadWriteDataSourceProcessor"> <property name="forceChoiceReadWhenWrite" value="false"/> </bean>
5、事务切面和读/写库选择切面
<aop:config expose-proxy="true"> <!-- 只对业务逻辑层实施事务 --> <aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" /> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/> <!-- 通过AOP切面实现读/写库选择 --> <aop:aspect order="-2147483648" ref="readWriteDataSourceTransactionProcessor"> <aop:around pointcut-ref="txPointcut" method="determineReadOrWriteDB"/> </aop:aspect> </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：欢迎拍砖指正。
支持一下博主：------------------------------------------
http://blog.51cto.com/contest2012/2058573
--------------------------------------------------------------
如何配置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：当只有读操作的时候，直接操作读库（从库）；
当在写事务（即写主库）中读时，也是读主库（即参与到主库操作），这样的优势是可以防止写完后可能读不到刚才写的数据；
此方案其实是使用事务传播行为为：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、写库配置
<bean id="writeDataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">
<property name="alias" value="writeDataSource"/>
<property name="driver" value="${write.connection.driver_class}" />
<property name="driverUrl" value="${write.connection.url}" />
<property name="user" value="${write.connection.username}" />
<property name="password" value="${write.connection.password}" />
<property name="maximumConnectionCount" value="${write.proxool.maximum.connection.count}"/>
<property name="minimumConnectionCount" value="${write.proxool.minimum.connection.count}" />
<property name="statistics" value="${write.proxool.statistics}" />
<property name="simultaneousBuildThrottle" value="${write.proxool.simultaneous.build.throttle}"/>
</bean>
1.2、读库配置
<bean id="readDataSource1" class="org.logicalcobwebs.proxool.ProxoolDataSource">
<property name="alias" value="readDataSource"/>
<property name="driver" value="${read.connection.driver_class}" />
<property name="driverUrl" value="${read.connection.url}" />
<property name="user" value="${read.connection.username}" />
<property name="password" value="${read.connection.password}" />
<property name="maximumConnectionCount" value="${read.proxool.maximum.connection.count}"/>
<property name="minimumConnectionCount" value="${read.proxool.minimum.connection.count}" />
<property name="statistics" value="${read.proxool.statistics}" />
<property name="simultaneousBuildThrottle" value="${read.proxool.simultaneous.build.throttle}"/>
</bean>
1.3、读写动态库配置
通过writeDataSource指定写库，通过readDataSourceMap指定从库列表，从库列表默认通过顺序轮询来使用读库，具体参考javadoc；
<bean id="readWriteDataSource" class="cn.javass.common.datasource.ReadWriteDataSource">
<property name="writeDataSource" ref="writeDataSource"/>
<property name="readDataSourceMap">
<map>
<entry key="readDataSource1" value-ref="readDataSource1"/>
<entry key="readDataSource2" value-ref="readDataSource1"/>
<entry key="readDataSource3" value-ref="readDataSource1"/>
<entry key="readDataSource4" value-ref="readDataSource1"/>
</map>
</property>
</bean>
2、XML事务属性配置
所以读方法必须是read-only（必须，以此来判断是否是读方法）。
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="create*" propagation="REQUIRED" />
<tx:method name="insert*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="merge*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="put*" read-only="true"/>
<tx:method name="query*" read-only="true"/>
<tx:method name="use*" read-only="true"/>
<tx:method name="get*" read-only="true" />
<tx:method name="count*" read-only="true" />
<tx:method name="find*" read-only="true" />
<tx:method name="list*" read-only="true" />
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
3、事务管理器
事务管理器管理的是readWriteDataSource
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="readWriteDataSource"/>
</bean>
4、读/写动态数据库选择处理器
根据之前的txAdvice配置的事务属性决定是读/写，具体参考javadoc；
forceChoiceReadWhenWrite：用于确定在如果目前是写（即开启了事务），下一步如果是读，是直接参与到写库进行读，还是强制从读库读，具体参考javadoc；
<bean id="readWriteDataSourceTransactionProcessor" class="cn.javass.common.datasource.ReadWriteDataSourceProcessor">
<property name="forceChoiceReadWhenWrite" value="false"/>
</bean>
5、事务切面和读/写库选择切面
<aop:config expose-proxy="true">
<!-- 只对业务逻辑层实施事务 -->
<aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
<!-- 通过AOP切面实现读/写库选择 -->
<aop:aspect order="-2147483648" ref="readWriteDataSourceTransactionProcessor">
<aop:around pointcut-ref="txPointcut" method="determineReadOrWriteDB"/>
</aop:aspect>
</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：欢迎拍砖指正。
支持一下博主：------------------------------------------
http://blog.51cto.com/contest2012/2058573
--------------------------------------------------------------
作者：jinnianshilongnian 发表于2012-11-8 21:01:33 原文链接
阅读：0 评论：0 查看评论
相关 [应用层 spring 数据库] 推荐：
Spring+MyBatis实践——MyBatis访问数据库
- - 开源软件 - ITeye博客 在http://dufengx201406163237.iteye.com/blog/2102054中描述了工程的配置，在此记录一下如何使用MyBatis访问数据库；. . .
spring实现数据库读写分离
- - 行业应用 - ITeye博客现在大型的电子商务系统，在数据库层面大都采用读写分离技术，就是一个Master数据库，多个Slave数据库. Master库负责数据更新和 实时数据查询，Slave库当然负责非实时数据查询. 因为在实际的应用中，数据库都是读多写少（读取数据的频率高，更新数据的频率相对较少），而读取数据 通常耗时比较长，占用数据库服务器的CPU较多，从而影响用户体验.
Spring AOP + Redis缓存数据库查询
- - 编程语言 - ITeye博客我们希望能够将数据库查询结果缓存到Redis中，这样在第二次做同样的查询时便可以直接从redis取结果，从而减少数据库读写次数. 必须要做到与业务逻辑代码完全分离. 从缓存中读出的数据必须与数据库中的数据一致. 如何为一个数据库查询结果生成一个唯一的标识. Key)，能唯一确定一个查询结果，同一个查询结果，一定能映射到同一个.
Spring 配置多数据源实现数据库读写分离
- - 企业架构 - ITeye博客现在大型的电子商务系统，在数据库层面大都采用读写分离技术，就是一个Master数据库，多个Slave数据库. Master库负责数据更新和实时数据查询，Slave库当然负责非实时数据查询. 因为在实际的应用中，数据库都是读多写少（读取数据的频率高，更新数据的频率相对较少），而读取数据通常耗时比较长，占用数据库服务器的CPU较多，从而影响用户体验.
Spring + JPA实现数据库读写分离
- - 深入一点,你会更加快乐 本文展示了如何在Spring环境中使用JPA实现dataSource的读写分离（本文没有使用JTA事务），这个东西看起来简单，其实实现起来比较蹩脚，与JDBC有很大区别. 1）使用Spring中的AbstractRoutingDataSource，辅助程序在运行时选择合适的dataSource.
Spring主从数据库的配置和动态数据源切换原理
- - 廖雪峰的官方网站在大型应用程序中，配置主从数据库并使用读写分离是常见的设计模式. 在Spring应用程序中，要实现读写分离，最好不要对现有代码进行改动，而是在底层透明地支持. Spring内置了一个 AbstractRoutingDataSource，它可以把多个数据源配置成一个Map，然后，根据不同的key返回不同的数据源.
Spring Boot 2 实战：使用 Flyway 管理你数据库的版本变更 - SegmentFault 思否
- -随着项目的不断迭代，数据库表结构、数据都在发生着变化. 甚至有的业务在多环境版本并行运行. 数据为王的时代，管理好数据库的版本也成为了迫切的需要. Git之类的版本控制工具来管理数据库. Liquibase来管理数据库版本. Flyway相对来说比较受欢迎. Flyway大受欢迎是因为它具有以下优点：.
Spring详解
- - CSDN博客架构设计推荐文章Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目的是简化企业开发.. PersonDaoBean
是在应用内部创建及维护的. 所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的.
Spring定时
- - 行业应用 - ITeye博客spring的定时任务配置分为三个步骤：. . . . . .