文档章节

Mysql读写分离的两种实现对比:Spring+JPA应用层实现 vs Amoeba中间件实现

商者
 商者
发布于 2016/01/26 15:41
字数 2442
阅读 261
收藏 0

前段时间看了篇文章,讲Youku网数据库架构的演变,如何从最开始的读写分离,再到垂直分区,最后到水平分片,一步一步慢慢成熟的。看完之后很有冲动抽出一个模型来把这几种技术都实现一下。

     说干就干,首先是读写分离了,我使用的数据库是Mysql,主从数据复制用的是半同步机制(mysql版本必须 5.5以上),具体配置,可以参照这篇文章: http://blog.csdn.net/changerlove/article/details/6167255, 要注意Windows环境下,mysql配置文件为my.ini, linux下才是my.cnf。

     然后主从复制有两类做法,一类就是在应用层去动态切换数据源,最简单的做法就是根据事务类型来做Route,另外一类就是利用所谓的“中间件”,在应用层和数据源之间通过分析SQL来Route,目前可选的“中间件有Mysql自带的Mysql Proxy还有阿里开发的Amoeba,后者据说比Mysql Proxy更稳定,使用也更简单,所以“中间件”做法里我选了第二种来尝试,待会儿会分析Amoeba的优劣,这儿先讲第一种做法,在应用层实现读写分离。

     在例子中有两台Mysql Server,一台Master 负责写,一台Slave负责读,对应的JPA 配置文件如下:

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  

  2. <persistence version="2.0"  

  3.     xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">  

  5.     <!-- used to test R/W Splitting in MYSQL, can be routed by transaction   

  6.         type(read only or not) -->  

  7.     <persistence-unit name="MASTER_000" transaction-type="RESOURCE_LOCAL">  

  8.         <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>  

  9.         <exclude-unlisted-classes>false</exclude-unlisted-classes>  

  10.         <properties>  

  11.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />  

  12.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/rws_db" />  

  13.             <property name="javax.persistence.jdbc.user" value="root" />  

  14.             <property name="javax.persistence.jdbc.password" value="" />  

  15.             <property name="eclipselink.jdbc.read-connections.min"value="1" />  

  16.             <property name="eclipselink.jdbc.write-connections.min"value="1" />  

  17.             <property name="eclipselink.jdbc.batch-writing" value="JDBC" />  

  18.             <property name="eclipselink.logging.level" value="FINE" />  

  19.             <property name="eclipselink.logging.thread" value="false" />  

  20.             <property name="eclipselink.logging.session" value="false" />  

  21.             <property name="eclipselink.logging.exceptions" value="false" />  

  22.             <property name="eclipselink.logging.timestamp" value="false" />  

  23.         </properties>  

  24.     </persistence-unit>  

  25.   

  26.     <persistence-unit name="SLAVE_000" transaction-type="RESOURCE_LOCAL">  

  27.         <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>  

  28.         <exclude-unlisted-classes>false</exclude-unlisted-classes>  

  29.         <properties>  

  30.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />  

  31.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://146.222.51.163:3306/rws_db" />  

  32.             <property name="javax.persistence.jdbc.user" value="zhuga3" />  

  33.             <property name="javax.persistence.jdbc.password" value="Gmail123" />  

  34.             <property name="eclipselink.jdbc.read-connections.min"value="1" />  

  35.             <property name="eclipselink.jdbc.write-connections.min"value="1" />  

  36.             <property name="eclipselink.jdbc.batch-writing" value="JDBC" />  

  37.             <property name="eclipselink.logging.level" value="FINE" />  

  38.             <property name="eclipselink.logging.thread" value="false" />  

  39.             <property name="eclipselink.logging.session" value="false" />  

  40.             <property name="eclipselink.logging.exceptions" value="false" />  

  41.             <property name="eclipselink.logging.timestamp" value="false" />  

  42.         </properties>  

  43.     </persistence-unit>  

  44.   

  45. </persistence>  


然后系统的事务控制,这个是关键,因为在事务初始化的时候要根据事务属性(R/W)来初始化对应的EntityManager,并开启事务,简单起见,例子里使用JPA的Entity Transaction,而不是JTA。

实现第一步,我们得自定义transactionManager来控制事务的开关,回滚以及资源的初始化等等,直接看代码吧:

[java] view plain copy

  1. package util.transaction;  

  2.   

  3. import javax.persistence.EntityManager;  

  4. import javax.persistence.EntityTransaction;  

  5.   

  6. import org.springframework.transaction.TransactionDefinition;  

  7. import org.springframework.transaction.TransactionException;  

  8. import org.springframework.transaction.support.AbstractPlatformTransactionManager;  

  9. import org.springframework.transaction.support.DefaultTransactionStatus;  

  10.   

  11. public class RWSTransactionManager extends AbstractPlatformTransactionManager {  

  12.   

  13.     private static final long serialVersionUID = -1369860968344021154L;  

  14.   

  15.     @Override  

  16.     protected Object doGetTransaction() throws TransactionException {  

  17.         RWSJPATransactionObject rwsTransaction = new RWSJPATransactionObject();  

  18.         EntityManager entityManager = EntityManagerHolder.getInstance()  

  19.                 .initializeResource(definition.isReadOnly());  

  20.         EntityTransaction transaction = entityManager.getTransaction();  

  21.         rwsTransaction.setTransaction(transaction);  

  22.   

  23.         return rwsTransaction;  

  24.     }  

  25.   

  26.     @Override  

  27.     protected void doBegin(Object txObject, TransactionDefinition definition)  

  28.             throws TransactionException {  

  29.         RWSJPATransactionObject rwsTransaction = (RWSJPATransactionObject) txObject;  

  30.           

  31.         if (!definition.isReadOnly()) {  

  32.             rwsTransaction.getTransaction().begin();  

  33.         }  

  34.     }  

  35.   

  36.     @Override  

  37.     protected void doCommit(DefaultTransactionStatus transactionStatus)  

  38.             throws TransactionException {  

  39.         if (transactionStatus.isReadOnly()) {  

  40.             return;  

  41.         }  

  42.   

  43.         RWSJPATransactionObject rwsTransaction = (RWSJPATransactionObject) transactionStatus  

  44.                 .getTransaction();  

  45.         rwsTransaction.getTransaction().commit();  

  46.     }  

  47.   

  48.     @Override  

  49.     protected void doRollback(DefaultTransactionStatus transactionStatus)  

  50.             throws TransactionException {  

  51.         if (transactionStatus.isReadOnly()) {  

  52.             return;  

  53.         }  

  54.   

  55.         RWSJPATransactionObject rwsTransaction = (RWSJPATransactionObject) transactionStatus  

  56.                 .getTransaction();  

  57.         rwsTransaction.getTransaction().rollback();  

  58.     }  

  59.   

  60.     private class RWSJPATransactionObject {  

  61.         private EntityTransaction transaction;  

  62.   

  63.         public EntityTransaction getTransaction() {  

  64.             return transaction;  

  65.         }  

  66.   

  67.         public void setTransaction(EntityTransaction transaction) {  

  68.             this.transaction = transaction;  

  69.         }  

  70.   

  71.         public RWSJPATransactionObject() {  

  72.             super();  

  73.         }  

  74.     }  

  75.   

  76. }  




对应的 EntityManagerHolder 代码如下:

[java] view plain copy

  1. package util.transaction;  

  2.   

  3. import java.util.HashMap;  

  4. import java.util.Map;  

  5. import java.util.Random;  

  6. import javax.persistence.EntityManager;  

  7. import javax.persistence.EntityManagerFactory;  

  8. import javax.persistence.Persistence;  

  9.   

  10. import org.apache.commons.lang.StringUtils;  

  11.   

  12. public class EntityManagerHolder {  

  13.   

  14.     private Random random = new Random();  

  15.     private String PERSISTENCE_UNIT_HEADER_MASTER = "MASTER_";  

  16.     private String PERSISTENCE_UNIT_HEADER_SLAVE = "SLAVE_";  

  17.     private final ThreadLocal<EntityManager> THREAD_LOCAL = new ThreadLocal<EntityManager>();  

  18.     private final Map<String, EntityManagerFactory> RESOURCE = new HashMap<String, EntityManagerFactory>();  

  19.   

  20.     private static EntityManagerHolder emHolder;  

  21.   

  22.     private EntityManagerHolder() {  

  23.     }  

  24.     public static EntityManagerHolder getInstance() {  

  25.         if (null == emHolder) {  

  26.             emHolder = new EntityManagerHolder();  

  27.         }  

  28.         return emHolder;  

  29.     }  

  30.     EntityManager initializeResource(boolean isReadOnly) {  

  31.         // get random persistence unit, dependents on master and slave  

  32.         // quantities  

  33.         // configured in persistence.xml  

  34.         String puSuffix = "";  

  35.         if (isReadOnly) {  

  36.             puSuffix = StringUtils.leftPad(String.valueOf(random.nextInt(1)),  

  37.                     3"0");  

  38.         } else {  

  39.             puSuffix = StringUtils.leftPad(String.valueOf(random.nextInt(1)),  

  40.                     3"0");  

  41.         }  

  42.   

  43.         String persistenceUnit = (isReadOnly ? PERSISTENCE_UNIT_HEADER_SLAVE  

  44.                 : PERSISTENCE_UNIT_HEADER_MASTER) + puSuffix;  

  45.   

  46.         return createEntityManager(persistenceUnit);  

  47.     }  

  48.   

  49.     private EntityManager createEntityManager(String persistenceUnit) {  

  50.         if (null == RESOURCE.get(persistenceUnit)) {  

  51.             EntityManagerFactory entityManagerFactory = Persistence  

  52.                     .createEntityManagerFactory(persistenceUnit);  

  53.             RESOURCE.put(persistenceUnit, entityManagerFactory);  

  54.         }  

  55.         EntityManager entityManager = THREAD_LOCAL.get();  

  56.         if (null == entityManager || !entityManager.isOpen()) {  

  57.             entityManager = RESOURCE.get(persistenceUnit).createEntityManager();  

  58.             THREAD_LOCAL.set(entityManager);  

  59.         }  

  60.         return entityManager;  

  61.     }  

  62.   

  63.     public EntityManager getEntityManager() {  

  64.         EntityManager entityManager = THREAD_LOCAL.get();  

  65.         if (null == entityManager) {  

  66.             throw new IllegalArgumentException();  

  67.         }  

  68.         return entityManager;  

  69.     }  

  70.   

  71.     public void closeEntityManager() {  

  72.         EntityManager entityManager = THREAD_LOCAL.get();  

  73.         THREAD_LOCAL.set(null);  

  74.         if (null != entityManager)  

  75.             entityManager.close();  

  76.     }  

  77.   

  78. }  


可以看到,在getTransaction方法里我们简单new了一个自定义的Object,其实就是一个EntityTransaction holder,关键是在begin(..)方法里,首先会根据事务属性到EntityManagerHolder中进行资源初始化(主要是EMFactory和EM),在initializeResource 方法里面,简单的写了种路由算法,就是Java随机数,生成对应PersistenceUnit Name的后缀,最后根据这个name去生成对应的EMFactory和EM,并且set到Threadlocal的变量中去,之后在Dao层可以直接通过getEntityManager 方法来获取EntityManager.初始化结束之后,对应的事务直接使用EM里面的EntityTransaction来begin,commit和rollback。


事务管理器写好了,我们先看一下相关的Spring配置:

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  

  2. <beans xmlns="http://www.springframework.org/schema/beans"  

  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

  4.     xmlns:context="http://www.springframework.org/schema/context"   

  5.     xmlns:tx="http://www.springframework.org/schema/tx"  

  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans  

  7.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  

  8.     http://www.springframework.org/schema/context   

  9.     http://www.springframework.org/schema/context/spring-context-2.5.xsd  

  10.     http://www.springframework.org/schema/tx  

  11.     http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  

  12.         <context:annotation-config />  

  13.     <context:component-scan base-package="*" />  

  14.     <bean id="transactionManager" class="util.transaction.RWSTransactionManager"/>  

  15.     <tx:annotation-driven transaction-manager="transactionManager"/>    

  16. </beans>  


最后需要在service上加上事务注解, 指明事务属性:

[java] view plain copy

  1. @Override  

  2. @Transactional(readOnly = false)  

  3. public void add(T object) {  

  4.     getDao().push(object);  

  5. }  

  6.   

  7. @Override  

  8. @Transactional(readOnly = true)  

  9. public List<T> findByExample(T object) {  

  10.     return getDao().findByExample(object);  

  11. }  

测试类:

[java] view plain copy

  1. package test;  

  2.   

  3. import service.EmployeeService;  

  4. import test.mainTest.BaseMainTest;  

  5. import domain.Employee;  

  6.   

  7. public class TestRWS extends BaseMainTest {  

  8.     public static void main(String[] args) {  

  9.         EmployeeService employeeService = (EmployeeService) ctx  

  10.                 .getBean("employeeService");  

  11.         Employee employee = new Employee();  

  12.         employee.setFirstName("Yinkan");  

  13.         employee.setLastName("Zhu");  

  14.   

  15.         employeeService.add(employee);  

  16. //      employeeService.findByExample(employee);  

  17.     }  

  18. }  


当调用EmployeeService里面的Add方法时(事务属性为写事务),从Log里可以看到成功连接到Master Server,并且插入成功,从库里也同步过去了。




当调用EmployeeService里面的FindByExample方法的时候(事务属性为读事务),从Log里可以看到是从Slave Server读取数据:




到这里第一种方法,在应用层来实现读写分离已经结束了,可以看到,通过事务属性来进行数据源切换这种做法比较简单,但是从软件设计的角度来看,事务控制里面耦合了数据源切换的逻辑,下面一种做法,使用Amoeba直接在SQL level做Route,代码的耦合度大大降低,但是也带来了其他问题。

      Amoeba的配置,请参照官方文档: http://docs.hexnova.com/amoeba/

      Amoeba的原理如下图所示,就是一层代理,对APP来说可见的只有一个DataSource,具体的Masters和Slaves可以在Amoeba里配置。


          

 对应应用层JPA的配置如下:

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  

  2. <persistence version="2.0"  

  3. xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

  4. xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">  

  5.   

  6. <persistence-unit name="proxyPU" transaction-type="RESOURCE_LOCAL">  

  7.      <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>  

  8.      <exclude-unlisted-classes>false</exclude-unlisted-classes>  

  9.      <properties>  

  10.          <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />  

  11.          <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:8066/rws_db" />  

  12.          <property name="javax.persistence.jdbc.user" value="amoebaUser" />           

  13.          <property name="javax.persistence.jdbc.password" value="123" />   

  14.          <property name="eclipselink.jdbc.read-connections.min"value="1" />   

  15.          <property name="eclipselink.jdbc.write-connections.min"value="1" />    

  16.          <property name="eclipselink.jdbc.batch-writing" value="JDBC" />       

  17.          <property name="eclipselink.logging.level" value="FINE" />          

  18.          <property name="eclipselink.logging.thread" value="false" />         

  19.          <property name="eclipselink.logging.session" value="false" />          

  20.          <property name="eclipselink.logging.exceptions" value="false" />       

  21.          <property name="eclipselink.logging.timestamp" value="false" />     

  22.       </properties>      

  23. </persistence-unit>  

  24. </persistence>              


该PersistenceUnit里面用到的Mysql相关信息,配置在Amoeba的amobe.xml文件里,是一个对外的proxy:

[html] view plain copy

  1. <!-- service class must implements com.meidusa.amoeba.service.Service -->  

  2.     <service name="Amoeba for Mysql" class="com.meidusa.amoeba.net.ServerableConnectionManager">  

  3.         <!-- port -->  

  4.         <property name="port">8066</property>             

  5.         <!-- bind ipAddress -->  

  6.         <!--  

  7.         <property name="ipAddress">127.0.0.1</property> 

  8.          -->       

  9.         <property name="manager">${clientConnectioneManager}</property>  

  10.         <property name="connectionFactory">  

  11.             <bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">  

  12.                 <property name="sendBufferSize">128</property>  

  13.                 <property name="receiveBufferSize">64</property>  

  14.             </bean>  

  15.         </property>  

  16.         <property name="authenticator">  

  17.             <bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">     

  18.                 <property name="user">amoebaUser</property>       

  19.                 <property name="password">123</property>      

  20.                 <property name="filter">  

  21.                     <bean class="com.meidusa.amoeba.server.IPAccessController">  

  22.                         <property name="ipFile">${amoeba.home}/conf/access_list.conf</property>  

  23.                     </bean>  

  24.                 </property>  

  25.             </bean>  

  26.         </property>  

  27.     </service>  

  28.       

     然后是事务,事务的话可以直接使用Spring自带的JpaTransactionManager来管理,Entitymanager可以在Service层用annotation来注入,具体代码我就不贴了,一切准备好之后先启动Amoeba,我们来跑一下test, 首先是读,发现log如下:




可以看到Database version: 。。mysql-amoeba-proxy。。 说明连接正确,在看结果读数据也的正常的。

接下来就是测试写数据: 跑了一下,报错了:

Internal Exception: java.sql.SQLException: ResultSet is from UPDATE. No Data.
Error Code: 0
Call: SELECT LAST_INSERT_ID()


Check一下生成的SQL,发现insert之后跑了句SELECT LAST_INSERT_ID(), 因为我程序里Entity的主键是Mysql的自增主键,每次插入都会生成这句话用来返回当前ID,而这个ID是跟着Connection走的,也就是说如果该connection里面没有更新,就拿不到值,可是我们的insert和这句select难道不在一个Connection里面?对的,忘了我们用的是“SQL路由器”吗?insert语句开启主库connection,select则走的是从库的connection,所以查询当然是空了,而天真的eclipselink查出resultSet之后直接.next()了,也没判断是否有值,于是就出现这个error code了,当然对于eclipselink,这种check只能说是nice to have的,正常情况下是不会出现这种情况的,connection在获取数据源的时候就已经有了,这里因为我们拿到的其实是个代理。

考虑到Amoeba的实现原理,即"SQL路由",即使Mysql支持Oracle一样的主键生成策略,在这种情况下似乎也不能正常工作。所以得由应用层来生成主键,这又是Effort。。。

另外从Amoeba的文档里看到,他的另一个缺点是目前不支持事务,这个我的理解是跨connection的事务做不到原子性,特别是当规则配置多主情况下,事务无效。

这么看来Amoeba的使用场景确实有限,首先domain层最好不要使用JPA之类的ORM框架,纯JDBC开发更可靠;然后在数据库架构上,一主多从尽量原子化事务。

综合对比一下,应用层实现读写分离比较靠谱。


本文转载自:http://blog.csdn.net/gaarazhu/article/details/8470431

商者

商者

粉丝 42
博文 142
码字总数 43255
作品 0
海淀
架构师
私信 提问
Mysql主从复制和读写分离方案分析

引子 最近在研究Web服务端负载均衡方面的技术,参考网上资料,总体思路可以分为如下几类: 1.应用服务器集群,典型的代表就是Nginx+Tomcat实现负载均衡; 2.数据库集群。 本文主要关注数据库...

蓝狐乐队
2015/03/24
0
1
amoeba数据库中间件透明实现MYSQL读写分离

Amoeba(变形虫)项目,该开源框架于2008年 开始发布一款 Amoeba for Mysql软件。这个软件致力于MySQL的分布式数据库前端代理层,它主要在应用层访问MySQL的 时候充当SQL路由功能,专注于分布式...

我想去看一看大海
2016/07/03
94
0
mysql读写分离方案比较

最近有个springmvc+ibatis项目需要做mysql读写分离,目前查询到以下几个方案 1.应用层. 通过spring管理datasource的route,由aop或程序控制读写数据源. 2.中间件. 中间件维护主从数据关系,对应...

Sean_Liu
2014/07/15
15.2K
3
MySQL5.6主从复制及读写分离的实现

MySQL5.6主从复制及读写分离的实现 MySQL 5.6 基于GTID的主从复制及使用amoeba配置实现读写分离 一、amoeba 简介 Amoeba(变形虫)项目,该开源框架于2008年开始发布一款 Amoeba forMysql软件。...

bdstravel
2015/01/27
0
0
MySQL的主从复制与读写分离技术实例(二)读写分离

系统版本:CentOS 6.5 MySQL版本:mysql-5.5.38 Amoeba版本:amoeba-mysql-binary-2.2.0 JDK版本:jdk-6u14-linux-x64.bin 案例拓扑图: 案例环境: 搭建MySQL的读写分离 一、搭建MySQL读写分...

睿睿学IT
2016/02/29
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Android双向绑定原理简述

Android双向绑定原理简述 双向绑定涉及两个部分,即将业务状态的变化传递给UI,以及将用户输入信息传递给业务模型。 首先我们来看业务状态是如何传递给UI的。开启dataBinding后,编译器为布局...

tommwq
今天
4
0
Spring系列教程八: Spring实现事务的两种方式

一、 Spring事务概念: 事务是一系列的动作,它们综合在一起才是一个完整的工作单元,这些动作必须全部完成,如果有一个失败的话,那么事务就会回滚到最开始的状态,仿佛什么都没发生过一样。...

我叫小糖主
今天
9
0
CentOS 的基本使用

1. 使用 sudo 命令, 可以以 root 身份执行命令, 必须要在 /etc/sudoers 中定义普通用户 2. 设置 阿里云 yum 镜像, 参考 https://opsx.alibaba.com/mirror # 备份mv /etc/yum.repos.d/CentO...

北漂的我
昨天
5
0
Proxmox VE技巧 移除PVE “没有有效订阅” 的弹窗提示

登陆的时候提示没有有效的订阅You do not have a valid subscription for this server. Please visit www.proxmox.com to get a list of available options. 用的是免费版的,所以每次都提示......

以谁为师
昨天
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部