引言

1、读写分离：可以通过Spring提供的AbstractRoutingDataSource类，重写determineCurrentLookupKey方法，实现动态切换数据源的功能；读写分离可以有效减轻写库的压力，又可以把查询数据的请求分发到不同读库；

2、写数据库：当调用insert、update、delete及一些实时数据用到的库；

3、读数据库：当调用select查询数据用到的库；

4、JaveWeb工程通过AbstractRoutingDataSource类实现读写分离；

一、jdbc.properties文件配置读写数据源

datasource.type=mysql

datasource.driverClassName=com.mysql.jdbc.Driver

datasource.username=root

#写库w.datasource.url=jdbc\:mysql\://127.0.0.1\:3306/ddt?characterEncoding\=utf-8w.datasource.password=write123

#读库r.datasource.url=jdbc\:mysql\://IP\:3306/ddt?characterEncoding\=utf-8r.datasource.password=read123

#连接池配置

c3p0.acquireIncrement=3

c3p0.acquireRetryAttempts=10

c3p0.acquireRetryDelay=1000

c3p0.initialPoolSize=20

c3p0.idleConnectionTestPeriod=3600

c3p0.testConnectionOnCheckout=true

c3p0.minPoolSize=10

c3p0.maxPoolSize=80

c3p0.maxStatements=100

c3p0.numHelperThreads=10

c3p0.maxIdleTime=10800

 二、application.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" xmlns:jee="http://www.springframework.org/schema/jee"

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

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"

xmlns:task="http://www.springframework.org/schema/task"

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

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

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

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/jee

http://www.springframework.org/schema/jee/spring-jee-3.0.xsd

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

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

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

http://www.springframework.org/schema/task

http://www.springframework.org/schema/task/spring-task-3.0.xsd">    <!-- 使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入    -->

<context:component-scan base-package="com.eb3">

<context:include-filter type="annotation"            expression="org.springframework.stereotype.Service" />

<context:exclude-filter type="annotation"            expression="org.springframework.stereotype.Controller" />

</context:component-scan>

<bean class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer" >

<property name="ignoreResourceNotFound" value="true" />

<property name="properties" ref="configProperties" />

</bean>

<bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">

<property name="locations">

<list>

<value>classpath*:jdbc.properties</value>

</list>

</property>

</bean>

<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 定义Hibernate读数据源 -->

<bean id="dataSourceRead" class="com.mchange.v2.c3p0.ComboPooledDataSource"

destroy-method="close">

<property name="driverClass">

<value>${datasource.driverClassName}</value>

</property>

<property name="jdbcUrl">

<value>${r.datasource.url}</value>

</property>

<property name="user">

<value>${datasource.username}</value>

</property>

<property name="password">

<value>${r.datasource.password}</value>

</property>

<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。-->

<property name="acquireIncrement">

<value>${c3p0.acquireIncrement}</value>

</property>

<!--定义在从数据库获取新连接失败后重复尝试的次数。-->

<property name="acquireRetryAttempts">

<value>${c3p0.acquireRetryAttempts}</value>

</property>

<!--两次连接中间隔时间，单位毫秒。-->

<property name="acquireRetryDelay">

<value>${c3p0.acquireRetryDelay}</value>

</property>

<property name="initialPoolSize">

<value>${c3p0.initialPoolSize}</value>

</property>

<property name="testConnectionOnCheckout">

<value>${c3p0.testConnectionOnCheckout}</value>

</property>

<property name="minPoolSize">

<value>${c3p0.minPoolSize}</value>

</property>

<property name="maxPoolSize">

<value>${c3p0.maxPoolSize}</value>

</property>

<property name="maxIdleTime">

<value>${c3p0.maxIdleTime}</value>

</property>

<property name="idleConnectionTestPeriod">

<value>${c3p0.idleConnectionTestPeriod}</value>

</property>

<property name="maxStatements">

<value>${c3p0.maxStatements}</value>

</property>

<property name="numHelperThreads">

<value>${c3p0.numHelperThreads}</value>

</property>

</bean>

<!-- 定义Hibernate写数据源 -->

<bean id="dataSourceWrite" class="com.mchange.v2.c3p0.ComboPooledDataSource"

destroy-method="close">

<property name="driverClass">

<value>${datasource.driverClassName}</value>

</property>

<property name="jdbcUrl">

<value>${w.datasource.url}</value>

</property>

<property name="user">

<value>${datasource.username}</value>

</property>

<property name="password">

<value>${w.datasource.password}</value>

</property>

<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。-->

<property name="acquireIncrement">

<value>${c3p0.acquireIncrement}</value>

</property>

<!--定义在从数据库获取新连接失败后重复尝试的次数。-->

<property name="acquireRetryAttempts">

<value>${c3p0.acquireRetryAttempts}</value>

</property>

<!--两次连接中间隔时间，单位毫秒。-->

<property name="acquireRetryDelay">

<value>${c3p0.acquireRetryDelay}</value>

</property>

<property name="initialPoolSize">

<value>${c3p0.initialPoolSize}</value>

</property>

<property name="testConnectionOnCheckout">

<value>${c3p0.testConnectionOnCheckout}</value>

</property>

<property name="minPoolSize">

<value>${c3p0.minPoolSize}</value>

</property>

<property name="maxPoolSize">

<value>${c3p0.maxPoolSize}</value>

</property>

<property name="maxIdleTime">

<value>${c3p0.maxIdleTime}</value>

</property>

<property name="idleConnectionTestPeriod">

<value>${c3p0.idleConnectionTestPeriod}</value>

</property>

<property name="maxStatements">

<value>${c3p0.maxStatements}</value>

</property>

<property name="numHelperThreads">

<value>${c3p0.numHelperThreads}</value>

</property>

</bean>

<!-- 动态数据源 -->

<bean id="dynamicDataSource" class="com.eb3.ddt.DynamicDataSource">

<!-- 通过key-value关联数据源 -->

<property name="targetDataSources">

<map>

<entry value-ref="dataSourceWrite" key="dataSourceWrite"></entry>

<entry value-ref="dataSourceRead" key="dataSourceRead"></entry>

</map>

</property>

<property name="defaultTargetDataSource" ref="dataSourceWrite" />

</bean>

<!-- 设置sessionFactory -->

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<!--  依赖注入数据源，注入正是上文定义的dataSource -->

<property name="dataSource" ref="dynamicDataSource" />

<property name="packagesToScan" value="com.eb3.ddt.pojo,com.eb3.loan.pojo"/>

<!--定义Hibernate的SessionFactory的属性 -->

<property name="hibernateProperties">

<props>

<!--  指定Hibernate的连接方言-->

<prop key="hibernate.dialect">

${hibernate.dialect}

</prop>

<prop key="hibernate.connection.autocommit">${hibernate.connection.autocommit}</prop>

<!-- 制定Hibernate是否打印SQL语句 -->

<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>

<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>

<!-- 设create(启动创建),create-drop(启动创建,退出删除),update(启动更新),validate(启动验证) -->

<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>

<prop key="connection.characterEncoding">utf-8</prop>

<!-- 设置二级缓存 -->

<prop key="hibernate.cache.user_query_cache">${hibernate.cache.user_query_cache}</prop>

<prop key="hibernate.user_second_level_cache">${hibernate.user_second_level_cache}</prop>

<prop key="hibernate.cache.provider_class">${hibernate.cache.class}</prop>

<prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.ehcache_config_file}</prop>

</props>

</property>

</bean>

<!-- 事务管理器配置,单数据源事务 -->

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="save*"  propagation="REQUIRED" rollback-for="Exception"/>

<tx:method name="add*"   propagation="REQUIRED" rollback-for="Exception"/>

<tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/>

<tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>

<tx:method name="merge*"  isolation="READ_COMMITTED" propagation="REQUIRED" rollback-for="Exception"/>

<tx:method name="get*" read-only="true"/>

<tx:method name="find*" read-only="true"/>

<tx:method name="list*" read-only="true"/>

<tx:method name="select*" read-only="true"/>

<tx:method name="*" propagation="REQUIRED"  />

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="interceptorPointCuts"       expression="execution(* com.eb3.*.service.*.*(..))" />

<aop:advisor advice-ref="txAdvice"            pointcut-ref="interceptorPointCuts" />

</aop:config>

<aop:aspectj-autoproxy proxy-target-class="true" />

<!-- 定时器配置 task:scheduler@pool-size调度线程池的大小，调度线程在被调度任务完成前不会空闲 task:executor/@pool-size：可以指定执行线程池的初始大小、最大大小

task:executor/@queue-capacity：等待执行的任务队列的容量 task:executor/@rejection-policy：当等待队已满时的策略，分为丢弃、由任务执行器直接运行等方式

@Async 异步任务时 task任务执行线程数 task:scheduler 和 task:executor 两个线程池同样起作用 没有异步注解时

task任务执行线程数只受task:scheduler的线程池大小影响 -->

<!-- 声明一个具有10个线程的池，每一个对象将获取同样的运行机会 -->

<task:scheduler id="scheduler" pool-size="10" />

<task:executor id="executor" keep-alive="3600" pool-size="100-300" queue-capacity="500" rejection-policy="CALLER_RUNS" />

<task:annotation-driven executor="executor" scheduler="scheduler" />

</beans>

三、继承AbstractRoutingDataSource类的动态数据源类DynamicDataSource

package com.eb3.ddt;

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

public class DynamicDataSource extends AbstractRoutingDataSource {

/**

* 重写determineCurrentLookupKey方法

*/

@Override

protected Object determineCurrentLookupKey() {

Object obj = DBHelper.getDbType();

return obj;

}

}

四、DBHelper工具类

package com.eb3.ddt;

import org.apache.commons.lang.StringUtils;

public class DBHelper {

private static ThreadLocal<String> dbContext = new ThreadLocal<String>();

// 写数据源标识

public final static String DB_WRITE = "dataSourceWrite";

// 读数据源标识

public final static String DB_READ = "dataSourceRead";

/**

* 获取数据源类型，即是写数据源，还是读数据源

*

* @return

*/

public static String getDbType() {

String db_type = dbContext.get();

if (StringUtils.isEmpty(db_type)) {

// 默认是写数据源

db_type = DB_WRITE;

}

return db_type;

}

/**

* 设置该线程的数据源类型

*

* @param str

*/

public static void setDbType(String str) {

dbContext.set(str);

}

}

五、服务层调用

/*@Aspect 此注解会影响数据源切换，运行代码得知不加的话会先执行DynamicDataSource里的determineCurrentLookupKey方法，后执行Service层里DBHelper.setDbType()方法，导致数据源切换失败！*/

@Aspect

@Component("userService")public class UserServiceImpl extends BaseServiceImpl<User, User, Integer> implements UserService {

@Resource

private UserDao userDao;

@Override

protected BaseDao<User, Integer> getDao() {

return this.userDao;

}

@Override

public void save(User user) {

DBHelper.setDbType(DBHelper.DB_WRITE); // 写库 (向数据库中写)

this.userDao.save(user);

}

@Override

public User findByUserName(String username) {

DBHelper.setDbType(DBHelper.DB_READ); // 读库 (从数据库中向外读)

List<User> userList = this.userDao.findBy("username", username);

return CollectionUtils.isNotEmpty(userList) ? userList.get(0) : null;

}

}

Java实现数据库的读写分离的更多相关文章

  1. Mycat - 实现数据库的读写分离与高可用

    前言 开心一刻 上语文课,不小心睡着了,坐在边上的同桌突然叫醒了我,并小声说道:“读课文第三段”.我立马起身大声读了起来.正在黑板写字的老师吓了一跳,老师郁闷的看着我,问道:“同学有什么问题吗?”,我 ...

  2. 如何轻松实现MySQL数据库的读写分离和负载均衡？

    配置好了 Mysql 的主从复制结构后,我们希望实现读写分离,把读操作分散到从服务器中,并且对多个从服务器能实现负载均衡.读写分离和负载均衡是 Mysql 集群的基础需求,MaxScale 就可以帮着 ...

  3. 利用oneproxy部署mysql数据库的读写分离

    实验系统:CentOS 6.6_x86_64 实验前提:防火墙和selinux都关闭 实验说明:本实验共有4台主机,IP分配如拓扑 实验软件:mariadb-10.0.20 oneproxy-rhel ...

  4. MySQL搭建主从数据库 实现读写分离

    首先声明,实际生产中,网站为了提高用户体验,性能等,将数据库实现读写分离是有必要的,我们让主数据库去写入数据,然后当用户查询的时候,然后在从数据库读取数据,故能减轻数据库的压力,实现良好的用户体验! ...

  5. 基于 EntityFramework 的数据库主从读写分离服务插件

    基于 EntityFramework 的数据库主从读写分离服务插件 1. 版本信息和源码 1.1 版本信息 v1.01 beta(2015-04-07),基于 EF 6.1 开发,支持 EF 6.1 ...

  6. 基于 EntityFramework 的数据库主从读写分离架构 - 目录

    基于 EntityFramework 的数据库主从读写分离架构       回到目录,完整代码请查看(https://github.com/cjw0511/NDF.Infrastructure)中的目 ...

  7. 基于 EntityFramework 的数据库主从读写分离架构（1） - 原理概述和基本功能实现

        回到目录,完整代码请查看(https://github.com/cjw0511/NDF.Infrastructure)中的目录:      src\ NDF.Data.EntityFramew ...

  8. springboot+mybatis实现数据库的读写分离

    介绍 随着业务的发展,除了拆分业务模块外,数据库的读写分离也是常见的优化手段.方案使用了AbstractRoutingDataSource和mybatis plugin来动态的选择数据源选择这个方案的 ...

  9. 基于amoeba实现mysql数据库的读写分离/负载均衡

    一.Amoeba的简述:[来自百度百科]      Amoeba是一个以MySQL为底层数据存储,并对应用提供MySQL协议接口的proxy.它集中地响应应用的请求,依据用户事先设置的规则,将SQL请 ...

随机推荐

  1. HDFS集群数据不均衡处理

    一.概述 公司使用是自己搭建的hadoop集群,版本2.7.3,最近发现出现了hdfs数据存储不均衡的现象,其中有一个datanode使用了65%,而有一个只使用了20%.hadoop集群使用的时间长 ...

  2. php处理文件的思考(去除空行、每行多余字符)

    1.去除空行 <?php $str = file_get_contents('a.txt'); $str = explode(PHP_EOL, $str); //分割为数组,每行为一个数组元素 ...

  3. sass重构响应式unofficial‘s博客轻松适应移动端

    前言: 刚刚玩博客园几天时间,发现挺不错的,对于我这个懒人又是一个爱折腾的人来说挺不错的,对于上班玩电脑,下班玩手机的用户来说,博客园中我的博客有一点给我的感觉不是很友好,电脑端看起来很美观的一个页面 ...

  4. Django学习（6）配置静态文件

      本文将详细讲述如何在Django中配置静态文件,如图片(images),JavaScript,CSS等.   我们将要实现的网页如下: 当按下按钮"Change Text"时, ...

  5. JavaScript字符串常用方法

    toUpperCase():把一个字符串全部变为大写 toLowerCase():把一个字符串全部变为小写 indexOf():会搜索制定字符串出现的位置,有返回索引,没有返回-1 substring ...

  6. 【Quartz】问题记录注意事项【四】

    记录一:queartz 在同时启动多个任务是,触发器名称不能设置一致,不然第二次启动会不成功 记录二:quartz 在使用任务与触发器分离写法时,任务必须要带(.StoreDurably()) IJo ...

  7. UDP服务器/客户端代码示例

    UDP服务器代码: #include <errno.h> #include <string.h> #include <stdlib.h> #include < ...

  8. Centos 7.x 安装 Docker-ce

    Centos 下安装 Docker-ce CentOS 7.0, CentOS 7.2: cat > /etc/yum.repos.d/docker-main.repo << -'E ...

  9. 怎么在ReactNative里面使用Typescript

    今天来搞一搞怎么搭建一个可以使用Typescript的ReactNative环境好吧,一句废话不多说,直接开始好吧 1.全局安装create-react-native-app yarn global ...

  10. 用 JS 写 （轮播图 / 选项卡 / 滑动门）

    页面中经常会用到各式各样的轮播图,今天贺贺为大家介绍一种常用的方法,对于JS我们需要举一反三,一种方法可以对多个轮播样式进行渲染. <head> <meta charset=&quo ...