geek的技术日志,记录每一次技术思考的闪光点。

SpringBoot项目中SpringDataJpa框架下配置MySQL的读写分离

前言:关于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.测试用类: 自己去写就好了

总结: 两大点。一是配置好多数据源。二是配置好不同的数据库操作去不同的数据源上面执行(如读的到从库,写的到主库)。一般是配置个AOP切面,在不同的方法执行前定义好其数据源。这样的好处就是,原来读写不分离时写的代码,完全不需要修改,读写不分离的代码改成读写分离,就是加上多数据源配置和多写个AOP就完事了。 打赏作者

未经允许不得转载:极客技术 » SpringBoot项目中SpringDataJpa框架下配置MySQL的读写分离

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址