首页
博客
专栏·视频
下载
论坛
问答
代码
直播
能力认证
高校

会员中心

动态

消息

创作中心

02-下篇-SpringBoot下MySQL的读写分离

dusuanyun 2018-07-16 09:03:30 3095 收藏 3

分类专栏：应用配置文章标签： SpringBoot MySQL读写分离 SpringDataJPA AOP

版权

前言：关于MySQL读写主从实现，分两步：

第一步，需要现有主从的环境，利用docker快速实现; -----上篇

第二步，利用已有的环境进行JavaEE的Web项目配置。 -----下篇，基于SpringBoot的SpringDataJpa的实现！即本文

环境：

SpringBoot：2.0.3 DB:MySQL5.7.20 主从模式

持久化框架：SpringDataJpa

1.多数据源的配置application.yml:

#####MySQL数据库的主从配置开始#####
mysql:
datasource:
readSize: 1 #读库个数,可以有多个
type: com.alibaba.druid.pool.DruidDataSource
write:
url: jdbc:mysql://192.168.1.121:3306/db_frms?useUnicode=true&characterEncoding=utf-8
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
minIdle: 5
maxActive: 100
initialSize: 10
maxWait: 60000
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 50
removeAbandoned: true
filters: stat
read01:
url: jdbc:mysql://192.168.1.121:3307/db_frms?useUnicode=true&characterEncoding=utf-8
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
minIdle: 5
maxActive: 100
initialSize: 10
maxWait: 60000
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 50
removeAbandoned: true
filters: stat
# read02: #因为我只用docker配置了一个slave，所以没有第二个slave，故这段配置注释掉！
# url: jdbc:mysql://192.168.1.121:3308/test_02?useUnicode=true&characterEncoding=utf-8
# username: root
# password: root
# driver-class-name: com.mysql.jdbc.Driver
# minIdle: 5
# maxActive: 100
# initialSize: 10
# maxWait: 60000
# timeBetweenEvictionRunsMillis: 60000
# minEvictableIdleTimeMillis: 300000
# validationQuery: select 'x'
# testWhileIdle: true
# testOnBorrow: false
# testOnReturn: false
# poolPreparedStatements: true
# maxPoolPreparedStatementPerConnectionSize: 50
# removeAbandoned: true
# filters: stat
#####MySQL数据库的主从配置结束#####

2.定义数据库的类型枚举类DataSourceType：

package com.ddbin.frms.config.datasource;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* Description:数据源类型的枚举类
*
* @param
* @author dbdu
* @date 18-7-14 上午8:05
*/
@Getter
@AllArgsConstructor
public enum DataSourceType {
read("read", "从库"), write("write", "主库");
/**
* Description:类型，是读还是写
*
* @author dbdu
* @date 18-7-14 上午8:14
*/
private String type;
/**
* Description:数据源的名称
*
* @author dbdu
* @date 18-7-14 上午8:15
*/
private String name;
}

要注意的是：枚举实例小写，大写会报错！！

read("read", "从库"), write("write", "主库");

3.多个数据源的实例化配置类DataSourceConfiguration：

有多少个数据源，就配置多少个对应的Bean。

package com.ddbin.frms.config.datasource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
/**
* Description:MySQL读写主从数据库源配置
*
* @param
* @author dbdu
* @date 18-7-14 上午7:51
* @return
*/
@Configuration
@Slf4j
public class DataSourceConfiguration {
@Value("${mysql.datasource.type}")
private Class<? extends DataSource> dataSourceType;
/**
* 写库数据源配置
*
* @return
*/
@Bean(name = "writeDataSource")
@Primary
@ConfigurationProperties(prefix = "mysql.datasource.write")
public DataSource writeDataSource() {
log.info("writeDataSource init ...");
return DataSourceBuilder.create().type(dataSourceType).build();
}
/**
* 有多少个从库就要配置多少个
*
* @return
*/
@Bean(name = "readDataSource01")
@ConfigurationProperties(prefix = "mysql.datasource.read01")
public DataSource readDataSourceOne() {
log.info("read01 DataSourceOne init ...");
return DataSourceBuilder.create().type(dataSourceType).build();
}
// @Bean(name = "readDataSource02")
// @ConfigurationProperties(prefix = "mysql.datasource.read02")
// public DataSource readDataSourceTwo() {
// log.info("read02 DataSourceTwo init ...");
// return DataSourceBuilder.create().type(dataSourceType).build();
// }
}

4.配置数据源的切换类DataSourceContextHolder

设置这个类的对应的read和write，就被内部用来读取不同的数据源

package com.ddbin.frms.config.datasource;
import lombok.extern.slf4j.Slf4j;
/**
* Description:本地线程，数据源上下文切换
*
* @author dbdu
* @date 18-7-14 上午8:17
*/
@Slf4j
public class DataSourceContextHolder {
//线程本地环境
private static final ThreadLocal<String> local = new ThreadLocal<String>();
public static ThreadLocal<String> getLocal() {
return local;
}
/**
* 读库
*/
public static void setRead() {
local.set(DataSourceType.read.getType());
//log.info("数据库切换到READ库...");
}
/**
* 写库
*/
public static void setWrite() {
local.set(DataSourceType.write.getType());
// log.info("数据库切换到WRITE库...");
}
public static String getReadOrWrite() {
return local.get();
}
public static void clear() {
local.remove();
}
}

5.数据源的代理路由配置DatasourceAgentConfig---请读者特别注意这个类，网上很多说的都是mybatis框架的，这里是SpringDataJpa框架对应的关联代理数据源路由的配置，此处配置出错就会失败！

package com.ddbin.frms.config.datasource;
import com.ddbin.frms.FrmsApplication;
import com.ddbin.frms.util.SpringContextsUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Configuration
@AutoConfigureAfter(DataSourceConfiguration.class)
@EnableTransactionManagement(order = 10)
@Slf4j
public class DatasourceAgentConfig {
@Value("${mysql.datasource.readSize}")
private String readDataSourceSize;
private AbstractRoutingDataSource proxy;
@Autowired
@Qualifier("writeDataSource")
private DataSource writeDataSource;
@Autowired
@Qualifier("readDataSource01")
private DataSource readDataSource01;
// @Autowired
// @Qualifier("readDataSource02")
// private DataSource readDataSource02;
/**
* 把所有数据库都放在路由中
* 重点是roundRobinDataSouceProxy()方法，它把所有的数据库源交给AbstractRoutingDataSource类，
* 并由它的determineCurrentLookupKey()进行决定数据源的选择，其中读库进行了简单的负载均衡（轮询）。
*
* @return
*/
@Bean(name = "roundRobinDataSouceProxy")
public AbstractRoutingDataSource roundRobinDataSouceProxy() {
/**
* Description:把所有数据库都放在targetDataSources中,注意key值要和determineCurrentLookupKey()中代码写的一至，
* 否则切换数据源时找不到正确的数据源
*/
Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
targetDataSources.put(DataSourceType.write.getType(), writeDataSource);
targetDataSources.put(DataSourceType.read.getType() + "1", readDataSource01);
//targetDataSources.put(DataSourceType.read.getType() + "2", readDataSource02);
//路由类，寻找对应的数据源
final int readSize = Integer.parseInt(readDataSourceSize);
MyAbstractRoutingDataSource proxy = new MyAbstractRoutingDataSource(readSize);
proxy.setTargetDataSources(targetDataSources);
//默认库
proxy.setDefaultTargetDataSource(writeDataSource);
this.proxy = proxy;
return proxy;
}
/**
* Description:要特别注意，这个Bean是配置读写分离成败的关键，
*
* @param []
* @return org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
* @author dbdu
* @date 18-7-15 下午5:08
*/
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
vendorAdapter.setDatabase(Database.MYSQL);
//是否生成表
vendorAdapter.setGenerateDdl(true);
//是否显示sql语句
vendorAdapter.setShowSql(true);
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
factory.setJpaVendorAdapter(vendorAdapter);
//配置扫描的位置
factory.setPackagesToScan(FrmsApplication.class.getPackage().getName());
// 这个数据源设置为代理的数据源，----这是关键性配置！！！
factory.setDataSource(proxy);
return factory;
}
@Bean(name = "transactionManager")
public MyJpaTransactionManager transactionManager() {
MyJpaTransactionManager transactionManager = new MyJpaTransactionManager();
transactionManager.setDataSource(proxy);
transactionManager.setEntityManagerFactory((EntityManagerFactory) SpringContextsUtil.getBean("entityManagerFactory"));
return transactionManager;
}
}

说明：entityManagerFactory是关键配置，网上很多说的都是mybatis的方式sqlSessionFactory的Bean会关联代理数据源，

SpringDataJpa的方式使用entityManagerFactory来关联代理数据源，否则读写分离是假的，这个可以通过主从库数据不同查询可以知道！

/**

* Description:要特别注意，这个Bean是配置读写分离成败的关键，

* @param []

* @return org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean

* @author dbdu

* @date 18-7-15 下午5:08

@Bean

public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();

vendorAdapter.setDatabase(Database.MYSQL);

//是否生成表

vendorAdapter.setGenerateDdl(true);

//是否显示sql语句

vendorAdapter.setShowSql(true);

LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();

factory.setJpaVendorAdapter(vendorAdapter);

//配置扫描的位置

factory.setPackagesToScan(FrmsApplication.class.getPackage().getName());

// 这个数据源设置为代理的数据源，----这是关键性配置！！！

factory.setDataSource(proxy);

return factory;

}

6.自定义的路由数据源及事务管理器的子类：

package com.ddbin.frms.config.datasource;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
* Description: 抽象数据源的路由的子类
* Created at:2018-07-15 13:37,
* by dbdu
*/
@Getter
@Setter
@AllArgsConstructor
public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {
/**
* Description:读库的数量，可以用来实现负载均衡
*/
private int readSize;
//private AtomicLong count = new AtomicLong(0);
/**
* 这是AbstractRoutingDataSource类中的一个抽象方法，
* 而它的返回值是你所要用的数据源dataSource的key值，有了这个key值，
* targetDataSources就从中取出对应的DataSource，如果找不到，就用配置默认的数据源。
*/
@Override
protected Object determineCurrentLookupKey() {
String typeKey = DataSourceContextHolder.getReadOrWrite();
if (typeKey == null || typeKey.equals(DataSourceType.write.getType())) {
System.err.println("使用数据库write.............");
return DataSourceType.write.getType();
} else {
//读库，简单负载均衡
// int number = count.getAndAdd(1);
// int lookupKey = number % readSize;
// System.err.println("使用数据库read-" + (lookupKey + 1));
// return DataSourceType.read.getType() + (lookupKey + 1);
return DataSourceType.read.getType() + "1";
}
}
}

package com.ddbin.frms.config.datasource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.DefaultTransactionStatus;
@SuppressWarnings("serial")
@Slf4j
public class MyJpaTransactionManager extends JpaTransactionManager {
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
if (definition.isReadOnly()) {
DataSourceContextHolder.setRead();
} else {
DataSourceContextHolder.setWrite();
}
log.info("jpa-transaction:begin-----now dataSource is [" + DataSourceContextHolder.getReadOrWrite() + "]");
super.doBegin(transaction, definition);
}
@Override
protected void doCommit(DefaultTransactionStatus status) {
log.info("jpa-transaction:commit-----now dataSource is [" + DataSourceContextHolder.getReadOrWrite() + "]");
super.doCommit(status);
}
}

说明：如果方法命名不符合规则，也没有加注解，则typeKey会有可能为null，下面的逻辑是

typeKey为空使用写库！---也就是主库。

/**

* 这是AbstractRoutingDataSource类中的一个抽象方法，

* 而它的返回值是你所要用的数据源dataSource的key值，有了这个key值，

* targetDataSources就从中取出对应的DataSource，如果找不到，就用配置默认的数据源。

@Override

protected Object determineCurrentLookupKey() {

String typeKey = DataSourceContextHolder.getReadOrWrite();

if (typeKey == null || typeKey.equals(DataSourceType.write.getType())) {

System.err.println("使用数据库write.............");

return DataSourceType.write.getType();

} else {

//读库，简单负载均衡

// int number = count.getAndAdd(1);

// int lookupKey = number % readSize;

// System.err.println("使用数据库read-" + (lookupKey + 1));

// return DataSourceType.read.getType() + (lookupKey + 1);

return DataSourceType.read.getType() + "1";

}

7.读写数据源的注解，非必需，有则可以更加灵活：

package com.ddbin.frms.config.datasource;
import java.lang.annotation.*;
/**
* Description:读数据源的注解
*
* @author dbdu
* @date 18-7-14 上午8:21
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface ReadDataSource {
}

package com.ddbin.frms.config.datasource;
import java.lang.annotation.*;
/**
* Description:写数据源的注解
*
* @author dbdu
* @date 18-7-14 上午8:21
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface WriteDataSource {
}

8.配置service切面，来切换不同的数据源：

package com.ddbin.frms.config.datasource;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;
/**
* Description:在service层决定数据源
* 必须在事务AOP之前执行，所以实现Ordered,order的值越小，越先执行
* 如果一旦开始切换到写库，则之后的读都会走写库;
* 方法名符合切入点规则或加上读写注解都可以使用对应的数据库！！
*
* @author dbdu
* @date 18-7-14 上午8:32
*/
@Aspect
@EnableAspectJAutoProxy(exposeProxy = true, proxyTargetClass = true)
@Component
public class DataSourceAopInService implements PriorityOrdered {
@Before("execution(* com.ddbin.frms.service..*.find*(..)) "
+ " or execution(* com.ddbin.frms.service..*.get*(..)) "
+ " or execution(* com.ddbin.frms.service..*.query*(..))"
+ " or execution(* com.ddbin.frms.service..*.list*(..))"
+ " or @annotation(com.ddbin.frms.config.datasource.ReadDataSource) "
)
public void setReadDataSourceType() {
//如果已经开启写事务了，那之后的所有读都从写库读
if (!DataSourceType.write.getType().equals(DataSourceContextHolder.getReadOrWrite())) {
DataSourceContextHolder.setRead();
}
}
@Before("execution(* com.ddbin.frms.service..*.insert*(..)) "
+ " or execution(* com.ddbin.frms.service..*.add*(..))"
+ " or execution(* com.ddbin.frms.service..*.save*(..))"
+ " or execution(* com.ddbin.frms.service..*.create*(..))"
+ " or execution(* com.ddbin.frms.service..*.update*(..))"
+ " or execution(* com.ddbin.frms.service..*.mod*(..))"
+ " or execution(* com.ddbin.frms.service..*.delete*(..))"
+ " or execution(* com.ddbin.frms.service..*.del*(..))"
+ " or execution(* com.ddbin.frms.service..*.truncate*(..))"
+ " or @annotation(com.ddbin.frms.config.datasource.WriteDataSource) "
)
public void setWriteDataSourceType() {
DataSourceContextHolder.setWrite();
}
@Override
public int getOrder() {
/**
* 值越小，越优先执行
* 要优于事务的执行
* 在启动类中加上了@EnableTransactionManagement(order = 10)
*/
return 1;
}
}

说明:

A.如果方法的命名符合切入点的规则，则自动设定使用需要的数据源;

B.如果不符合A 的方法命名规则，使用注解也一样。

C.如果方法命名不符合A 的规则也没有对应的注解，则默认使用主库！

特别注意：

一定不要对从库或说read库进行写操作，这样做的后果是，轻者导致数据不一致(主库到从库的单向同步)，重者导致从库同步失败，主库的更改不会同步到从库！

因此，写库注解可以加到service的任意方法上，因为是操作主库，但是读库注解不能加到写的方法上！

9.测试用类：读者自己去写就好了。

/**
* Description:这个方法用来测试方法名不符合规范及注解不同是什么效果！！
* 方法名不符合规则也没有注解，默认走主库！
*
* @author dbdu
* @date 18-7-15 下午5:45
*/
@ReadDataSource
@Override
public Page<Employee> pageByName(String userName, Pageable page) {
Page<Employee> page1 = employeeRepository.findByName(userName, page);
return page1;
}

参考地址：

A.https://blog.csdn.net/dream_broken/article/details/72851329 https://github.com/269941633/spring-boot-mybatis-mysql-write-read ----主要参考这篇文章！！

B.https://blog.csdn.net/u011493599/article/details/53930394

C.https://www.cnblogs.com/pier2/p/spring-boot-read-write-split.html

D.https://www.jianshu.com/p/8813ec02926a

E.https://my.oschina.net/wxdl/blog/1628007

F.http://blog.51cto.com/13645072/2090313

datajpa:

https://blog.csdn.net/hangge111/article/details/51605558

https://blog.csdn.net/ba5189tsl/article/details/47341425

LocalContainerEntityManagerFactoryBean创建的方法：

http://www.javased.com/index.php?api=org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean

点赞
评论7
分享
收藏3
打赏
关注
一键三连

SpringBoot+ProxySql 配置读写分离代理解决 java.sql.SQLException: Unknown system variable query_cache

weixin_43193729的博客

369

ProxySql 简介 ProxySQL 是基于 MySQL 的一款开源的中间件的产品，是一个灵活的 MySQL 代理层，可以实现读写分离，支持 Query 路由功能，支持动态指定某个 SQL 进行缓存，支持动态加载（无需重启 ProxySQL 服务），故障切换和一些 SQL 的过滤功能。具体介绍请参考：ProxySQL 基础篇文章中指出主从库的配置文件中要有 read_only节点这个在我的上一篇配置主从数据库中有配置但是在MySQL配置文件中写的话必须要写成 read-on...

SpringBoot+MySQLRouter 8 （mysql读写分离的代理）ubuntu20.04 配置mysqlrouter8

weixin_43193729的博客

397

mysql router 特性（1）Router实现读写分离，程序不是直接连接数据库IP，而是固定连接到mysql router。MySQL Router对前端应用是透明的。应用程序把MySQL Router当作是普通的mysql实例，把查询发给MySQL Router,而MySQL Router会把查询结果返回给前端的应用程序。（2）从数据库服务器故障，业务可以正常运行。由MySQL Router来进行自动下线不可用服务器。程序配置不需要任何修改。（3）主数据库故障，由MySQL R..

「已注销」:import com.ddbin.frms.util.SpringContextsUtil;这个类没有啊2 年前回复
- dusuanyun回复:
```
 
```
 1. @Component
 2. public class SpringContextUtils implements ApplicationContextAware {
 3. public static ApplicationContext applicationContext;
 4. @Override
 5. public void setApplicationContext(ApplicationContext applicationContext)
 6. throws BeansException {
 7. SpringContextUtils.applicationContext = applicationContext;
 8. }
 9. public static Object getBean(String name) {
 10. return applicationContext.getBean(name);
 11. }
 12. public static <T> T getBean(String name, Class<T> requiredType) {
 13. return applicationContext.getBean(name, requiredType);
 14. }
 15. public static boolean containsBean(String name) {
 16. return applicationContext.containsBean(name);
 17. }
 18. public static boolean isSingleton(String name) {
 19. return applicationContext.isSingleton(name);
 20. }
 21. public static Class<? extends Object> getType(String name) {
 22. return applicationContext.getType(name);
 23. }
 24. }
 2 年前回复
- 「已注销」回复:applicationContext.getBean("entityManagerFactory"));
```
 
```
 1. 我改成这样不知道对不对
 2 年前回复

BnuzLeon:兄弟，可以。网上的确有很多假主从，都是拿主表来读写的。2 年前回复
- dusuanyun回复: 是的,谢谢认可.我个人也非常在意是否是真的读写,这个研究很久整理出来的文章,还是有一定的参考价值的.2 年前回复

qingqianxiaoyao:博主啊能不能把那个yml配置文件修改成yml格式的文件，不然有点不清楚到底是怎么配置的2 年前回复
- dusuanyun回复:已经调整,谢谢提醒2 年前回复

相关推荐

基于SpringBoot的MYSQL数据库读写分离(二)——项目搭建...

5-7

在前一章中,我们介绍完了数据库读写分离所需要的基础环境的的搭建。详见:【基于SpringBoot的MYSQL数据库读写分离(一)——基础环境搭建】在本章中,将介绍如何使用Springboot去实现动态切换数据源。

崛起于Springboot2.X之Mysql读写分离(6)_weixin_342040...

5-4

序言:这个读写分离摘自于Springboot多数据源快速启动器,读写分离的话并不是按照传统方式的springmvc看方法命名那样,而是在每个方法上加注解或者类上添加注解表明选用的数据源。支持事物! 1、创建Springboot项目 ...

【MySQL】SpringBoot实现MySQL读写分离

头号码农的博客

452

SpringBoot MySQL读写分离读写分离实现编码思想实现步骤添加pom依赖application.properties配置配置数据源配置切面类用到的其他类动态数据源读写类型记录操作类型业务方法标记注解 MySQL数据库安装请参考：CentOS7安装MySQL数据库及MariaDB MySQL数据库主从复制环境搭建请参考：CentOS7实现MySQL读写分离环境搭建 读写分离实现 读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行，至于谁来做选择数据库这件事儿，无非两个，要么中间件帮我们做

MySQL Proxy笔记

星猿

版本 mysql-proxy 0.8.5 命令行方式启动，监听4040端口 mysql-proxy --proxy-read-only-backend-addresses=10.1.1.1 --log-level=debug --daemon 2021-01-06 15:15:31: (message) proxy listening on port :4040 2021-01-06 15:15:31: (message) added read/write backend: 127.0.0.1:330

springboot mysql实现读写分离_ccr1001ccr1001的博客

4-14

springboot mysql实现读写分离 mysql主从设置参考:mysql主从设置 1. pom设置 spring: data: master: driver-class-name: com.mysql.jdbc.Driver jdbc-url:jdbc:mysql://192.168.1.47:3306/im-block?autoReconnect=true&useUnicode=...

基于SpringBoot,来实现MySQL读写分离技术_里奥ii的博客

4-29

基于SpringBoot,来实现MySQL读写分离技术前言首先思考一个问题:在高并发的场景中,关于数据库都有哪些优化的手段?常用的有以下的实现方法:读写分离、加缓存、主从架构集群、分库分表等,在互联网应用中,大部分都是读多写少的场景,...

SpringBoot进行MySql动态数据源配置实现读写分离（连接池Druid）

Autumn、的博客

4077

1.简介前面使用C3P0连接池进行过数据库的读写分离的实验，今天换一下数据库连接池改造一下，原理还是和原来的一样。 Druid是阿里出品，淘宝和支付宝专用数据库连接池，但它不仅仅是一个数据库连接池，它还包含一个ProxyDriver，一系列内置的JDBC组件库，一个 SQL Parser。支持所有JDBC兼容的数据库，包括Oracle、MySql、Derby、Postgresql、SQL S...

SpringBoot MySql读写分离-多数据源集成

zhuyu19911016520

1327

1.业务场景客户给了3台MySQL数据库服务器，一主二从，程序需要集成读写分离，充分提升数据处理能力数据层使用了MyBatis-Plus，它有一个多数据源的中间件 dynamic-datasource-spring-boot-starter 参考：MyBatis-Plus 2.MySql主从一主二从，搭建方式参考：docker搭建mysql读写分离 3.SpringBoot快速集成 1.新建SpringBoot项目，核心依赖 <dependency> <groupId&g

基于SpringBoot的MYSQL数据库读写分离(一)——基础环境...

5-10

首先需要明确的是使用数据库读写分离的目的,它的主要应用场景是为了解决数据库“读”的瓶颈问题,在对数据库进行一定程度的优化后,任然不能满足“读”数据的业务需求,这样我们就需要引入数据库读写分离了。

SpringBoot+MyBatis+MySQL读写分离(实例)_javafirst

5-8

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

mysql读写分离之springboot集成

lipeng的博客

2823

springboot、mysql实现读写分离 1、首先在springcloud config中配置读写数据库 mysql: datasource: readSize: 1 #读库个数 type: com.alibaba.druid.pool.DruidDataSource write: url: jdbc:mysql://200...

SpringBoot+MyBatis+MySQL读写分离（实例）

java面试笔试

701

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

SpringBoot+MyBatis+MySQL读写分离_lisheng19870305的专栏

5-6

SpringBoot+MyBatis+MySQL读写分离 原文地址:https://www.cnblogs.com/cjsblog/p/9712457.html 1. 引言 读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行,至于谁来做选择数据库这件事儿,无非两个,要么中间件帮我们做,...

Spring/SpringBoot系列之springboot+mysql+mybatis实现...

5-4

--lookup parent from repository--></parent><groupId>com.linyf</groupId><artifactId>demo</artifactId><version>0.0.1-SNAPSHOT</version><name>demo</name><description>springboot+mysql+mybatis实现读写分离实战</...

SpringBoot + MyBatis + MySQL 读写分离实战

勇往直前的专栏

688

1. 引言 读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行，至于谁来做选择数据库这件事儿，无非两个，要么中间件帮我们做，要么程序自己做。因此，一般来讲，读写分离有两种实现方式。第一种是依靠中间件（比如：MyCat），也就是说应用程序连接到中间件，中间件帮我们做SQL分离；第二种是应用程序自己去做分离。这里我们选择程序自己来做，主要是利用Spring提供的路由数据源，以及AOP。然...

SpringBoot + MyBatis + MySQL 读写分离实战

HollisChuang's Blog

1302

作者：废物大师兄来源：http://t.cn/AiKuJEB91. 引言读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行，至于谁来做选择数据库这件事儿，无非两个...

springboot实现mysql的读写分离_SunQIXin的博客-CSDN博...

4-14

springboot实现mysql的读写分离 描述 读写分离就是对于一条SQL该选择哪一个数据库去执行,至于谁来做选择数据库这件事,有两个,要么使用中间件帮我们做,要么程序自己做。一般来说,读写分离有两种实现方式。第一种是依靠中间件MyCat,...

SpringBoot+MyBatis+MySQL读写分离

weixin_30848775的博客

124

springboot+springAOP实现数据库读写分离及数据库同步(MySQL)

wsbgmofo的博客

5788

网上找了很多资料,发现根据获取bean的时候报空指针,不知道是哪里有问题,后来稍作修改就可以了 1,数据源配置文件,如下 datasource.readSize=1 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource # 主数据源，默认的 spring.master.driver-class-name=com.my

Springboot Mybatis MySQL读写分离及事物配置

wantnrun的专栏

5936

为什么需要读写分离 当项目越来越大和并发越来大的情况下，单个数据库服务器的压力肯定也是越来越大，最终演变成数据库成为性能的瓶颈，而且当数据越来越多时，查询也更加耗费时间，当然数据库数据过大时，可以采用数据库分库分表，同时数据库压力过大时，也可以采用Redis等缓存技术来降低压力，但是任何一种技术都不是万金油，很多时候都是通过多种技术搭配使用，而本文主要就是介绍通过读写分离来加快数据库读取速度

mysql使用mysql-proxy实现读写分离

橙汁Iter的博客

1349

一、主从分离的原理 1.简介对于很多大型网站（pv值百万、千万）来说，在所处理的业务中，其中有70%的业务是查询（select）相关的业务操作（新闻网站，插入一条新闻。查询操作），剩下的则是写（insert、update、delete，只要能对MySQL的数据造成更改的操作都叫写操作）操作。在使用负载均衡集群之后，可以很大程度的提升网站的整体性能，但是最终的数据处理的压力还是会落到MySQ...

手把手搭建Java学生信息管理系统【附源码】（毕设）

02-24

本课程主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者 1. 包含：项目源码、项目文档、数据库脚本、软件工具等所有资料 2. 手把手的带你从零开始部署运行本套系统 3. 该项目附带的源码资料可作为毕设使用 4. 提供技术答疑和远程协助指导 项目运行截图： 1）系统登陆界面 <img src="https://img-bss.csdn.net/202002241015433522.png" alt="" /> 2）学生模块 <img src="https://img-bss.csdn.net/202002241015575966.png" alt="" /> 3）教师模块 <img src="https://img-bss.csdn.net/202002241016127898.png" alt="" /> 4）系统管理员 <img src="https://img-bss.csdn.net/202002241016281177.png" alt="" /> <img src="https://img-bss.csdn.net/202002241016369884.png" alt="" /> 更多Java毕设项目请关注我的毕设系列课程 <a href="https://edu.csdn.net/lecturer/2104">https://edu.csdn.net/lecturer/2104</a>

Windows版YOLOv4-tiny目标检测实战：训练自己的数据集

07-06

课程演示环境：Windows10 需要学习Ubuntus系统YOLOv4-tiny的同学请前往《YOLOv4-tiny目标检测实战：训练自己的数据集》 YOLOv4-tiny来了！速度大幅提升！ YOLOv4-tiny在COCO上的性能可达到：40.2% AP50, 371 FPS (GTX 1080 Ti)。相较于YOLOv3-tiny，AP和FPS的性能有巨大提升。并且，YOLOv4-tiny的权重文件只有23MB，适合在移动端、嵌入式设备、边缘计算设备上部署。 本课程将手把手地教大家使用labelImg标注和使用YOLOv4-tiny训练自己的数据集。课程实战分为两个项目：单目标检测（足球目标检测）和多目标检测（足球和梅西同时检测）。 本课程的YOLOv4-tiny使用AlexAB/darknet，在Windows10系统上做项目演示。包括：YOLOv4-tiny的网络结构、安装YOLOv4-tiny、标注自己的数据集、整理自己的数据集、修改配置文件、训练自己的数据集、测试训练出的网络模型、性能统计(mAP计算)和先验框聚类分析。 除本课程《Windows版YOLOv4-tiny目标检测实战：训练自己的数据集》外，本人推出了有关YOLOv4目标检测的系列课程。请持续关注该系列的其它视频课程，包括： 《Windows版YOLOv4目标检测实战：训练自己的数据集》 《Windows版YOLOv4目标检测实战：人脸口罩佩戴识别》 《Windows版YOLOv4目标检测实战：中国交通标志识别》 《Windows版YOLOv4目标检测：原理与源码解析》 <img alt="" src="https://img-bss.csdnimg.cn/202007061503586145.jpg" /> <img alt="" src="https://img-bss.csdnimg.cn/202007061504169339.jpg" />

C语言入门--必须基础17讲

07-28

适合没有基础的人群学习C语言，简单的入门教程。帮助小白理解什么是开发，什么是编程。做的很简单，很多细节没有详细讲解，不适合用来深入研究。学了这个，你能理解什么是编程，什么是C语言。

python入门

12-18

您观看课程学习后 免费入群领取【超全Python资料包+17本学习电子书】 <img src="https://img-bss.csdn.net/201909261025418774.jpg" alt="" /> 帮助与数百万年轻人打开人工智能的学习大门！

JAVA入门精品课程

12-20

课程目标： 1、让初学者从小白开始，善于运用知识点，解脱学习的苦恼 2、能够学习更多的工作中使用技巧，成为编程高手

关于我们
招贤纳士
广告服务
开发助手
400-660-0108
kefu@csdn.net
在线客服
工作时间 8:30-22:00

公安备案号11010502030143
京ICP备19004658号
京网文〔2020〕1039-165号
经营性网站备案信息
北京互联网违法和不良信息举报中心
网络110报警服务
中国互联网举报中心
家长监护
Chrome商店下载
版权与免责声明
版权申诉
出版物许可证
营业执照

dusuanyun

码龄9年暂无认证

原创

10万+

周排名

18万+

总排名

3万+

访问

等级

582

积分

粉丝

获赞

私信

关注

分类专栏

环境配置3篇
编程实现5篇
SpringDataJpa2篇
多租户1篇
隔离的redis1篇
设备驱动1篇
读书笔记3篇
应用配置9篇
小技巧3篇
开发坑解决6篇

SpringBoot下MySQL的读写分离相关推荐

Springboot实现Mysql的读写分离
一.描述读写分离就是对于一条SQL该选择哪一个数据库去执行,至于谁来做选择数据库这件事,有两个,要么使用中间件帮我们做,要么程序自己做.一般来说,读写分离有两种实现方式.第一种是依靠中间件MyCat ...
linux mysql安装读写分离_linux下安装mysql-proxy 配置读写分离
一.软件列表 ncurses-5.7.tar.gz wget http://ftp.gnu.org/pub/gnu/ncurses/ncurses-5.7.tar.gz mysql-proxy-0.8 ...
Sharding-jdbc教程：Springboot整合sharding-jdbc实现读写分离
点击上方"方志朋",选择"置顶公众号" 技术文章第一时间送达! Sharding-JDBC简介 Sharding-JDBC是的分布式数据库中间件解决方案.Sha ...
Amoeba实现mysql主从读写分离
Amoeba实现mysql主从读写分离这段在网上看了下关于amoeba的文章,总体感觉好像要比mysql-proxy好的多,也参考了不少的资料,此文章可能与其他文章作者会有雷同的地方,请谅解,但是此 ...
Centos7源码安装mysql及读写分离，互为主从
Linux服务器 -源码安装mysql 及读写分离,互为主从一.环境介绍: Linux版本: CentOS 7 64位 mysq版本: mysql-5.6.26 这是我安装时所使用的版本, ...
MySQL Router实现MySQL的读写分离
1.简介 MySQL Router是MySQL官方提供的一个轻量级MySQL中间件,用于取代以前老版本的SQL proxy. 既然MySQL Router是一个数据库的中间件,那么MySQL Rout ...
MySQL面试 - 读写分离
MySQL面试 - 读写分离面试题你们有没有做 MySQL 读写分离?如何实现 MySQL 的读写分离?MySQL 主从复制原理的是啥?如何解决 MySQL 主从同步的延时问题? 面试官心理分析 ...
SpringBoot 整合 MyCat 实现读写分离
作者:颜不喜 cnblogs.com/muycode/p/12603037.html MyCat一个彻底开源的,面向企业应用开发的大数据库集群.基于阿里开源的Cobar产品而研发.能满足数据库数据大量 ...
amoeba实现mysql主从读写分离_利用Amoeba实现MySQL主从复制和读写分离
在实际生产环境中,如果对数据库的读和写都在同一个数据库服务器中操作,无论是在安全性.高可用性,还是高并发等各个方面都是完全不能满足实际需求的,因此,一般来说都是通过主从复制(Master-Slave) ...

SpringBoot下MySQL的读写分离

02-下篇-SpringBoot下MySQL的读写分离

热门文章

最新评论

最新文章

分类专栏

SpringBoot下MySQL的读写分离相关推荐

最新文章

热门文章