Spring实现数据库读写分离

最新推荐文章于 2024-07-29 11:58:47 发布
最新推荐文章于 2024-07-29 11:58:47 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： Spring
转载自：http://itindex.net/detail/50093-spring-%E6%95%B0%E6%8D%AE%E5%BA%93
              http://blog.csdn.net/alaahong/article/details/8707915

       在数据库层面需要采用读写分离技术，就是一个master数据库，多个slave数据库。master库负责数据更新和实时数据查询，slave库负责非实时数据查询。因为在实际的应用中，数据库都是读多写少（读取数据的频率高，更新数据的频率相对较少），而读取数据通常耗时比较长，占用数据库服务器的CPU较多。

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


       如何方便的实现读写分离呢?
       1.第一种方式是最简单的方式，就是定义2个数据库连接，一个是masterDataSource,另一个是slaveDataSource。对DAO的dataSource属性注入是，根据需求分别如入不同的DataSource。有时由于在同一个DAO中可能既有select又有insert，那样就需要对同一类型的DAO写两个DAO，比如就可能需要将UserDaoImp拆分为UserDaoImp_w与UserDaoImp_r。
       2. 第二种方式，不将UserDaoImp拆分为UserDaoImp_w与UserDaoImp_r。在UserDaoImp的方法调用前使用this.setDataSource()来切换DataSource，但是存在线程安全问题。例如，线程一中，调用了f1()，将datasource切换为masterDataSource ，准备写数据到主数据库，但是这时线程二，调用了f2()，将datasource切换为slaveDataSource，准备从从数据库读数据，那么线程一继续执行f1()的方法就会出现问题。原因在于线程一、线程二使用的是一个UserDaoImp实例（spring加载的bean默认都是单例），共用的一个datasource。当然可不让UserDaoImp为单例，并结合ThreadLocal来避免线程安全问题，但是不推荐。
       3. 第三种方式动态数据源切换，就是在程序运行时，把数据源动态织入到程序中，从而选择读取主库还是从库。 这里Spring的AbstractRoutingDataSource提供了很好的支持。
 
public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

	private Map<Object, Object> targetDataSources;

	private Object defaultTargetDataSource;

	private boolean lenientFallback = true;

	private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();

	private Map<Object, DataSource> resolvedDataSources;

	private DataSource resolvedDefaultDataSource;
        
        ......
       AbstractRoutingDataSource继承了AbstractDataSource ，而AbstractDataSource 又是DataSource 的子类。DataSource是javax.sql的数据源接口，定义如下： 
public interface DataSource  extends CommonDataSource, Wrapper {

  Connection getConnection() throws SQLException;
 
  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);
}
       AbstractRoutingDataSource通过调用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;
}
      determineCurrentLookupKey()方法返回lookupKey, resolvedDataSources()方法就是根据 lookupKey从Map中获得数据源。

示例：
beans.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

	<bean id="m_dataSource"
		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/zero" />
		<property name="username" value="root/>
		<property name="password" value="123456" />
	</bean>

	<bean id="s_dataSource"
		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/zero_test" />
		<property name="username" value="root" />
		<property name="password" value="123456" />
	</bean>

	<bean id="dynamicDataSource" class="com.zero.springjdbc.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<!-- write -->
				<entry key="master" value-ref="m_dataSource" />
				<!-- read -->
				<entry key="slave" value-ref="s_dataSource" />
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="m_dataSource" />
	</bean>


	<bean id="zeroDaoImpl" class="com.zero.springjdbc.ZeroDaoImpl">
		<property name="dataSource" ref="dynamicDataSource"></property>
	</bean>

</beans>
       以上的beans.xml中，配置了两个DataSource，m_dataSource与s_dataSource，然后将这两个DataSource交给com.zero.springjdbc.DynamicDataSource管理，由于com.zero.springjdbc.DynamicDataSource是继承了AbstractRoutingDataSource，所以给它的两个属性targetDataSources、defaultTargetDataSource注入值。而DAO层的dataSource属性所使用的是dynamicDataSource。

DynamicDataSourceHolder.java 
package com.zero.springjdbc;

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

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

	public static String getDataSouce() {
		return holder.get();
	}
}
       这里利用了ThreadLocal，来指明每个线程在进行数据库操作时所用到的数据库。

DynamicDataSource.java 
package com.zero.springjdbc;

import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource{

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

	@Override
	public Logger getParentLogger() throws SQLFeatureNotSupportedException {
		// TODO Auto-generated method stub
		return null;
	}
}
ZeroDaoImpl.java 
package com.zero.springjdbc;

import org.springframework.jdbc.core.JdbcTemplate;

public class ZeroDaoImpl extends JdbcTemplate {

	public void update1() {
		DynamicDataSourceHolder.setDataSource("master");
		String sql01 = "update lineitem_record set fee=111111 where lineitemId='11238'";
		System.out.println("update1 lineitemId='11238' : "
				+ this.update(sql01));
		
		String sql02 = "update lineitem_record set fee=111111 where lineitemId='111'";
		System.out.println("update1 lineitemId='111' : "
				+ this.update(sql02));
	}

	public void update2() {
		try {
			
			DynamicDataSourceHolder.setDataSource("slave");
			String sql01 = "update lineitem_record set fee=111111 where lineitemId='11238'";
			System.out.println("update2 lineitemId='11238' : "
					+ this.update(sql01));
			
			String sql02 = "update lineitem_record set fee=222222 where lineitemId='111'";
			System.out.println("update2 lineitemId='111' : "
					+ this.update(sql02));
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
}
       这里的每个方法都DynamicDataSourceHolder.setDataSource(),来指明接下来的操作将使用的是什么数据库，由于被ThreadLocal隔离了，所以是线程安全的。

Test.java 
package com.zero.springjdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext ctx = new ClassPathXmlApplicationContext(
				"/com/zero/springjdbc/beans.xml");
		ZeroDaoImpl zeroDaoImpl = (ZeroDaoImpl) ctx.getBean("zeroDaoImpl");
		for (int i = 0; i < 5; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					zeroDaoImpl.update1();
				}
			}, "thread1-" + i).start();
			;
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					zeroDaoImpl.update2();
				}
			}, "thread2-" + i).start();
			;
		}

	}

}
      这里建了10个线程，每个线程执行zeroDaoImpl.update1()或zeroDaoImpl.update2()方法来检验是否是线程安全的。
      PS：master的lineitem_record表中有lineitemId='11238'，没有lineitemId='111'；而slave的lineitem_record表中没有lineitemId='11238'，有lineitemId='111'。预期结果是update1 lineitemId='11238' 的值是1，而update1 lineitemId='111'的值是0，update2 lineitemId='11238' 的值是0，而update2 lineitemId='111'的值是1。如果不是这样，那么就说明在多线程环境下，依然会出现方式二所面临的问题。
测试结果： 
update2 lineitemId='11238' : 0
update1 lineitemId='11238' : 1
update2 lineitemId='11238' : 0
update1 lineitemId='11238' : 1
update2 lineitemId='11238' : 0
update1 lineitemId='11238' : 1
update1 lineitemId='11238' : 1
update1 lineitemId='11238' : 1
update2 lineitemId='11238' : 0
update1 lineitemId='111' : 0
update2 lineitemId='111' : 1
update1 lineitemId='111' : 0
update1 lineitemId='111' : 0
update2 lineitemId='111' : 1
update2 lineitemId='111' : 1
update1 lineitemId='111' : 0
update2 lineitemId='11238' : 0
update2 lineitemId='111' : 1
update1 lineitemId='111' : 0
update2 lineitemId='111' : 1
      由结果可知， 利用Spring的AbstractRoutingDataSource可以解决多数据源的问题。

贴上AbstractRoutingDataSource源码： 
package org.springframework.jdbc.datasource.lookup;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.jdbc.datasource.AbstractDataSource;
import org.springframework.util.Assert;

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

	private Map<Object, Object> targetDataSources;

	private Object defaultTargetDataSource;

	private boolean lenientFallback = true;

	private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();

	private Map<Object, DataSource> resolvedDataSources;

	private DataSource resolvedDefaultDataSource;

	public void setTargetDataSources(Map<Object, Object> targetDataSources) {
		this.targetDataSources = targetDataSources;
	}

	public void setDefaultTargetDataSource(Object defaultTargetDataSource) {
		this.defaultTargetDataSource = defaultTargetDataSource;
	}

	public void setLenientFallback(boolean lenientFallback) {
		this.lenientFallback = lenientFallback;
	}

	public void setDataSourceLookup(DataSourceLookup dataSourceLookup) {
		this.dataSourceLookup = (dataSourceLookup != null ? dataSourceLookup : new JndiDataSourceLookup());
	}


	public void afterPropertiesSet() {
		if (this.targetDataSources == null) {
			throw new IllegalArgumentException("Property 'targetDataSources' is required");
		}
		this.resolvedDataSources = new HashMap<Object, DataSource>(this.targetDataSources.size());
		for (Map.Entry entry : this.targetDataSources.entrySet()) {
			Object lookupKey = resolveSpecifiedLookupKey(entry.getKey());
			DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());
			this.resolvedDataSources.put(lookupKey, dataSource);
		}
		if (this.defaultTargetDataSource != null) {
			this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
		}
	}

	protected Object resolveSpecifiedLookupKey(Object lookupKey) {
		return lookupKey;
	}

	protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
		if (dataSource instanceof DataSource) {
			return (DataSource) dataSource;
		}
		else if (dataSource instanceof String) {
			return this.dataSourceLookup.getDataSource((String) dataSource);
		}
		else {
			throw new IllegalArgumentException(
					"Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
		}
	}


	public Connection getConnection() throws SQLException {
		return determineTargetDataSource().getConnection();
	}

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

	@Override
	@SuppressWarnings("unchecked")
	public <T> T unwrap(Class<T> iface) throws SQLException {
		if (iface.isInstance(this)) {
			return (T) this;
		}
		return determineTargetDataSource().unwrap(iface);
	}

	@Override
	public boolean isWrapperFor(Class<?> iface) throws SQLException {
		return (iface.isInstance(this) || determineTargetDataSource().isWrapperFor(iface));
	}

	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;
	}

	protected abstract Object determineCurrentLookupKey();

}
zero__007
关注
专栏目录
spring+springmvc+mybatis的整合以及数据库读写分离的测试
06-12
spring+springmvc+mybatis的整合以及数据库读写分离的测试
Spring 实现数据库读写分离的示例
08-31
Spring 实现数据库读写分离是一种常见的优化策略，用于应对大规模应用中的数据库性能挑战。在大型电子商务系统中，由于读操作远多于写操作，通过读写分离可以将读操作分散到多个从库，减轻主库的压力，提升系统整体...
Spring实现数据库的读写分离
courage丶的博客
03-10 356
在mysql的主从架构，或者一主多从的架构中，需要做读写分离。除了使用中间件实现外，还可以使用SpringAOP在代码层面实现。
为什么要读写分离？如何实现业务系统读写分离？
最新发布
oOBubbleX的博客
07-29 1257
本文介绍了什么是读写分离以及读写分离的应用场景并附实战案例。
利用Spring实现数据库读写分离
ycb1689的专栏
03-22 2325
借助于Spring框架在2.0.1之后提供的AbstractRoutingDataSource可以实现动态的选择数据源datasource，下面先举一个最简单的例子（可以参考这个链接 http://spring.io/blog/2007/01/23/dynamic-datasource-routing）：   1. 首先新建一个Catalog VO对象的DAO（见代码1），它继承了S
Spring系列第52篇：Spring实现数据库读写分离
路人甲Java
11-12 3749
1、背景大多数系统都是读多写少，为了降低数据库的压力，可以对主库创建多个从库，从库自动从主库同步数据，程序中将写的操作发送到主库，将读的操作发送到从库去执行。今天的主要目标：通过 spr...
Spring实现数据库读写分离代码
04-12
通过以上分析，我们可以看出，Spring、Spring MVC、MyBatis和MySQL的组合，为实现数据库读写分离提供了一种高效且灵活的解决方案。理解并掌握这些知识点，对于提升系统的稳定性和性能具有重要的意义。
Spring boot实现数据库读写分离的方法
08-31
本文将深入探讨如何利用Spring Boot结合自定义的数据源路由实现数据库读写分离。 首先，数据库读写分离的基本思想是将读操作和写操作分散到不同的数据库实例上，通常主库用于处理写操作，而从库用于处理读操作。...
在应用层透过spring解决数据库读写分离
09-09
在应用层解决数据库读写分离可以通过Spring框架来实现，本文将介绍如何使用Spring解决数据库读写分离。 概念 * 读写分离：将数据库的读取和写入操作分开处理，以提高数据库的性能和可用性。 * 主从复制：将主...
[Spring]配置数据库读写分离
Konaji
03-08 4598
[Spring]配置数据库读写分离
04_集合类线程不安全问题
08-29 423
Collection线程不安全的举例 单线程环境和多线程下效果如何 单线程环境的ArrayList是不会有问题的 @Test public void test1(){ //单线程是没问题问题的 我们非常熟悉 List<String> list = new ArrayList<>(); list.add("dd"); list.add("aa"); list.add("bb"); l
mysql读写分离实现_如何实现MySQL数据库的读写分离？
weixin_39929687的博客
12-05 1541
上一篇文章我们已经介绍过《MySQL是如何实现主从备份的？》但如果主库只负责所有的读写操作，而从库只实现备份功能，这样的主从架构看起来性价比似乎不是很高。我们所希望的主从架构是，当我们在写数据时，请求全部发到Master节点上，当我们需要读数据时，请求全部发到Slave节点上。并且多个Slave节点最好可以存在负载均衡，那么这样的架构就能够让集群的效率最大化。实现读写分离，实际上有两种经...
SpringCloud - Springboot 实现读写分离
Andy_Health的博客
08-24 2208
Springboot项目的构建 首先，我们在idea中创建一个新项目。在pom中引入如下的依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <depe
如何实现读写分离
qq_21209307的博客
04-22 2504
使用场景 当我们的数据量很大时，数据库服务器的压力就会增大，性能就会受到挑战。在一个网站中，根据二八原则，百分之二十的操作是写操作，百分之八十的操作是读操作。那么从数据库这边我们可以配置读写分离，把读操作和写操作分离出来，最大程度的利用好数据库服务器。 实现逻辑 读写分离的实现原理是，在执行SQL语句的时候，判断到底是读操作还是写操作，把读操作转向读操作服务器（从服务器，一般是多台）；写的操...
读写分离怎么实现_MyCat实现读写分离
weixin_39622891的博客
12-14 53
实现读写分离需要更改两个配置文件Schema.xml和Server.xml文件Schema.xml文件的修改重要的属性设置1.schema 的name属性：用于设置在MyCat中显示的虚拟库的名称2.table：设置表的有几个表就会有几个table标签3.table name：要和物理存在的表的名称一致4.dataNode name 为table引用，dataHost引用dataHost标签 da...
读写分离怎么做，怎么实现
Angus
12-13 3477
实现方案： # #第一种是在应用层做 方案就是根据我们的不同的sql语句来选择不同的数据源来操作，优点是对性能的损耗比较小，缺点是强依赖程序员。如果是是新开发程序还好。如果是改造原有的系统，就会变的及其糟糕。 可以选择的技术有： 从上边的四个方案中选，我们要选的是红色的。原因是无侵入，原有代码不需要做任何改变。 来看一下工作原理： 在dao层之后，数...
Spring实现数据库读写分离：应用层与中间件方案
"本文主要探讨了如何利用Spring框架解决数据库的读写分离问题，提供了两种解决方案：应用层解决和中间件解决，并详细介绍了基于应用层的Spring实现方式。" 在应对高并发的读取压力时，数据库的读写分离是一种有效的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值