springboot +mybatis实现mysql读写分离

已于 2023-04-19 15:38:31 修改
阅读量597 收藏 1
点赞数
分类专栏： Java 文章标签： mysql读写分离 aop
于 2019-10-04 22:36:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengchengwu2012/article/details/102099599
版权

配置好mysql的主从复制后，读写分离需要在代码层面实现，本实例采用spring boot集成mybatis的方式是实现，数据源连接池使用druid

1、加入maven依赖，配置application.yml文件

pom.xml依赖jar

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

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

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

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

application.xml配置数源

spring:
  freemarker:
    suffix: .html
    request-context-attribute: request
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      master:
        url: jdbc:mysql://192.168.2.131:3306/app_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: root
        # 从库数据源
      slave:
          # 从数据源开关/默认关闭
        enabled: true
        url: jdbc:mysql://192.168.2.132:3306/app_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: root
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      webStatFilter:
        enabled: true
      statViewServlet:
        enabled: true
        # 设置白名单，不填则允许所有访问
        allow:
        url-pattern: /monitor/druid/*
      filter:
        stat:
          enabled: true
          # 慢SQL记录
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: true
        wall:
          config:
            multi-statement-allow: true
spring:
  freemarker:
    suffix: .html
    request-context-attribute: request
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      master:
        url: jdbc:mysql://192.168.2.131:3306/app_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: root
        # 从库数据源
      slave:
          # 从数据源开关/默认关闭
        enabled: true
        url: jdbc:mysql://192.168.2.132:3306/app_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: root
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      webStatFilter:
        enabled: true
      statViewServlet:
        enabled: true
        # 设置白名单，不填则允许所有访问
        allow:
        url-pattern: /monitor/druid/*
      filter:
        stat:
          enabled: true
          # 慢SQL记录
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: true
        wall:
          config:
            multi-statement-allow: true

2、java代码实现

 （1）定义主库从库常量

public interface Constant {
    String MASTER="MASTER";
    String SLAVE="SLAVE";
}

（2）数据源切换处理，主库从库切换，主库处理写数据，从库处理读数据

public class DynamicDataSourceContextHolder
{
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     *  所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源的变量
     */
    public static void setDataSourceType(String dsType)
    {
        log.info("切换到{}数据源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 获得数据源的变量
     */
    public static String getDataSourceType()
    {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 清空数据源变量
     */
    public static void clearDataSourceType()
    {
        CONTEXT_HOLDER.remove();
    }
}

（3）动态数据源路由

public class DynamicDataSource extends AbstractRoutingDataSource
{
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources)
    {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey()
    {
        //如果有多个从库，可以使用负载均衡算法，实现具体从库的路由
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

（4）druid 配置属性，实例化数据源

@Configuration
public class DruidProperties
{
    @Value("${spring.datasource.druid.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.druid.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.druid.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.druid.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis}")
    private int maxEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.testOnReturn}")
    private boolean testOnReturn;

    public DruidDataSource dataSource(DruidDataSource datasource)
    {
        /** 配置初始化大小、最小、最大 */
        datasource.setInitialSize(initialSize);
        datasource.setMaxActive(maxActive);
        datasource.setMinIdle(minIdle);
        /** 配置获取连接等待超时的时间 */
        datasource.setMaxWait(maxWait);
        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);
        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
        datasource.setTestWhileIdle(testWhileIdle);
        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);
        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);
        return datasource;
    }
}

@Configuration
public class DruidConfig {

    @Autowired
    private DruidProperties druidProperties;

    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource  masterDataSource(){
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave")
    @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
    public DataSource  slaveDataSource(){
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dataSource()
    {
        Map<Object, Object> targetDataSources = new HashMap<>(2);
        targetDataSources.put(Constant.MASTER, masterDataSource());
        targetDataSources.put(Constant.SLAVE,slaveDataSource());
        return new DynamicDataSource(masterDataSource(), targetDataSources);
    }

    @Bean
    public SqlSessionFactory  sqlSessionFactory() throws  Exception{
        SqlSessionFactoryBean  sqlSessionFactoryBean=new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
        sqlSessionFactoryBean.setTypeAliasesPackage("cn.com.fcw.mysqlproxy");
        return sqlSessionFactoryBean.getObject();
    }

    /**
     * 开启事务管理
     * @return
     */
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager(){
        return  new DataSourceTransactionManager(dataSource());
    }
}

（5）利用AOP技术操作具体的读写分离业务

/**
 * 自定义多数据源切换注解
 * 
 * @author inquiry
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RwDataSource
{
    /**
     * 切换数据源名称
     */
    String value() default Constant.MASTER;
}

@Aspect
@Order(1)
@Component
public class DataSourceAspect
{
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(cn.com.fcw.mysqlproxy.config.RwDataSource)")
    public void dsPointCut() { }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable
    {
        MethodSignature signature = (MethodSignature) point.getSignature();

        Method method = signature.getMethod();

        RwDataSource dataSource = method.getAnnotation(RwDataSource.class);

        if (dataSource!=null)
        {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value());
        }

        try
        {
            return point.proceed();
        }
        finally
        {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }
}

（6）读写分离具体实现，将注解使用在service的具体方法上

@Service
public class UserServiceImpl {

    @Autowired
    private UserMapper userMapper;

    @RwDataSource
    public BaseBean insert(UserEntity userEntity){
        Integer res = userMapper.insert(userEntity);
        return BaseBean.getBaseBean(res,res);
    }
    @RwDataSource
    public BaseBean update(UserEntity userEntity){
        Integer res = userMapper.update(userEntity);
        return BaseBean.getBaseBean(res,res);
    }

    @RwDataSource
    public BaseBean delete(Integer id){
        Integer res = userMapper.delete(id);
        return BaseBean.getBaseBean(res,res);
    }

    @RwDataSource(Constant.SLAVE)
    public BaseBean list(){
        List<UserEntity> userEntities = userMapper.selectUserList();
        return BaseBean.getBaseBean(userEntities,0);
    }
}

fengchengwu2012
关注
专栏目录
MySQL 读写分离实例详解
12-15
MySQL 读写分离 MySQL读写分离又一好办法 使用 com.mysql.jdbc.ReplicationDriver 在用过Amoeba 和 Cobar，还有dbware 等读写分离组件后，今天我的一个好朋友跟我讲，MySQL自身的也是可以读写分离的，因为他们提供了一个新的驱动，叫 com.mysql.jdbc.ReplicationDriver 说明文档：http://dev.mysql.com/doc/refman/5.1/en/connector-j-reference-replication-connection.html  代码例子： import java.sql.Conn
DataSource数据源
一个很懒的人
06-07 1万+
本文详细的介绍了 JAVA中的数据源，认真看下来 你一定会收获满满！！！
Spring Boot+MyBatis+MySQL如何实现读写分离
最新发布
2301_76419561的博客
08-02 735
​博客主页: 南来_北往系列专栏：Spring Boot实战读写分离是数据库架构中的一种优化策略，它将读操作（查询）和写操作（更新、插入、删除）分开处理，通常通过将读请求和写请求分别发送到不同的数据库服务器来实现。下面介绍实现读写分离的原因：总之，读写分离不仅能有效提升数据库性能，还能根据不同的业务需求，提供灵活的数据处理能力。然而，在实施时也需考虑数据同步延迟、一致性等问题，以确保系统整体的稳定性和可靠性。1、配置数据源：在application.properties或application.ym
【Spring Boot】DataSource数据源的自动配置解析
热门推荐
Decade0712的博客
09-28 1万+
简单介绍一下SpringBoot关于数据源的自动配置，主要是DataSource的自动配置类以及如何使用JdbcTemplate去操作数据源查询数据
SpringBoot框架DataSource多数据源配置
weixin_45385991的博客
08-17 9429
SpringBoot配置DataSource 多数据源
SpringBoot+Mybatis实现读写分离
weixin_38091679的博客
10-17 775
SpringBoot+Mybatis实现读写分离 最近的项目中需要实现简单的读写分离，由于项目中使用的是SpringBoot+Mybatis，简单的实现了一下功能 读写分离的概念已经提过很多次：单个数据库的承受服务请求的压力太大，于是将数据库的读操作和写操作分别执行，由于我们的应用大部分是读操作，写操作频率较低，于是常见的结构是一主多从；（当然生产环境是有主备切换的，这里不赘述） 核心思想 基于S...
springboot+mybatis+mysql实现读写分离.zip
10-23
springboot+mybatis+mysql实现读写分离 先在建好mysql主从数据库的配置，然后在代码中根据读写分离或强制读取master数据库中的数据 mysql数据库设置主从，参考： ...
springBoot+mybatis读写分离（AOP）
04-02
在Spring Boot项目中，我们可以通过AOP来实现读写分离。首先，我们需要定义两个数据源，一个作为主数据源（写库），另一个作为从数据源（读库）。这可以通过配置Spring Boot的数据源切换功能实现，例如在`...
springboot基于Mybatis mysql实现读写分离
08-25
springboot基于Mybatis mysql实现读写分离 一、概述 本文主要介绍如何使用 Spring Boot 和 MyBatis 实现 MySQL 读写分离。读写分离是一种常见的数据库优化技术，用于提高数据库的读取性能。通过将读写操作分离到...
spring +springboot+mybatis+maven 读写分离及事务管理
09-07
spring +springboot+mybatis+maven 读写分离，数据库采用mysql, 采用springboot 采用项目框架搭建，继承spring 中的AbstractRoutingDataSource，实现 determineCurrentLookupKey 进行数据源的动态切换，采用Spring ...
springboot+mybatis多数据源+动态数据源配置(连接池)
09-09
springboot+mybatis多数据源+动态数据源配置(连接池),mysql数据库，代码实现了简单的读写分离，但是不建议这种操作，建议使用数据库中间件进行读写分离，例如使用mycat进行读写分离主从热备，使用该代码对于多个...
最简单可配置的多数据源dataSource
yaliangtang
02-17 3387
场景 公司需要从数量不定，类型可能不同的第三方数据库读取数据。 需求 数据库信息需要动态配置（如从数据库读取），需要动态设置DataSource，且考虑到线程安全。 所以写死的多数据源满足不了。 现代码已满足基本要求，便捷性自行扩展。 解释：ComRecord 它是个自定义的map。 数据源代码： private ThreadLocal<JdbcTemplate> local = new ThreadLocal<>(); private Map&l.
Spring Boot + MyBatis 实现读写分离
xzkwuli的博客
03-07 652
Spring Boot + MyBatis 实现读写分离 MySQL主从复制配置 项目下载 一、版本号 Spring Boot：2.2.2.Release <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.2.RELEASE</versi
springboot+mybatis实现主从库读写分离
jieyuanyihao的博客
07-08 2097
springboot+mybatis或者mybatis-plus实现主从库读写分离
MyBatis下DataSource的配置原理以及多数据源的配置
m0_46496021的博客
03-31 2614
为当前注入的bean对象读取配置文件以spring.datasource开头的配置项，如果之后的部分和实体类的属性一致的话，会将配置的内容注入给对象的属性中。多datasource的配置原理：将不同数据源的mapper接口放在不同的包内，再在数据源配置中，用@MapperScan注解扫描不同的包。在配置类上使用@MapperScan注解后，扫描的包内所有接口就默认是mapper接口了，不需要再在每个接口上使用@Mapper注解。
springboot+mysql+mybatis实现读写分离-基于程序（一招解决）
zwjzone的博客
04-21 1196
简单、快速的利用程序实现MySQL读写分离
SpringBoot多数据源配置
文盲青年的博客
07-17 3758
springboot多数据源
SpringBoot系列之数据库初始化-datasource配置方式
BASK2311的博客
12-22 4820
在我们的日常业务开发过程中，如果有db的相关操作，通常我们是直接建立好对应的库表结构，并初始化对应的数据，即更常见的情况下是我们在已有表结构基础之下，进行开发；但是当我们是以项目形式工作时，更常见的做法是所有的库表结构变更、数据的初始、更新等都需要持有对应的sql变更，并保存在项目工程中，这也是使用liqubase的一个重要场景；将上面的问题进行简单的翻译一下，就是如何实现在项目启动之后执行相应的sql，实现数据库表的初始化？
【DataSource】局部数据源配置（用jdbc或c3p0配置数据源）
m0_56249083的博客
04-29 2899
先介绍一下局部数据源配置的共同之处是： 需要在webapp应用文件夹下的/WEB-INF下的context.xml中配置，有的人是没有这个文件夹的，需要自己手动生成（没错就是我，全班都在用eclipse而我用idea发现自己并没有，可能是因为我创建的是maven工程是自己导入的webapp）： 导入后如上图。 这里再穿插一下context.xml和web.xml： 【方式1】传统的jdbc连接： 不需要在context.xml中配置。但是需要类加载驱动以及driverManage.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值