springboot2.0+druid+mybatis 读写分离

最新推荐文章于 2022-11-24 13:30:47 发布
置顶 最新推荐文章于 2022-11-24 13:30:47 发布
阅读量4.7k 收藏 8
点赞数
分类专栏： springboot 文章标签： soringboot druid mybatis 读写分离
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kysmkj/article/details/82876307
版权

文末有demo链接

先上pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.carlton</groupId>
	<artifactId>Read-Write-database</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>Read-Write-database</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>

		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.11</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<optional>true</optional>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

配置文件：

server:
  port: 8080
  tomcat:
    uri-encoding: UTF-8
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3306/trymaster?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123123
    readSize: 1
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    driver-class-name: com.mysql.jdbc.Driver
    filters: stat,wall
    initialSize: 5
    maxActive: 20
    maxPoolPreparedStatementPerConnectionSize: 20
    maxWait: 60000
    minEvictableIdleTimeMillis: 300000
    minIdle: 5
    poolPreparedStatements: true
    testOnBorrow: false
    testOnReturn: false
    testWhileIdle: true
    timeBetweenEvictionRunsMillis: 60000
    useGlobalDataSourceStat: true
    validationQuery: SELECT 1 FROM DUAL
  slave:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3306/tryslave1?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123123
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    driver-class-name: com.mysql.jdbc.Driver
    filters: stat,wall
    initialSize: 5
    maxActive: 20
    maxPoolPreparedStatementPerConnectionSize: 20
    maxWait: 60000
    minEvictableIdleTimeMillis: 300000
    minIdle: 5
    poolPreparedStatements: true
    testOnBorrow: false
    testOnReturn: false
    testWhileIdle: true
    timeBetweenEvictionRunsMillis: 60000
    useGlobalDataSourceStat: true
    validationQuery: SELECT 1 FROM DUAL
  messages:
    encoding: UTF-8
  http:
    encoding:
      force: true
      charset: UTF-8
      enabled: true
mybatis:
  mapper-locations: com/carlton/demo/mapper/*.xml
  type-aliases-package: com.carlton.demo.entity
logging:
  level:
    com.carlton.demo.mapper: debug
  
druid:
  init:
    prefix: /druid/*
    allow: 
    deny: 192.168.1.100
    loginUsername: root
    loginPassword: 123123
    resetEnable: false

下面是切换数据源所需的几个工具类

首先用枚举类型定义数据库的主从（或者多个数据库）：DataSourceType.class

package com.carlton.demo.conf.split;

/***
 * 枚举区分读写库
 * 
 * @author Carlton
 *
 */
public enum DataSourceType {
	read("read", "从库"), write("write", "主库");
	private String type;
	private String name;

	DataSourceType(String type, String name) {
		this.type = type;
		this.name = name;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

创建一个用于切换数据源的全局变量 DataSourceContextHolder.class

package com.carlton.demo.conf.split;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import lombok.extern.slf4j.Slf4j;

/***
 * 本地线程全局变量
 * 
 * @author Carlton
 *
 */
@Slf4j
public class DataSourceContextHolder {
	static Logger log = LoggerFactory.getLogger(DataSourceContextHolder.class);

	private static final ThreadLocal<String> local = new ThreadLocal<String>();

	public static ThreadLocal<String> getLocal() {
		return local;
	}

	/**
	 * 读可能是多个库
	 */
	public static void read() {
		local.set(DataSourceType.read.getType());
	}

	/**
	 * 写只有一个库
	 */
	public static void write() {
		log.debug("writewritewrite");
		local.set(DataSourceType.write.getType());
	}

	public static String getJdbcType() {
		return local.get();
	}
}

然后是切入点和切面 DataSourceAop.class

package com.carlton.demo.conf.split;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import lombok.extern.slf4j.Slf4j;

/***
 * 切换数据源
 * 
 * @author Carlton
 *
 */
@Aspect
@Component
@Slf4j
public class DataSourceAop {

	static Logger log = LoggerFactory.getLogger(DataSourceAop.class);

	@Before("execution(* com.carlton.demo.mapper.*.select*(..)) || execution(* com.carlton.demo.mapper.*.count*(..))")
	public void setReadDataSourceType() {
		DataSourceContextHolder.read();
		log.info("dataSource切换到：Read");
	}

	@Before("execution(* com.carlton.demo.mapper.*.insert*(..)) || execution(* com.carlton.demo.mapper.*.update*(..)) || execution(* com.carlton.demo.mapper.*.delete*(..))")
	public void setWriteDataSourceType() {
		DataSourceContextHolder.write();
		log.info("dataSource切换到：write");
	}
}

 

如果配置了多个从库，即多个读库，则需要一个简单的负载均衡来确定读取哪个从库 MyAbstractRoutingDataSource.class

package com.carlton.demo.conf.split;

import java.util.concurrent.atomic.AtomicInteger;

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

/***
 * 多数据源切换，从库负载均衡
 * 
 * @author Carlton
 *
 */
public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {

	private final int dataSourceNumber;
	private AtomicInteger count = new AtomicInteger(0);

	public MyAbstractRoutingDataSource(int dataSourceNumber) {
		this.dataSourceNumber = dataSourceNumber;
	}

	@Override
	protected Object determineCurrentLookupKey() {
		String typeKey = DataSourceContextHolder.getJdbcType();
		if (typeKey.equals(DataSourceType.write.getType()))
			return DataSourceType.write.getType();
		// 读 简单负载均衡
		int number = count.getAndAdd(1);
		int lookupKey = number % dataSourceNumber;
		Integer i = lookupKey;
		return i;
	}

}

然后是 druid 数据库配置类：DataSourceConfiguration.class

package com.carlton.demo.conf.split;

import java.util.ArrayList;
import java.util.List;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;

import lombok.extern.slf4j.Slf4j;

/**
 * 数据库配置
 */
@Slf4j
@Configuration
public class DataSourceConfiguration {

	protected Logger log = LoggerFactory.getLogger(DataSourceConfiguration.class);

	@Value("${spring.datasource.type}")
	private Class<? extends DataSource> dataSourceType;
	@Value("${druid.init.prefix}")
	private String prefix;
	@Value("${druid.init.allow}")
	private String allow;
	@Value("${druid.init.deny}")
	private String deny;
	@Value("${druid.init.loginUsername}")
	private String loginUsername;
	@Value("${druid.init.loginPassword}")
	private String loginPassword;
	@Value("${druid.init.resetEnable}")
	private String resetEnable;

	@Bean
	public ServletRegistrationBean druidServlet() {
		log.info("init Druid Servlet Configuration ");
		ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), prefix);
		// IP白名单
		servletRegistrationBean.addInitParameter("allow", allow);
		// IP黑名单(共同存在时，deny优先于allow)
		servletRegistrationBean.addInitParameter("deny", deny);
		// 控制台管理用户
		servletRegistrationBean.addInitParameter("loginUsername", loginUsername);
		servletRegistrationBean.addInitParameter("loginPassword", loginPassword);
		// 是否能够重置数据 禁用HTML页面上的“Reset All”功能
		servletRegistrationBean.addInitParameter("resetEnable", resetEnable);
		return servletRegistrationBean;

	}

	@Bean
	public FilterRegistrationBean filterRegistrationBean() {
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
		filterRegistrationBean.addUrlPatterns("/*");
		filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico," + prefix);
		return filterRegistrationBean;
	}

	@Bean(name = "writeDataSource", destroyMethod = "close", initMethod = "init")
	@Primary
	@ConfigurationProperties(prefix = "spring.datasource")
	public DataSource writeDataSource() {
		log.info("-------------------- writeDataSource init ---------------------");
		return DataSourceBuilder.create().type(dataSourceType).build();
	}

	/**
	 * 有多少个从库就要配置多少个
	 * 
	 * @return
	 */
	@Bean(name = "readDataSource1")
	@ConfigurationProperties(prefix = "spring.slave")
	public DataSource readDataSourceOne() {
		log.info("-------------------- readDataSourceOne init ---------------------");
		return DataSourceBuilder.create().type(dataSourceType).build();
	}

	@Bean("readDataSources")
	public List<DataSource> readDataSources() {
		List<DataSource> dataSources = new ArrayList<>();
		dataSources.add(readDataSourceOne());
		return dataSources;
	}
}

最后是配置事务管理 DataSourceTransactionManager.class

package com.carlton.demo.conf.split;

import javax.annotation.Resource;
import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import lombok.extern.slf4j.Slf4j;

/***
 * 自定义事务
 * 
 * @author Carlton
 *
 */
@Configuration
@EnableTransactionManagement
@Slf4j
public class DataSourceTransactionManager extends DataSourceTransactionManagerAutoConfiguration {

	static Logger log = LoggerFactory.getLogger(DataSourceTransactionManager.class);

	@Resource(name = "writeDataSource")
	private DataSource dataSource;

	/**
	 * 自定义事务
	 * MyBatis自动参与到spring事务管理中，无需额外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的数据源与DataSourceTransactionManager引用的数据源一致即可，否则事务管理会不起作用。
	 * 
	 * @return
	 */
	@Bean(name = "transactionManager")
	public org.springframework.jdbc.datasource.DataSourceTransactionManager transactionManagers() {
		log.info("-------------------- transactionManager init ---------------------");
		return new org.springframework.jdbc.datasource.DataSourceTransactionManager(dataSource);
	}
}

到这里，读写分离主要步骤都已经完成，下面就是建表写测试代码：

在两个库中新建两张一样的表，user表，实体类如下：

package com.carlton.demo.entity;

public class User {
    private Integer id;

    private String name;

    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

-----mapper 类 和 xml ----省略，

再然后新建controller和service，写测试代码。

注意要使事务管理生效，需在相应service方法上加上@Transactional 注解

完整demo：

https://gitee.com/carltonq/read_write_separation_demo.git

矿泉
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
springboot+mybatis+druid+redis实现数据库读写分离和缓存
04-12
springboot+mybatis+druid+redis实现数据库读写分离和缓存
druid+mybatis 多数据源及读写分离的处理
S&Y_shhy_QQ_1127833416
02-19 2803
现如今复杂的业务系统，一般会将数据库按业务拆开，比如产品系统的数据库放在product db中，订单系统的数据库放在order db中...，然后，如果量大了，可能每个库还要考虑做读、写分离，以进一步提高系统性能，下面就来看看如何处理： 核心思路：配置多个数据源，然后利用RoutingDataSource结合AOP来动态切不同的库。 存在一下几个问题： 1、配置文件中，多数据源的配置节...
主从复制 & 读写分离
lwj_07的博客
10-03 2101
配置好之后，我们从日志中就会发现我们的项目能够启动成功了：
实现读写分离SpringBoot+MyBatis+Druid
牧风人的博客
11-16 1650
实现读写分离 SpringBoot+MyBatis+Druid 1.读写分离概念理解 读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行，至于谁来做选择数据库这件事儿，无非两个，要么中间件帮我们做，要么程序自己做。因此，一般来讲，读写分离有两种实现方式。第一种是依靠中间件（比如：MyCat），也就是说应用程序连接到中间件，中间件帮我们做SQL分离；第二种是应用程序自己去做分离。这里我们选择程序自己来做，主要是利用Spring提供的路由数据源，以及AOP。然而，应用程序层面去做读写分离最大的弱点
MySQL系列文章 怎么去自定义读写分离
weixin_44994494的博客
11-24 286
基于 druid 连接池自定义配置做一主多从的读写分离配置，做读写分离的前提是数据库集群已做好主从同步配置。这里直接把配置的数据源信息读取到，由 druid 创建 DataSource 数据源，托管数据库连接。每个连接的建立都保存在当前线程中，这里把 DataSource 分为 Master 和 Slave，在后面配置的 AOP 拦截可以选择不同的数据源。但也有特例，需要强制选择 Master 库，所以配置了根据 @Master 注解主动选择数据源。这里配置 druid 监控平台。配置 druid 监控。
SpringBoot实现MySQL读写分离
KIMTOU的博客
11-26 6133
在高并发下，需要对应用进行读写分离，配置多数据源，即写操作走主库，读操作则走从库，主从数据库负责各自的读和写，缓解了锁的争用，提高了读取性能。 实现读写分离有多种方式，如使用中间件MyCat、Sharding-JDBC等，这里我们使用Aop的方式在代码层面实现读写分离。 实现原理 实现读写分离，首先要对Mysql做主从复制，即搭建一个主数据库，以及一个或多个从数据库。 具体实现主从复制，可参照前一篇博客《基于docker配置MySQL主从复制》 使用Aop的方式，当调用业务层方法前，判断请求是否是只读操作
springboot+mybatis+mysql实现读写分离.zip
10-23
springboot+mybatis+mysql实现读写分离 先在建好mysql主从数据库的配置，然后在代码中根据读写分离或强制读取master数据库中的数据 mysql数据库设置主从，参考： ...
springboot+mybatis3+druid+postgresql
05-08
springboot+druid+mybatis+postgresql框架搭建，使用mybatis-generator自动生成pojo+mapper+dao
Springboot+mybatis+druid多数据源配置（oracle+mybatis）
07-29
技术架构：springboot2.0 + mybatis + druid, 数据库：Oracle，Mysql 数据库分离调试，针对不同数据库情况
基于springboot2.0+freemarker+thymeleaf+mybatis+druid实现了支付宝，微信支付功能
06-24
springboot-weixin-alipay是基于(springboot2.0+freemarker+thymeleaf+mybatis+druid)实现了支付宝，微信支付功能，用户列表,商品列表,选择购买,提交订单,扫码支付,订单表单提交支付的通用商城项目.
springBoot+mybatis读写分离（AOP）
04-02
springBoot+mybatis+AOP实现读写分离，在代码层面直接实现，无需任何插件，简单易懂，非常适合作为解决数据库并发大的解决方案
springmvc-mybatis 整合druid多数据源配置读写实现读写分离，windows上mysql主从复制
10-27
springmvc mybatis 整合druid多数据源配置 实现简单的读写分离，windows上mysql主从复制
SpringBoot+MybatisPlus+Druid （超简单超详细）实现读写分离
imHanweihu的博客
04-30 6523
说明： 1. 本文是本地运行了两个mysql服务，可参考我上一篇文章配置（不同ip同理） windows mysql8：（超详细）同ip运行两个mysql服务 2. 数据库的主从同步，可参考我的另一篇文章 Windows mysql8：（超详细）主从数据与结构同步配置 开始： 使用开源中国发布的优秀框架 SpringBoot 多数据源快速启动器dynamic-da...
springboot druid 读写分离
追求卓越，精彩人生
11-22 3177
springboot druid 读写分离 一、修改yml文件 spring: datasource: druid: master: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://${MASTER_DB_HOST}:3306/test?useUnicode=true&...
druid mysql读写分离_Spring Boot + Mybatis + Druid 实现MySQL一主多从读写分离
weixin_35817939的博客
01-19 601
Spring Boot 读写分离实现原理实现方式主要是通过扩展Spring AbstractRoutingDataSource这个类充当DataSource路由中介，在运行当中根据自定义KEY值动态切换正真的DataSource。具体实现创建测试库、表：create database `mytest_db`;CREATE TABLE `t_user` (`id` int(11) NOT NULL ...
SpringBoot2整合MyBatis实现读写分离
程序带给我们的思考
11-02 695
一、CentOS7搭建MariaDB主从环境 CentOS7搭建MariaDB主从 二、新建SpringBoot项目 目录结构如下： 三、pom.xml文件如下 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmln...
Druid配置详解，新手必须读
热门推荐
Lailai Monkey的博客
04-27 2万+
什么是Druid Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。 Druid也是配置最简单使用最方便的一种连接池。 Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、SQL性能收集、SQL注入检查、SQL...
druid mysql读写分离_Sharding-JDBC + MyBatis-Plus + Druid 实现读写分离
weixin_35618933的博客
02-06 317
一、概述1，当业务数据越来越大时，就需要进行分库分表，而 Sharding-JDBC 框架就是能完整的实现分库分表、读写分离和分布式主键等功能2，此处实现读写分离功能。因为是测试，就在同一个 MySQL中创建两个数据库来模拟。3，Sharding-JDBC 的配置方式四种：Java，YAML，Spring命名空间和Spring Boot Starter。此处只讲 YAML 和 XML 方式。二、数...
sharding+druid 读写分离
很努力的恺恺
07-28 1283
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。 ShardingSphere定位为关系型数据库中间件，旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。 它与NoSQL和
springboot+druid+mybatis plus整合demo
最新发布
01-23
在pom.xml中添加Spring Boot、Druid和MyBatis Plus的相关依赖。 接下来，在application.yml或application.properties文件中配置数据库连接信息和Druid的相关配置。包括数据库的URL、用户名、密码以及Druid的一些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值