2. 程式人生 > >Mysql讀寫分離的兩種方法對比：Spring+JPA應用層實現 vs Amoeba中介軟體實現

Mysql讀寫分離的兩種方法對比：Spring+JPA應用層實現 vs Amoeba中介軟體實現

阿新 • • 發佈：2019-02-18

前段時間看了篇文章，講Youku網資料庫架構的演變，如何從最開始的讀寫分離，再到垂直分割槽，最後到水平分片，一步一步慢慢成熟的。看完之後很有衝動抽出一個模型來把這幾種技術都實現一下。

     說幹就幹，首先是讀寫分離了，我使用的資料庫是Mysql，主從資料複製用的是半同步機制(mysql版本必須 5.5以上)，具體配置，可以參照這篇文章： http://blog.csdn.net/changerlove/article/details/6167255， 要注意Windows環境下，mysql配置檔案為my.ini, linux下才是my.cnf。

主從複製有兩類做法，

1.手動：根據事物型別，來route,應用層動態切換資料來源

2.自動：利用中介軟體自動完成（比如amoeba）在應用層和資料來源之間通過分析SQL來Route

---------------------------------------------------------------------------------- 下面說方法1：

     在例子中有兩臺Mysql Server，一臺Master 負責寫，一臺Slave負責讀，對應的JPA 配置檔案如下：

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
	xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

	<!-- used to test R/W Splitting in MYSQL, can be routed by transaction 
		type(read only or not) -->
	<persistence-unit name="MASTER_000" transaction-type="RESOURCE_LOCAL">
		<provider>
            org.eclipse.persistence.jpa.PersistenceProvider
        </provider>
		<exclude-unlisted-classes>false</exclude-unlisted-classes>
		<properties>
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/rws_db" />
			<property name="javax.persistence.jdbc.user" value="root" />
			<property name="javax.persistence.jdbc.password" value="" />
			<!-- Minimal connections in internal pool -->
			<property name="eclipselink.jdbc.read-connections.min"
				value="1" />
			<property name="eclipselink.jdbc.write-connections.min"
				value="1" />
			<property name="eclipselink.jdbc.batch-writing" value="JDBC" />
			<property name="eclipselink.logging.level" value="FINE" />
			<property name="eclipselink.logging.thread" value="false" />
			<property name="eclipselink.logging.session" value="false" />
			<property name="eclipselink.logging.exceptions" value="false" />
			<property name="eclipselink.logging.timestamp" value="false" />
		</properties>
	</persistence-unit>

	<persistence-unit name="SLAVE_000" transaction-type="RESOURCE_LOCAL">
		<provider>
            org.eclipse.persistence.jpa.PersistenceProvider
        </provider>
		<exclude-unlisted-classes>false</exclude-unlisted-classes>
		<properties>
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://146.222.51.163:3306/rws_db" />
			<property name="javax.persistence.jdbc.user" value="zhuga3" />
			<property name="javax.persistence.jdbc.password" value="Gmail123" />
			<!-- Minimal connections in internal pool -->
			<property name="eclipselink.jdbc.read-connections.min"
				value="1" />
			<property name="eclipselink.jdbc.write-connections.min"
				value="1" />
			<property name="eclipselink.jdbc.batch-writing" value="JDBC" />
			<property name="eclipselink.logging.level" value="FINE" />
			<property name="eclipselink.logging.thread" value="false" />
			<property name="eclipselink.logging.session" value="false" />
			<property name="eclipselink.logging.exceptions" value="false" />
			<property name="eclipselink.logging.timestamp" value="false" />
		</properties>
	</persistence-unit>

</persistence>

然後系統的事務控制，這個是關鍵，因為在事務初始化的時候要根據事務屬性(R/W)來初始化對應的EntityManager，並開啟事務，為簡單起見，例子中利用的都是JPA的Entity Transaction，而不是JTA。

實現第一步，我們得自定義transactionManager來控制事務的開關，回滾以及資源的初始化等等，直接看程式碼吧：

package util.transaction;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.support.AbstractPlatformTransactionManager;
import org.springframework.transaction.support.DefaultTransactionStatus;

public class RWSTransactionManager extends 
 
AbstractPlatformTransactionManager {

	private static final long serialVersionUID = -1369860968344021154L;

	@Override
	protected Object doGetTransaction() throws TransactionException {
		return new RWSJPATransactionObject();
	}

	@Override
	protected void doBegin(Object txObject, TransactionDefinition definition)
			throws TransactionException {
		RWSJPATransactionObject rwsTransaction = (RWSJPATransactionObject) txObject;
		EntityManager entityManager = EntityManagerHolder.getInstance()
				.initializeResource(definition.isReadOnly());
		EntityTransaction transaction = entityManager.getTransaction();
		rwsTransaction.setTransaction(transaction);

		if (!definition.isReadOnly()) {
			rwsTransaction.getTransaction().begin();
		}
	}

	@Override
	protected void doCommit(DefaultTransactionStatus transactionStatus)
			throws TransactionException {
		if (transactionStatus.isReadOnly()) {
			return;
		}

		RWSJPATransactionObject rwsTransaction = (RWSJPATransactionObject) transactionStatus
				.getTransaction();
		rwsTransaction.getTransaction().commit();
	}

	@Override
	protected void doRollback(DefaultTransactionStatus transactionStatus)
			throws TransactionException {
		if (transactionStatus.isReadOnly()) {
			return;
		}

		RWSJPATransactionObject rwsTransaction = (RWSJPATransactionObject) transactionStatus
				.getTransaction();
		rwsTransaction.getTransaction().rollback();
	}

	private class RWSJPATransactionObject {
		private EntityTransaction transaction;

		public EntityTransaction getTransaction() {
			return transaction;
		}

		public void setTransaction(EntityTransaction transaction) {
			this.transaction = transaction;
		}

		public RWSJPATransactionObject() {
			super();
		}
	}

}
對應的 EntityManagerHolder 程式碼如下： 
package util.transaction;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.apache.commons.lang.StringUtils;

public class EntityManagerHolder {

	private Random random = new Random();

	private String PERSISTENCE_UNIT_HEADER_MASTER = "MASTER_";

	private String PERSISTENCE_UNIT_HEADER_SLAVE = "SLAVE_";

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

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

	private static EntityManagerHolder emHolder;

	private EntityManagerHolder() {
	}

	public static EntityManagerHolder getInstance() {
		if (null == emHolder) {
			emHolder = new EntityManagerHolder();
		}
		return emHolder;
	}

	EntityManager initializeResource(boolean isReadOnly) {
		// get random persistence unit, dependents on master and slave
		// quantities
		// configured in persistence.xml
		String puSuffix = "";
		if (isReadOnly) {
			puSuffix = StringUtils.leftPad(String.valueOf(random.nextInt(1)),
					3, "0");
		} else {
			puSuffix = StringUtils.leftPad(String.valueOf(random.nextInt(1)),
					3, "0");
		}

		String persistenceUnit = (isReadOnly ? PERSISTENCE_UNIT_HEADER_SLAVE
				: PERSISTENCE_UNIT_HEADER_MASTER) + puSuffix;

		return createEntityManager(persistenceUnit);
	}

	private EntityManager createEntityManager(String persistenceUnit) {
		if (null == RESOURCE.get(persistenceUnit)) {
			EntityManagerFactory entityManagerFactory = Persistence
					.createEntityManagerFactory(persistenceUnit);
			RESOURCE.put(persistenceUnit, entityManagerFactory);
		}

		EntityManager entityManager = THREAD_LOCAL.get();

		if (null == entityManager || !entityManager.isOpen()) {
			entityManager = RESOURCE.get(persistenceUnit).createEntityManager();
			THREAD_LOCAL.set(entityManager);
		}

		return entityManager;
	}

	public EntityManager getEntityManager() {
		EntityManager entityManager = THREAD_LOCAL.get();
		if (null == entityManager) {
			throw new IllegalArgumentException();
		}
		return entityManager;
	}

	public void closeEntityManager() {
		EntityManager entityManager = THREAD_LOCAL.get();
		THREAD_LOCAL.set(null);
		if (null != entityManager)
			entityManager.close();
	}

}

可以看到，在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配置：

<?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:context="http://www.springframework.org/schema/context" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-2.5.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<context:annotation-config />
	<context:component-scan base-package="*" />
	
	<bean id="transactionManager" class="util.transaction.RWSTransactionManager"/>
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
</beans>

最後需要在service上配置事務：

	@Override
	@Transactional(readOnly = false)
	public void add(T object) {
		getDao().push(object);
	}

	@Override
	@Transactional(readOnly = true)
	public List<T> findByExample(T object) {
		return getDao().findByExample(object);
	}

測試類：

package test;

import service.EmployeeService;
import test.mainTest.BaseMainTest;
import domain.Employee;

public class TestRWS extends BaseMainTest {
	public static void main(String[] args) {
		EmployeeService employeeService = (EmployeeService) ctx
				.getBean("employeeService");
		Employee employee = new Employee();
		employee.setFirstName("Yinkan");
		employee.setLastName("Zhu");

		employeeService.add(employee);
//		employeeService.findByExample(employee);
	}
}

當呼叫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的配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

<persistence-unit name="proxyPU" transaction-type="RESOURCE_LOCAL">
<provider>
            org.eclipse.persistence.jpa.PersistenceProvider
        </provider>
<exclude-unlisted-classes>false</exclude-unlisted-classes>
<properties>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:8066/rws_db" />
<property name="javax.persistence.jdbc.user" value="amoebaUser" />
<property name="javax.persistence.jdbc.password" value="123" />
<!-- Minimal connections in internal pool -->
<property name="eclipselink.jdbc.read-connections.min"
value="1" />
<property name="eclipselink.jdbc.write-connections.min"
value="1" />
<property name="eclipselink.jdbc.batch-writing" value="JDBC" />
<property name="eclipselink.logging.level" value="FINE" />
<property name="eclipselink.logging.thread" value="false" />
<property name="eclipselink.logging.session" value="false" />
<property name="eclipselink.logging.exceptions" value="false" />
<property name="eclipselink.logging.timestamp" value="false" />
</properties>
</persistence-unit>
</persistence>


該PersistenceUnit裡面用到的Mysql相關資訊，配置在Amoeba的amobe.xml檔案裡，是一個對外的proxy：

	<!-- service class must implements com.meidusa.amoeba.service.Service -->
		<service name="Amoeba for Mysql" class="com.meidusa.amoeba.net.ServerableConnectionManager">
			<!-- port -->
			<property name="port">8066</property>
			
			<!-- bind ipAddress -->
			<!-- 
			<property name="ipAddress">127.0.0.1</property>
			 -->
			
			<property name="manager">${clientConnectioneManager}</property>
			
			<property name="connectionFactory">
				<bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">
					<property name="sendBufferSize">128</property>
					<property name="receiveBufferSize">64</property>
				</bean>
			</property>
			
			<property name="authenticator">
				<bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">
					
					<property name="user">amoebaUser</property>
					
					<property name="password">123</property>
					
					<property name="filter">
						<bean class="com.meidusa.amoeba.server.IPAccessController">
							<property name="ipFile">${amoeba.home}/conf/access_list.conf</property>
						</bean>
					</property>
				</bean>
			</property>
			
		</service>

     然後是事務，事務的話可以直接使用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的事務做不到原子性，也就是不支援JTA。

這麼看來Amoeba的使用場景確實有限，

首先domain層最好不要使用JPA之類的ORM框架，純JDBC開發更可靠。。。然後不支援XA的transaction。

綜合對比一下，第一種做法更簡單也更放心，第二種做法，還是再議吧。。。

相關推薦

Mysql讀寫分離的兩種方法對比：Spring+JPA應用層實現 vs Amoeba中介軟體實現

前段時間看了篇文章，講Youku網資料庫架構的演變，如何從最開始的讀寫分離，再到垂直分割槽，最後到水平分片，一步一步慢慢成熟的。看完之後很有衝動抽出一個模型來把這幾種技術都實現一下。      說幹就幹，首先是讀寫分離了，我使用的資料庫是Mysql，主從資料複製用的是半

mysql讀寫分離的三種實現方式

不能 span bsp 缺點 解決方案 使用 隨機 mas 均衡 　　1 程序修改mysql操作類可以參考PHP實現的Mysql讀寫分離，阿權開始的本項目，以php程序解決此需求。優點：直接和數據庫通信，簡單快捷的讀寫分離和隨機的方式實現的負載均衡，權限獨立分配缺點：自己維

Mysql讀寫分離方案－MySQL Proxy環境部署記錄

round back 通過 and http 意思 同時 主從 角色 Mysql的讀寫分離可以使用MySQL Proxy和Amoeba實現，其實也可以使用MySQL-MMM實現讀寫分離的自動切換。MySQL Proxy有一項強大功能是實現"讀寫分離"，基本原理是讓主數據

amoeba實現mysql讀寫分離+主從復制架構

mysql amoeba 讀寫分離 主從復制一、環境系統：centos6.5mysql版本：mysql5.6master服務器：192.168.1.21slave服務器： 192.168.1.100master寫 slave讀二、實現mysql主從復制在master的/etc/my.cnf中[mysqld]字

mysql中間件amoeba實現mysql讀寫分離

ipaddress -c export div 高可用 rop 6.0 res grant Amoeba是一個以MySQL為底層數據存儲，並相應用提供MySQL協議接口的proxy。它集中地響應應用的請求，根據用戶事先設置的規則。將SQL請求發送到特定的數據庫上運行

mysql讀寫分離

mysql amabeamoeba 實現 mysql 讀寫分離Amoeba 其實是一個代理,接收所有請求,將其分類,根據我們寫在 xml 文件裏的規則,將其投放出去,比如讀寫分離,將所有的寫操作投放給 master,將所有的讀操作投放給 slave,最後再由他返回給用戶. 讀寫分離能有效利用 mysql 主從

mycat實現MySQL讀寫分離

mycat mysql讀寫分離 mycat實現MySQL讀寫分離mycat是什麽Mycat是一個開源的分布式數據庫系統，但是由於真正的數據庫需要存儲引擎，而Mycat並沒有存儲引擎，所以並不是完全意義的分布式數據庫系統。Mycat是數據庫中間件，就是介於數據庫與應用之間，進行數據處理與交互的中間服務。

Linux的企業-Mysql讀寫分離，組的復制Group-based Replication（2）

mysql讀寫分離 組的復制 基於組的復制（Group-based Replication）是一種被使用在容錯系統中的技術。Replication-group（復制組）是由能夠相互通信的多個服務器（節點）組成的。在通信層，Group replication實現了一系列的機制：比如原子消息（atomic

使用Spring AOP實現MySQL讀寫分離

npr getclass mod rac ava nfa release box port spring aop ， mysql 主從配置 實現讀寫分離，下來把自己的配置過程，以及遇到的問題記錄下來，方便下次操作，也希望給一些朋友帶來幫助。mysql主從配置參看：http:

實現MySQL讀寫分離，MySQL性能調優

affect iad list cte 軟件包 密碼 sts 要求 select 實現MySQL讀寫分離 1.1 問題 本案例要求配置2臺MySQL服務器+1臺代理服務器，實現MySQL代理的讀寫分離： 用戶只需要訪問MySQL代理服務器，而實際的SQL查詢、寫入操作交給

6MySQL 主從同步 、 MySQL 讀寫分離 、 MySQL 性能調優

chang 時間 form 變量名 col 最大 rom 驗證 uptime day06一、mysql主從同步 二、數據讀寫分離三、MySQL優化++++++++++++++++++++++++++++++++一、mysql主從同步 1.1 主從同步介紹？從庫服務器自動同

Mysql讀寫分離-Mysql router

post ble -- .rpm https mariadb ogg tcp 實現 原理：MySQL router根據端口來區分讀寫，把連接讀寫端口的所有請求發往master，連接只讀端口的所有請求以輪詢方式發往多個slave，從而實現讀寫分離 主： SQL-Maste

Mysql讀寫分離-amoeba

使用 客戶 cor 刷新 cto query 查詢 runt 刷新數據 轉載自http://www.cnblogs.com/liuyisai/p/6009379.html Amoeba主配置文件($AMOEBA_HOME/conf/amoeba.xml)，用來配置Amo

Mysql讀寫分離-atlas

src -o eal only utf8 iad deb 字段 情況 下載地址https://github.com/Qihoo360/Atlas/releases 安裝rpm包 rpm -ivh Atlas-2.2.1.el6.x86_64.rpm 程序目錄在/usr/lo

haproxy+keepalived+mycat+mysql (讀寫分離）

haproxy+keepalived+m描述：架構方案： mysql （master/slave） --gtid 方式主備（pos 也可）mycat （master/slave） --xinted 插件時間主備模式haproxy （master/slave） --keepalived 自動切換--keepal

企業 - mysql 讀寫分離（proxy）

mysql 讀寫分離（proxy） MySQL ProxyMySQL Proxy是一個處於你的client端和MySQL server端之間的簡單程序，它可以監測、分析或改變它們的通信。它

Mysql讀寫分離--mysql-proxy

mysql 讀寫分離準備前提：1、MySQL的安裝與配置 --省略版本：Server version: 5.6.351.1 系統版本：[root@centos7-67 package]# lsb_release -aLSB Version: :core-4.1-amd64:core-4.1-noarchDis

MYSQL讀寫分離解決方案：MariaDB MaxScale部署實錄

maxscaleMASTER（KING01）[root@king01 ~]# mysql -uroot -pabcd.1234 Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 173 S

MYSQL讀寫分離解決方案：MYCAT部署實錄

mysql mycat 讀寫分離 MASTER （KING01）[root@king01 ~]# mysql -uroot -pabcd.1234 mysql> show master status; +------------------+----------+--------------

安裝mysql-proxy實現mysql讀寫分離

mysql-proxy 讀寫分離 一. 環境描述操作系統版本：centos 7.2主服務器：192.168.0.72 node2從服務器：192.168.0.73 node3調度服務器MySQL-Proxy：192.168.0.71 node1二. 配置mysql主從2.1 安裝mysqlno