文档章节
xxggy的个人页面 Spring
正文

Spring JDBC_多数据源和事务的配置
原

秋风醉了
 秋风醉了 发布于 2014/11/10 19:34
字数 1875
阅读 447
收藏 3
评论 0

程序员们，在北上广你还能买房吗？ >>>   

Spring JDBC_多数据源和事务的配置


直接帖代码：

maven项目，以下是pom：

<dependencies>
	<dependency>
		<groupId>org.apache.tomcat</groupId>
		<artifactId>tomcat-jdbc</artifactId>
		<version>8.0.14</version>
	</dependency>

	<!--spring context -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!--spring core -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!--spring bean -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!--spring aop -->

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!--spring jdbc -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jdbc</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!-- spring tx -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-tx</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!-- spring test -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>4.1.1.RELEASE</version>
	</dependency>

	<!-- spring-batch-core -->
	<dependency>
		<groupId>org.springframework.batch</groupId>
		<artifactId>spring-batch-core</artifactId>
		<version>3.0.2.RELEASE</version>
	</dependency>

	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.10</version>
		<scope>test</scope>
	</dependency>

	<!--aspectj -->
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjrt</artifactId>
		<version>1.8.2</version>
	</dependency>
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.2</version>
	</dependency>

	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.6</version>
	</dependency>
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>3.8.1</version>
		<scope>test</scope>
	</dependency>
</dependencies>


主要说一下我的思路：

  1. 首先配置多个数据源，继承spring 的AbstractRoutingDataSource 实现管理多数据源

  2. 然后考虑怎么实现动态选择多数据源，使用ThreadLocal，在线程中传递参数，通过对应的数据源的key动态的选择多数据源

以上就是基本思路，但还要考虑如何管理事务。这里考虑使用@Transactional标签管理事务，当你配置好事务，并且在代码中动态选择数据源时，发现根本不好使，原因就是你开启了事务，早在你动态选择数据源之前，开启的事务就已经连接了数据库，等到执行具体的sql语句时，选择的数据源总是事务中连接的数据库，下面是DataSourceUtils.java中的一段代码，通过该代码，你可以看到具体是如何选择数据库连接的：

public static Connection doGetConnection(DataSource dataSource) throws SQLException {
	Assert.notNull(dataSource, "No DataSource specified");

	ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
	if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
		conHolder.requested();
		if (!conHolder.hasConnection()) {
			logger.debug("Fetching resumed JDBC Connection from DataSource");
			conHolder.setConnection(dataSource.getConnection());
		}
		return conHolder.getConnection();
	}
	// Else we either got no holder or an empty thread-bound holder here.

	logger.debug("Fetching JDBC Connection from DataSource");
	Connection con = dataSource.getConnection();

	if (TransactionSynchronizationManager.isSynchronizationActive()) {
		logger.debug("Registering transaction synchronization for JDBC Connection");
		// Use same Connection for further JDBC actions within the transaction.
		// Thread-bound object will get removed by synchronization at transaction completion.
		ConnectionHolder holderToUse = conHolder;
		if (holderToUse == null) {
			holderToUse = new ConnectionHolder(con);
		}
		else {
			holderToUse.setConnection(con);
		}
		holderToUse.requested();
		TransactionSynchronizationManager.registerSynchronization(
				new ConnectionSynchronization(holderToUse, dataSource));
		holderToUse.setSynchronizedWithTransaction(true);
		if (holderToUse != conHolder) {
			TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
		}
	}

	return con;
}


好了，思路就又来了，既然在开启事务的时候就选择了数据源，那么必须要在事务开启之前选择数据源：很简单的做法，其实就是在开启事务的方法上加上切面，实现动态选择数据源。

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

	<aop:aspectj-autoproxy />
	<!-- 定义包的扫描规则 -->
	<context:component-scan base-package="com.lyx">
		<context:include-filter type="annotation"
			expression="org.springframework.stereotype.Service" />
		<context:include-filter type="annotation"
			expression="org.springframework.stereotype.Repository" />
		<context:include-filter type="annotation"
			expression="org.springframework.stereotype.Component" />
	</context:component-scan>

	<!--tomcat jdbc pool数据源配置 -->
	<bean id="localDataSource" class="org.apache.tomcat.jdbc.pool.DataSource"
		destroy-method="close">
		<property name="poolProperties">
			<bean class="org.apache.tomcat.jdbc.pool.PoolProperties">
				<property name="driverClassName" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://10.255.9.79:3306/local_database" />
				<property name="username" value="root" />
				<property name="password" value="034039" />
			</bean>
		</property>
	</bean>

	<!--tomcat jdbc pool数据源配置 -->
	<bean id="threadDataSource" class="org.apache.tomcat.jdbc.pool.DataSource"
		destroy-method="close">
		<property name="poolProperties">
			<bean class="org.apache.tomcat.jdbc.pool.PoolProperties">
				<property name="driverClassName" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://10.255.9.79:3306/thread_database" />
				<property name="username" value="root" />
				<property name="password" value="034039" />
			</bean>
		</property>
	</bean>

	<!--tomcat jdbc pool数据源配置 -->
	<bean id="remoteDataSource" class="org.apache.tomcat.jdbc.pool.DataSource"
		destroy-method="close">
		<property name="poolProperties">
			<bean class="org.apache.tomcat.jdbc.pool.PoolProperties">
				<property name="driverClassName" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://10.255.9.79:3306/remote_database" />
				<property name="username" value="root" />
				<property name="password" value="034039" />
			</bean>
		</property>
	</bean>

	<!--使用枚举类型作为key -->
	<bean id="dataSource" class="com.lyx.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="com.lyx.DataSourceLookupKey">
				<entry key="REMOTE_DATASOURCE" value-ref="remoteDataSource" />
				<entry key="THREAD_DATASOURCE" value-ref="threadDataSource" />
				<entry key="LOCAL_DATASOURCE" value-ref="localDataSource" />
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="localDataSource" />
	</bean>

	<!-- spring的事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 动态选择数据源的切面 -->
	<bean id = "determineDataSourceAspect" class="com.lyx.DetermineDataSourceAspect"/>
	<!-- 切面的配置 -->
	<aop:config>
		<aop:aspect id="determineDataSourceAspect" ref="determineDataSourceAspect">
			<aop:pointcut id="dataSourcePoint"
				expression="@annotation(com.lyx.RequireDataSource)" />
			<aop:before method="determineDataSource" pointcut-ref="dataSourcePoint" />
		</aop:aspect>
	</aop:config>

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

</beans>

看到这里，你可能会问，为什么没有使用aspect的风格来配置切面，实现aop，答案就是那种方式不好用，@Transactional代理比我配置的注解的代理要提前一步，导致动态选择数据源的切面发挥不了作用。而这种方式就可以很好的工作。。


相关的类：

DataSourceLookupKey.java

package com.lyx;

/**
 * 
 * @author Lenovo
 */
public enum DataSourceLookupKey {

	LOCAL_DATASOURCE("本地数据库"), REMOTE_DATASOURCE("远程数据库"), THREAD_DATASOURCE(
			"THREAD数据库");

	private String value;

	private DataSourceLookupKey(String value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return this.value;
	}

}

DbContextHolder.java

package com.lyx;

/**
 * 
 * @author Lenovo
 */
public class DbContextHolder {
	// 利用ThreadLocal解决线程安全问题
	private static final ThreadLocal<DataSourceLookupKey> contextHolder = new ThreadLocal<DataSourceLookupKey>();

	// 设置数据源
	public static void setDbType(DataSourceLookupKey dbType) {
		contextHolder.set(dbType);
	}

	// 获取数据源
	public static DataSourceLookupKey getDbType() {
		return (DataSourceLookupKey) contextHolder.get();
	}

	// 清空
	public static void clearDbType() {
		contextHolder.remove();
	}
}

DynamicDataSource.java

package com.lyx;

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

public class DynamicDataSource extends AbstractRoutingDataSource {

	@Override
	protected DataSourceLookupKey determineCurrentLookupKey() {
		// TODO Auto-generated method stub
		if (!(DbContextHolder.getDbType() == null)) {
			System.out.println("====>" + DbContextHolder.getDbType());
		} else {
			System.out.println("====>没有初始化数据库上下文环境");
		}

		return DbContextHolder.getDbType();
	}
}

DetermineDataSourceAspect.java

package com.lyx;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

public class DetermineDataSourceAspect {

	public void determineDataSource(JoinPoint point) {
		System.out
				.println("determine datasource begin>>>>>>>>>>>>>>>>>>>>>>>>>");
		RequireDataSource datasource = ((MethodSignature) point.getSignature())
				.getMethod().getAnnotation(RequireDataSource.class);
		System.out.println("====>" + datasource.name());
		DbContextHolder.setDbType(datasource.name());
		System.out.println("determine datasource end>>>>>>>>>>>>>>>>>>>>>>>>>");
	}

}

RequireDataSource.java

package com.lyx;

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface RequireDataSource {

	/**
	 * the name of datasource
	 * 
	 * @return
	 */
	DataSourceLookupKey name();
}

PersonDao.java

package com.lyx;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

@Repository
public class PersonDao {

	private JdbcTemplate jdbcTemplate;

	@Autowired
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}

	/**
	 * 查询记录的个数
	 * 
	 * @return
	 */
	public long count() {
		long rowCount = this.jdbcTemplate.queryForObject(
				"select count(*) from people", Long.class);
		return rowCount;
	}

	/**
	 * 查询同名的人的个数
	 * 
	 * @param name
	 * @return
	 */
	public long countPeopleByName(String name) {
		long countOfActorsNamedJoe = this.jdbcTemplate.queryForObject(
				"select count(*) from people where first_name = ?", Long.class,
				name);
		return countOfActorsNamedJoe;
	}

	/**
	 * 根据Id查询姓名
	 * 
	 * @param id
	 * @return
	 */
	public String queryNameById(int id) {
		String lastName = this.jdbcTemplate.queryForObject(
				"select last_name from t_actor where person_id = ?",
				new Object[] { id }, String.class);
		return lastName;
	}

	/**
	 * 根据Id查找实体
	 * 
	 * @param id
	 * @return
	 */
	public People findPeopleById(int id) {
		People people = this.jdbcTemplate.queryForObject(
				"select first_name, last_name from people where person_id = ?",
				new Object[] { id }, new RowMapper<People>() {
					public People mapRow(ResultSet rs, int rowNum)
							throws SQLException {
						People p = new People();
						p.setFirstName(rs.getString("first_name"));
						p.setLastName(rs.getString("last_name"));
						return p;
					}
				});

		return people;
	}

	/**
	 * 分页查询people
	 * 
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public List<People> findPeopleList(int pageNo, int pageSize) {
		int start = (pageNo - 1) * pageSize;
		List<People> peoples = this.jdbcTemplate.query(
				"select first_name, last_name from people limit ?,?",
				new Object[] { start, pageSize }, new RowMapper<People>() {
					public People mapRow(ResultSet rs, int rowNum)
							throws SQLException {
						People p = new People();
						p.setFirstName(rs.getString("first_name"));
						p.setLastName(rs.getString("last_name"));
						return p;
					}
				});

		return peoples;
	}

	/**
	 * 分页查询
	 * 
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public List<People> findPeopleList0(int pageNo, int pageSize) {
		int start = (pageNo - 1) * pageSize;
		List<People> peoples = this.jdbcTemplate.query(
				"select first_name, last_name from people limit ?,?",
				new Object[] { start, pageSize }, new PeopleRowMapper());

		return peoples;
	}

	private static class PeopleRowMapper implements RowMapper<People> {
		public People mapRow(ResultSet rs, int rowNum) throws SQLException {
			// TODO Auto-generated method stub
			People p = new People();
			p.setFirstName(rs.getString("first_name"));
			p.setLastName(rs.getString("last_name"));
			return p;
		}
	}

	/**
	 * 插入实体
	 * 
	 * @param people
	 */
	public void addPeople(People people) {
		this.jdbcTemplate.update(
				"insert into people (first_name, last_name) values (?, ?)",
				people.getFirstName(), people.getLastName());
	}

	/**
	 * 更新实体
	 * 
	 * @param id
	 */
	public void updatePeopleName(int id, String name) {
		this.jdbcTemplate
				.update("update people set last_name = ? where person_id = ?",
						name, id);
	}

	/**
	 * 删除实体
	 * 
	 * @param id
	 */
	public void deletePeople(int id) {
		this.jdbcTemplate.update("delete from people where person_id = ?", id);
	}

	/**
	 * 执行sql语句
	 * 
	 * @param sql
	 *            create table mytable (id integer, name varchar(100))
	 */
	public void execute(String sql) {
		this.jdbcTemplate.execute(sql);
	}
}

PersonService.java

package com.lyx;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PersonService {

	@Autowired
	private PersonDao personDao;

	@RequireDataSource(name = DataSourceLookupKey.REMOTE_DATASOURCE)
	@Transactional
	public void addperson() {
		System.out.println("-----addPerson begin-----");
		System.out.println("====>" + DbContextHolder.getDbType());
		People people = new People();
		people.setFirstName("adasdfasdfwe");
		people.setLastName("adadfeexcsdwadfsafd");
		this.personDao.addPeople(people);
		System.out.println("-----addPerson end-----");
		System.out.println("====>" + DbContextHolder.getDbType());
	}
}


测试类：

AppMain.java

package com.lyx;

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.datasource.ConnectionHolder;
import org.springframework.jdbc.datasource.DataSourceUtils.ConnectionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.Assert;

public class AppMain {

	public static void main(String[] args) {
		@SuppressWarnings("resource")
		ApplicationContext context = new ClassPathXmlApplicationContext(
				new String[] { "classpath:spring-dao.xml" });
		PersonService personService = (PersonService) context
				.getBean("personService");
		personService.addperson();
	}
	

}

结果：

determine datasource begin>>>>>>>>>>>>>>>>>>>>>>>>>

====>远程数据库

determine datasource end>>>>>>>>>>>>>>>>>>>>>>>>>

====>远程数据库

-----addPerson begin-----

====>远程数据库

-----addPerson end-----

====>远程数据库

如果你要动态选择数据库，就在该方法上加上注解@RequireDataSource，name值为数据库的枚举值。。


============================END============================


© 著作权归作者所有

收藏 (3)
举报
共有 人打赏支持
上一篇： MySQL Cursor在存储过程中的使用
下一篇： InnoDB Read-Only Transactions_只读事务
秋风醉了

秋风醉了

粉丝 241
博文 566
码字总数 417505
作品 0
朝阳
程序员
私信 提问
相关文章 最新文章
轻量级的关系型数据库中间件 - Sharding-JDBC

Sharding-JDBC是一个开源的适用于微服务的分布式数据访问基础类库，它始终以云原生的基础开发套件为目标。 Sharding-JDBC定位为轻量级java框架，使用客户端直连数据库，以jar包形式提供服务，...

亮_dangdang
2016/01/27
0
27
SpringBoot+MyBatis+MySQL读写分离

引言 读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行，至于谁来做选择数据库这件事儿，无非两个，要么中间件帮我们做，要么程序自己做。因此，一般来讲，读写分离有两种实现方式。...

编程SHA
01/14
0
0
SSH框架之Spring4专题4：Spring与DAO

本专题内容主要包含两部分：Spring所使用的操作数据库的技术之一，JDBC模版的使用；另一部分则为Spring对于事务的管理。 Spring与Dao部分，是Spring的两大核心技术loC与AOP的经典应用体现： ...

糖醋白糖
2018/06/26
0
0
Spring引用Tomcat的 JTA事务

Spring引用Tomcat的 JTA事务 Tomcat是Servlet容器，但它提供了JNDI的实现，因此用户可以象在Java EE应用程序服务器中一样，在Tomcat中使用JNDI查找JDBC数据源。在事务处理方面，Tomcat本身并...

崔耀升
2010/06/12
0
0
Hasor JDBC 的难关，嵌套事务处理思路

本文存属提醒我自己不要忘记的事情。也是向大家展示 Hasor 对于 JDBC 方面即将的又一个重大的进步。目前该方案还在实施中。 前段时间闲着没事分析了下 Spring JDBC ，觉得 Spring JDBC 的设计...

哈库纳
2013/12/29
0
9

没有更多内容

加载失败，请刷新页面

加载更多

百度黄埔学院将培养一批首席AI架构师，为“国之重器”赋能

深度学习高端人才不仅是AI发展的重要养分，也是企业转型AI巨大推动力。2019年1月19日，百度黄埔学院——深度学习架构师培养计划在百度科技园举行开学典礼，深度学习技术及应用国家工程实验室...

深度学习之桨
34分钟前
2
0
扒站wget仿站

wget -c -r -p -np -k http://xxx.com/xxx 其中： -c, --continue （断点续传） 接着下载没下载完的文件 -r, --recursive（递归） specify recursive download.（指定递归下载） -p, --page...

临江仙卜算子
37分钟前
2
0
Nextjs+React非页面组件SSR渲染

@随风溜达的向日葵 Nextjs Nextjs是React生态中非常受欢迎的SSR（server side render——服务端渲染）框架，只需要几个步骤就可以搭建一个支持SSR的工程（_Nextjs_的快速搭建见Next.js入门）...

随风溜达的向日葵
今天
2
0
如何在 Linux 系统查询机器最近重启时间

在你的 Linux 或类 UNIX 系统中，你是如何查询系统上次重新启动的日期和时间？怎样显示系统关机的日期和时间？ last 命令不仅可以按照时间从近到远的顺序列出该会话的特定用户、终端和主机名...

来来来来来
今天
4
0
Redis协议是什么样的

前言 我们用过很多redis的客户端，有没有相过自己撸一个redis客户端？ 其实很简单，基于socket，监听6379端口，解析数据就可以了。 redis协议 解析数据的过程主要依赖于redis的协议了。 我们...

春哥大魔王的博客
今天
10
0

没有更多内容

加载失败，请刷新页面

加载更多

删除文章

文章删除后无法恢复，确定取消删除此文章吗？

取消
确定
自荐文章

亲，自荐的博客将通过私信方式通知管理员，优秀的博客文章审核通过后将在博客推荐列表中显示

取消
确定
推荐文章

确定推荐此文章吗？

取消
确定
推荐博主

确定推荐此博主吗？

取消
确定
13_float_left_people 13_float_left_close
返回顶部
顶部