spring-boot 速成(9) druid+mybatis 多数据源及读写分离的处理

按上节继续学习，稍微复杂的业务系统，一般会将数据库按业务拆开，比如产品系统的数据库放在product db中，订单系统的数据库放在order db中...，然后，如果量大了，可能每个库还要考虑做读、写分离，以进一步提高系统性能，下面就来看看如何处理：

核心思路：配置多个数据源，然后利用RoutingDataSource结合AOP来动态切不同的库。

要解决的问题：

1、配置文件中，多数据源的配置节点如何设计？

 1 druid:
 2     type: com.alibaba.druid.pool.DruidDataSource
 3     study:
 4       master: #study库的主库
 5         url: jdbc:mysql://localhost:3306/study?useSSL=false&characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true
 6         driver-class-name: com.mysql.cj.jdbc.Driver
 7         username: root
 8         password: A1b2c3@def.com
 9         initial-size: 5
10         min-idle: 1
11         max-active: 20
12         test-on-borrow: true
13       slave: #study库的从库
14         url: jdbc:mysql://localhost:3306/study_slave?useSSL=false&characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true
15         driver-class-name: com.mysql.cj.jdbc.Driver
16         username: root
17         password: A1b2c3@def.com
18         initial-size: 5
19         min-idle: 1
20         max-active: 20
21         test-on-borrow: true
22     product:
23       master: #product库的主库
24         url: jdbc:mysql://localhost:3306/product?useSSL=false&characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true
25         driver-class-name: com.mysql.cj.jdbc.Driver
26         username: root
27         password: A1b2c3@def.com
28         initial-size: 5
29         min-idle: 1
30         max-active: 20
31         test-on-borrow: true
32       slave: #product库的从库
33         url: jdbc:mysql://localhost:3306/product_slave?useSSL=false&characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true
34         driver-class-name: com.mysql.cj.jdbc.Driver
35         username: root
36         password: A1b2c3@def.com
37         initial-size: 5
38         min-idle: 1
39         max-active: 20
40         test-on-borrow: true

View Code

上面的配置写法供参数，如果slave节点数要扩展，按这个格式，改造成slave1,slave2... 自行扩展。

 

2、配置类如何设计？

 1 package com.cnblogs.yjmyzz.db.config;
 2
 3 /**
 4  * Created by jimmy on 6/18/17.
 5  */
 6
 7 import com.cnblogs.yjmyzz.db.datasource.DbContextHolder;
 8 import com.cnblogs.yjmyzz.db.datasource.MasterSlaveRoutingDataSource;
 9 import org.springframework.beans.factory.annotation.Value;
10 import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
11 import org.springframework.boot.context.properties.ConfigurationProperties;
12 import org.springframework.context.annotation.Bean;
13 import org.springframework.context.annotation.Configuration;
14 import org.springframework.context.annotation.Primary;
15 import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
16 import org.springframework.transaction.annotation.EnableTransactionManagement;
17
18 import javax.sql.DataSource;
19 import java.util.HashMap;
20 import java.util.Map;
21
22
23 @Configuration
24 @EnableTransactionManagement
25 public class DataSourceConfiguration {
26
27     @Value("${druid.type}")
28     private Class<? extends DataSource> dataSourceType;
29
30     @Bean(name = "studyMasterDataSource")
31     @ConfigurationProperties(prefix = "druid.study.master")
32     public DataSource studyMasterDataSource() {
33         return DataSourceBuilder.create().type(dataSourceType).build();
34     }
35
36     @Bean(name = "studySlaveDataSource")
37     @ConfigurationProperties(prefix = "druid.study.slave")
38     public DataSource studySlaveDataSource1() {
39         return DataSourceBuilder.create().type(dataSourceType).build();
40     }
41
42     @Bean(name = "productMasterDataSource")
43     @ConfigurationProperties(prefix = "druid.product.master")
44     public DataSource productMasterDataSource() {
45         return DataSourceBuilder.create().type(dataSourceType).build();
46     }
47
48     @Bean(name = "productSlaveDataSource")
49     @ConfigurationProperties(prefix = "druid.product.slave")
50     public DataSource productSlaveDataSource1() {
51         return DataSourceBuilder.create().type(dataSourceType).build();
52     }
53
54     @Bean(name = "dataSource")
55     @Primary
56     public AbstractRoutingDataSource dataSource() {
57         MasterSlaveRoutingDataSource proxy = new MasterSlaveRoutingDataSource();
58         Map<Object, Object> targetDataResources = new HashMap<>();
59         targetDataResources.put(DbContextHolder.DbType.PRODUCT_MASTER, productMasterDataSource());
60         targetDataResources.put(DbContextHolder.DbType.PRODUCT_SLAVE, productSlaveDataSource1());
61         targetDataResources.put(DbContextHolder.DbType.STUDY_MASTER, studyMasterDataSource());
62         targetDataResources.put(DbContextHolder.DbType.STUDY_SLAVE, studySlaveDataSource1());
63         proxy.setDefaultTargetDataSource(productMasterDataSource());
64         proxy.setTargetDataSources(targetDataResources);
65         proxy.afterPropertiesSet();
66         return proxy;
67     }
68
69 }

View Code

参考这个，一看就明，不说多(注：@Primary一定要在动态数据源上，否则事务回滚无效！）

 

3、根据什么来切换db?

有很多选择，

a、用约定的方法前缀，比如：get/query/list开头的约定为读从库，其它为主库，但是这样还要考虑不同业务库的切换（即：何时切换到product库，何时切换到order库，可以再用不同的Scanner来处理，略复杂）

b、用自定义注解来处理，比如 @ProductMaster注解，表示切换到product的master库，这样同时把业务库，以及主还是从，一次性解决了，推荐这种。

这里，我定义了4个注解，代表product，study二个库的主及从。

 

4、aop在哪里拦截,如何拦截？

service层和mapper层都可以拦截，推荐在服务层拦截，否则如果一个业务方法里，即有读又有写，还得考虑如果遇到事务，要考虑的东西更多。

当然，如果拦截特定的注解，就不用过多考虑在哪个层，只认注解就行（当然，注解还是建议打在服务层上）。

dubbo-starter的一个小坑：spring boot中，只有managed bean才能用aop拦截，而dubbo-starter中的@service注解不是spring中的注解（是阿里package下的自定义注解），生成的service provider实例，aop拦截不到，解决办法，再加一个注解让spring认识它，参考：

Aop拦截类的参考代码如下：

  1 package com.cnblogs.yjmyzz.db.aspect;
  2
  3 import com.cnblogs.yjmyzz.db.annotation.ProductMaster;
  4 import com.cnblogs.yjmyzz.db.annotation.ProductSlave;
  5 import com.cnblogs.yjmyzz.db.annotation.StudyMaster;
  6 import com.cnblogs.yjmyzz.db.annotation.StudySlave;
  7 import com.cnblogs.yjmyzz.db.datasource.DbContextHolder;
  8 import org.aspectj.lang.ProceedingJoinPoint;
  9 import org.aspectj.lang.annotation.Around;
 10 import org.aspectj.lang.annotation.Aspect;
 11 import org.slf4j.Logger;
 12 import org.slf4j.LoggerFactory;
 13 import org.springframework.core.Ordered;
 14 import org.springframework.stereotype.Component;
 15
 16
 17 @Aspect
 18 @Component
 19 public class MasterSlaveAspect implements Ordered {
 20
 21     public static final Logger logger = LoggerFactory.getLogger(MasterSlaveAspect.class);
 22
 23
 24     /**
 25      * 切换到product主库
 26      *
 27      * @param proceedingJoinPoint
 28      * @param productMaster
 29      * @return
 30      * @throws Throwable
 31      */
 32     @Around("@annotation(productMaster)")
 33     public Object proceed(ProceedingJoinPoint proceedingJoinPoint, ProductMaster productMaster) throws Throwable {
 34         try {
 35             logger.info("set database connection to product-master only");
 36             DbContextHolder.setDbType(DbContextHolder.DbType.PRODUCT_MASTER);
 37             Object result = proceedingJoinPoint.proceed();
 38             return result;
 39         } finally {
 40             DbContextHolder.clearDbType();
 41             logger.info("restore database connection");
 42         }
 43     }
 44
 45
 46     /**
 47      * 切换到product从库
 48      *
 49      * @param proceedingJoinPoint
 50      * @param productSlave
 51      * @return
 52      * @throws Throwable
 53      */
 54     @Around("@annotation(productSlave)")
 55     public Object proceed(ProceedingJoinPoint proceedingJoinPoint, ProductSlave productSlave) throws Throwable {
 56         try {
 57             logger.info("set database connection to product-slave only");
 58             DbContextHolder.setDbType(DbContextHolder.DbType.PRODUCT_SLAVE);
 59             Object result = proceedingJoinPoint.proceed();
 60             return result;
 61         } finally {
 62             DbContextHolder.clearDbType();
 63             logger.info("restore database connection");
 64         }
 65     }
 66
 67     /**
 68      * 切换到study主库
 69      *
 70      * @param proceedingJoinPoint
 71      * @param studyMaster
 72      * @return
 73      * @throws Throwable
 74      */
 75     @Around("@annotation(studyMaster)")
 76     public Object proceed(ProceedingJoinPoint proceedingJoinPoint, StudyMaster studyMaster) throws Throwable {
 77         try {
 78             logger.info("set database connection to study-master only");
 79             DbContextHolder.setDbType(DbContextHolder.DbType.STUDY_MASTER);
 80             Object result = proceedingJoinPoint.proceed();
 81             return result;
 82         } finally {
 83             DbContextHolder.clearDbType();
 84             logger.info("restore database connection");
 85         }
 86     }
 87
 88     /**
 89      * 切换到study从库
 90      *
 91      * @param proceedingJoinPoint
 92      * @param studySlave
 93      * @return
 94      * @throws Throwable
 95      */
 96     @Around("@annotation(studySlave)")
 97     public Object proceed(ProceedingJoinPoint proceedingJoinPoint, StudySlave studySlave) throws Throwable {
 98         try {
 99             logger.info("set database connection to study-slave only");
100             DbContextHolder.setDbType(DbContextHolder.DbType.STUDY_SLAVE);
101             Object result = proceedingJoinPoint.proceed();
102             return result;
103         } finally {
104             DbContextHolder.clearDbType();
105             logger.info("restore database connection");
106         }
107     }
108
109     @Override
110     public int getOrder() {
111         return 0;
112     }
113 }

View Code

 

5、其它事项

启用类上，一定要排除spring-boot自带的datasource配置，即：

1 @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
2 @EnableAspectJAutoProxy
3 @ComponentScan("com.cnblogs.yjmyzz")
4 @MapperScan(basePackages = "com.cnblogs.yjmyzz.dao.mapper")
5 public class ServiceProvider {
6     public static void main(String[] args) {
7         SpringApplication.run(ServiceProvider.class, args);
8     }
9 }

View Code

第1行：@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

 

6、日志中如何输出格式化且带参数值的sql?

一般的sql输出是这样的：

我们可以把它变成下面这样：

是不是更友好！

方法：加一个mybtais的拦截器即可

package com.cnblogs.yjmyzz.db.interceptor;

import com.cnblogs.yjmyzz.util.PrettySQLFormatter;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Properties;

/**
 * Created by 菩提树下的杨过(http://yjmyzz.cnblogs.com/) on 28/07/2017.
 */
@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})})
public class MybatisInterceptor implements Interceptor {

    private static Logger logger = LoggerFactory.getLogger(MybatisInterceptor.class);

    private Properties properties;

    private final static SimpleDateFormat sdt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        Object parameter = null;
        if (invocation.getArgs().length > 1) {
            parameter = invocation.getArgs()[1];
        }
        String sqlId = mappedStatement.getId();
        BoundSql boundSql = mappedStatement.getBoundSql(parameter);
        Configuration configuration = mappedStatement.getConfiguration();
        Object returnValue;
        long start = System.currentTimeMillis();
        returnValue = invocation.proceed();
        long end = System.currentTimeMillis();
        long time = (end - start);
        if (time > 1) {
            String sql = getSql(configuration, boundSql, sqlId, time);
            logger.debug("mapper method ==> " + sql.split("\\^")[0] + "\n，" + PrettySQLFormatter.getPrettySql(sql.split("\\^")[1]) + "\n\n，" + "sql execute time ==> " + time + " ms\n\n");
        }
        return returnValue;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public static String getSql(Configuration configuration, BoundSql boundSql, String sqlId, long time) {
        String sql = showSql(configuration, boundSql);
        StringBuilder str = new StringBuilder(100);
        str.append(sqlId);
        str.append("^");
        str.append(sql);
        str.append("^");
        str.append(time);
        str.append("ms");
        return str.toString();
    }

    private static String getParameterValue(Object obj) {
        String value;
        if (obj instanceof String) {
            value = "'" + obj.toString() + "'";
        } else if (obj instanceof Date) {
            value = "'" + sdt.format(obj) + "'";
        } else {
            if (obj != null) {
                value = obj.toString();
            } else {
                value = "";
            }

        }
        return value;
    }

    public static String showSql(Configuration configuration, BoundSql boundSql) {
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        if (parameterMappings.size() > 0 && parameterObject != null) {
            TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
            if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                sql = sql.replaceFirst("\\?", getParameterValue(parameterObject));

            } else {
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    if (metaObject.hasGetter(propertyName)) {
                        Object obj = metaObject.getValue(propertyName);
                        sql = sql.replaceFirst("\\?", getParameterValue(obj));
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        Object obj = boundSql.getAdditionalParameter(propertyName);
                        sql = sql.replaceFirst("\\?", getParameterValue(obj));
                    }
                }
            }
        }
        return sql;
    }
}

这里面还用了hibernate的一个小工具，用于格式化sql

package com.cnblogs.yjmyzz.util;

import org.hibernate.engine.jdbc.internal.FormatStyle;

public class PrettySQLFormatter {

    public static void print(String sql) {
        System.out.println(FormatStyle.BASIC.getFormatter().format(sql));
    }

    public static void print(String remark, String sql) {
        System.out.println(remark
                + FormatStyle.BASIC.getFormatter().format(sql));
    }

    public static String getPrettySql(String sql) {
        return FormatStyle.BASIC.getFormatter().format(sql);
    }

    public static String getPrettySql(String remark, String sql) {
        return remark + FormatStyle.BASIC.getFormatter().format(sql);
    }

    public static void main(String[] args) {
        System.out.println(getPrettySql("select * from MyUser as A join MyFriend as B on A.id = B.pid where B.name like ? "));
    }
}

接下来，把这个拦截器配置在mybatis-config.xml里

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 3         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 4 <configuration>
 5     <settings>
 6         <setting name="cacheEnabled" value="true"/>
 7     </settings>
 8
 9     <plugins>
10         <plugin interceptor="com.cnblogs.yjmyzz.db.interceptor.MybatisInterceptor">
11         </plugin>
12     </plugins>
13
14 </configuration>

View Code

最后在application.yml里指定mybatis-config.xml所在的路径：

示例源码见：https://github.com/yjmyzz/spring-boot-dubbo-demo （dubbox2.8.5-multi-ds分支）

时间： 2024-10-29 09:28:17

spring-boot 速成(9) druid+mybatis 多数据源及读写分离的处理的相关文章

spring boot(七)：springboot+mybatis多数据源最简解决方案

说起多数据源,一般都来解决那些问题呢,主从模式或者业务比较复杂需要连接不同的分库来支持业务.我们项目是后者的模式,网上找了很多,大都是根据jpa来做多数据源解决方案,要不就是老的spring多数据源解决方案,还有的是利用aop动态切换,感觉有点小复杂,其实我只是想找一个简单的多数据支持而已,折腾了两个小时整理出来,供大家参考. 废话不多说直接上代码吧 配置文件 pom包就不贴了比较简单该依赖的就依赖,主要是数据库这边的配置: mybatis.config-locations=classpath:

spring boot druid mybatis 多数据源 配置

spring boot 在配置时做了很多简化配置的设置,但是简化的配置往往已牺牲一定的定制化,比如在数据源的配置时,spring boot 只提供4种数据库连接池的配置,其中并不支持常用的druid 阅读spring boot DataSourceBuilder 的源码可以发现 spring boot 提供的4种数据源类型并不是我们想要的 private static final String[] DATA_SOURCE_TYPE_NAMES = new String[] { "org.apac

在应用层通过spring特性解决数据库读写分离

在应用层通过spring特性解决数据库读写分离    如何配置mysql数据库的主从? 单机配置mysql主从:http://my.oschina.net/god/blog/496   常见的解决数据库读写分离有两种方案 1.应用层 http://neoremind.net/2011/06/spring实现数据库读写分离 目前的一些解决方案需要在程序中手动指定数据源,比较麻烦,后边我会通过AOP思想来解决这个问题.   2.中间件 mysql-proxy:http://hi.baidu.com/

Spring Boot 整合 Mybatis 实现 Druid 多数据源详解

本文提纲一.多数据源的应用场景二.运行 springboot-mybatis-mutil-datasource 工程案例三.springboot-mybatis-mutil-datasource 工程代码配置详解 一.多数据源的应用场景 目前,业界流行的数据操作框架是 Mybatis,那 Druid 是什么呢? Druid 是 Java 的数据库连接池组件.Druid 能够提供强大的监控和扩展功能.比如可以监控 SQL ,在监控业务可以查询慢查询 SQL 列表等.Druid 核心主要包括三部分:

Spring Boot下配置MyBatis多数据源

Spring Boot最大的特点是简化开发,因此使用Java Config实现去xml配置,本文将使用这种方式完成对阿里云ADS和RDS两个产品的多数据源配置.同时,会用到阿里巴巴的开源数据源Druid. 依赖 因为ADS和RDS都兼容mysql的JDBC实现,因此工程只需要依赖mysql的driver. Spring Boot易用性的特点是通过Starter实现的,我们只需依赖mybatis的spring-boot-starter即可. Druid是数据源. <dependency> <

Spring多数据源分布式事务管理/springmvc+spring+atomikos[jta]+druid+mybatis

项目进行读写分离及分库分表,在一个业务中,在一个事务中处理时候将切换多个数据源,需要保证同一事务多个数据源数据的一致性.此处使用atomikos来实现:最后附源码: 1:spring3.0之后不再支持jtom[jta]了,第三方开源软件atomikos(http://www.atomikos.com/)来实现．  2:org.springframework.transaction.jta.JotmFactoryBean类,spring-tx-2.5.6.jar中有此类,spring-tx-3.0

spring boot整合mybatis+mybatis-plus

Spring boot对于我来说是一个刚接触的新东西,学习过程中,发现这东西还是很容易上手的,Spring boot没配置时会默认使用Spring data jpa,这东西可以说一个极简洁的工具,可是我还是比较喜欢用mybatis,工具是没有最好的,只有这合适自己的. 说到mybatis,最近有一个很好用的工具--------mybatis-Plus(官网),现在更新的版本是2.1.2,这里使用的也是这个版本.我比较喜欢的功能是代码生成器,条件构造器,这样就可以更容易的去开发了. mybatis

Spring Boot 动态数据源（Spring 注解数据源）

本文实现案例场景: 某系统除了需要从自己的主要数据库上读取和管理数据外,还有一部分业务涉及到其他多个数据库,要求可以在任何方法上可以灵活指定具体要操作的数据库. 为了在开发中以最简单的方法使用,本文基于注解和AOP的方法实现,在spring boot框架的项目中,添加本文实现的代码类后,只需要配置好数据源就可以直接通过注解使用,简单方便. 一配置二使用1. 启动类注册动态数据源2. 配置文件中配置多个数据源3. 在需要的方法上使用注解指定数据源 1.在启动类添加 @Import({Dynamic

Spring boot Mybatis

最近刚接触Spring boot,正是因为他的及简配置方便开发,促使我下定决心要用它把之前写的项目重构,那么问题来了,spring boot怎么整合mybatis呢,下面几个配置类来搞定. 在我的代码当中是实现了数据库读写分离的,所以代码仅做参考,如有需要可以加我微信:benyzhous [后续更新]   1.文件结构       DataBaseConfiguration.java用来获取数据库连接配置信息,配置从application.properties中读取   MybatisConfi