查看: 1375|回复: 0

[Mysql数据库] 自定义注解完成数据库切库

发表于 2018-2-15 08:00:00
前提

这几天,学员们反馈希望学习一下自定义注解,正好准备高并发课程内容里有一块涉及到使用自定义注解完成数据库切库的内容。这里单独写一篇文章记录说明一下。

为什么会有数据库切库一说

首先,许多项目都有主库与从库,有的主库后面甚至会有很多个从库,主从库之间的通常同步也很快,这为数据库切库提供了一个基础,因为可以去不同的数据库查询,得到相同的结果(如果不同的数据库是完全不同的,这个不在我们这篇文章讨论的范围之内,那个属于让项目支持多个数据源)

其次,随着项目越来越大、操作的用户越来越多,对数据库的请求操作越来越多,很容易想到的是将读写请求分开,将写请求交给主库处理,读请求直接从某个从库读取。这样可以极大的减少大量对主库的请求,提升主库的性能。

接下来具体说一下如何通过自定义注解完成切库(代码使用springboot实现):

第一步、定义我们自己的切库注解类

自定义注解有几点需要注意:

1)@Target 是作用的目标,接口、方法、类、字段、包等等,具体看:ElementType

2)@Retention 是注解存在的范围,RUNTIME代表的是注解会在class字节码文件中存在,在运行时可以通过反射获取到,具体看:RetentionPolicy

3)允许的变量,通常都要给定默认值,比如我们使用一个service时,可以@Service,也可以@Service("xxxx")

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({
  3. ElementType.METHOD
  4. })
  5. public @interface RoutingDataSource {
  6. String value() default DataSources.MASTER_DB;
  7. }
复制代码
第二步、定义需要使用的数据库及配置

1、数据库配置:application.properties,这里要注意不同db的前缀区别

  1. ## datasource master #
  2. spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
  3. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  4. spring.datasource.url=jdbc:mysql://localhost:3306/master?characterEncoding=UTF-8
  5. spring.datasource.username=root
  6. spring.datasource.password=466420182
  7. ## datasource slave #
  8. spring.datasourceSlave.type=com.alibaba.druid.pool.DruidDataSource
  9. spring.datasourceSlave.driver-class-name=com.mysql.jdbc.Driver
  10. spring.datasourceSlave.url=jdbc:mysql://localhost:3306/slave?characterEncoding=UTF-8
  11. spring.datasourceSlave.username=root
  12. spring.datasourceSlave.password=466420182
复制代码

2、定义支持的数据源id:

  1. public interface DataSources {
  2. String MASTER_DB = "masterDB";
  3. String SLAVE_DB = "slaveDB";
  4. }
复制代码

3、定义数据库实体类并配置为多数据源的形式

这里不要忽略了通过 MapperScan 指定需要扫描的mybatis的接口类

  1. @Configuration
  2. public class DatasourceConfig {
  3. //destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用.
  4. @Bean(destroyMethod = "close", name = DataSources.MASTER_DB)
  5. @ConfigurationProperties(prefix = "spring.datasource")
  6. public DataSource dataSource() {
  7. return DataSourceBuilder.create().type(DruidDataSource.class).build();
  8. }
  9. @Bean(destroyMethod = "close", name = DataSources.SLAVE_DB)
  10. @ConfigurationProperties(prefix = "spring.datasourceSlave")
  11. public DataSource dataSourceSlave() {
  12. return DataSourceBuilder.create().type(DruidDataSource.class).build();
  13. }
  14. }
复制代码

4、配置成动态数据源:

  1. @Configuration
  2. @MapperScan(basePackages = {"com.xxx.dao"}) // 这里需要替换为实际的路径
  3. public class MybatisConfig {
  4. @Autowired
  5. @Qualifier(Datasources.MASTER_DB)
  6. private DataSource masterDB;
  7. @Autowired
  8. @Qualifier(DataSources.SLAVE_DB)
  9. private DataSource slaveDB;
  10. /**
  11. * 动态数据源
  12. */
  13. @Bean(name = "dynamicDataSource")
  14. public DataSource dynamicDataSource() {
  15. DynamicDataSource dynamicDataSource = new DynamicDataSource();
  16. // 默认数据源
  17. dynamicDataSource.setDefaultTargetDataSource(masterDB);
  18. // 配置多数据源
  19. Map<Object, Object> dsMap = Maps.newHashMap();
  20. dsMap.put(DataSources.MASTER_DB, masterDB);
  21. dsMap.put(DataSources.SLAVE_DB, slaveDB);
  22. dynamicDataSource.setTargetDataSources(dsMap);
  23. return dynamicDataSource;
  24. }
  25. @Bean
  26. @ConfigurationProperties(prefix = "mybatis")
  27. public SqlSessionFactoryBean sqlSessionFactoryBean() {
  28. SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
  29. // 配置数据源,此处配置为关键配置,如果没有将 dynamicDataSource 作为数据源则不能实现切换
  30. sqlSessionFactoryBean.setDataSource(dynamicDataSource());
  31. return sqlSessionFactoryBean;
  32. }
  33. }
复制代码
第三步、使用ThreadLocal安全的管理当前进程使用的数据源连接
  1. @Slf4j
  2. public class DataSourceContextHolder {
  3. /**
  4. * 默认数据源
  5. */
  6. public static final String DEFAULT_DATASOURCE = DataSources.MASTER_DB;
  7. private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
  8. // 设置数据源名
  9. public static void setDB(String dbType) {
  10. log.debug("切换到{}数据源", dbType);
  11. contextHolder.set(dbType);
  12. }
  13. // 获取数据源名
  14. public static String getDB() {
  15. return (contextHolder.get());
  16. }
  17. // 清除数据源名
  18. public static void clearDB() {
  19. contextHolder.remove();
  20. }
  21. }
复制代码
第四步、通过编写切面,对所有我们自定义切库注解的方法进行拦截,动态的选择数据源

这里是为下一步提供铺垫,动态调整DataSourceContextHolder里存储的值,使用threadLocal来管理是为了避免多线程之间互相影响。

自定义注解,核心的处理就是写处理这个注解的逻辑,然后通过指定的拦截方案根据当前的数据做一些动态的处理。比如Spring提供的@Controller、@Service等注解,都是需要我们在配置文件里配置好需要扫描的路径,然后项目启动时,spring根据配置去指定路径读取这些配置,然后这些类才可以被spring进行管理。

这里不要忽略了默认数据源要选择主库,如果切库出现什么问题,比如配置错误等,可以保证访问主库来得到正确的结果;另外,请求完了不要忘记调用提供的clearDB的操作,防止threadLocal误用带来的内存泄露。

  1. @Aspect
  2. @Component
  3. @Slf4j
  4. public class DynamicDataSourceAspect {
  5. @Before("@annotation(RoutingDataSource)")
  6. public void beforeSwitchDS(JoinPoint point){
  7. //获得当前访问的class
  8. Class<?> className = point.getTarget().getClass();
  9. //获得访问的方法名
  10. String methodName = point.getSignature().getName();
  11. //得到方法的参数的类型
  12. Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
  13. String dataSource = DataSourceContextHolder.DEFAULT_DATASOURCE;
  14. try {
  15. // 得到访问的方法对象
  16. Method method = className.getMethod(methodName, argClass);
  17. // 判断是否存在@DS注解
  18. if (method.isAnnotationPresent(RoutingDataSource.class)) {
  19. RoutingDataSource annotation = method.getAnnotation(RoutingDataSource.class);
  20. // 取出注解中的数据源名
  21. dataSource = annotation.value();
  22. }
  23. } catch (Exception e) {
  24. log.error("routing datasource exception, " + methodName, e);
  25. }
  26. // 切换数据源
  27. DataSourceContextHolder.setDB(dataSource);
  28. }
  29. @After("@annotation(RoutingDataSource)")
  30. public void afterSwitchDS(JoinPoint point){
  31. DataSourceContextHolder.clearDB();
  32. }
  33. }
复制代码
第五步、动态的取出我们在切面里设置的数据源的字符串即可

这里需要把原理介绍一下,在连接数据库时其实是先选择一个配置好的spring管理的datasource的id,就是我们之前在 DatasourceConfig 类里定义的Datasource实体类的id:masterDB 和 slaveDB。然后根据id去spring的上下文选择配置,进行数据库连接。有兴趣的可以看一下源码。

  1. @Slf4j
  2. public class DynamicDataSource extends AbstractRoutingDataSource {
  3. @Override
  4. protected Object determineCurrentLookupKey() {
  5. log.debug("数据源为{}", DataSourceContextHolder.getDB());
  6. return DataSourceContextHolder.getDB();
  7. }
  8. }
复制代码
使用

如何使用呢,我们简单演示一下:

  1. @Service
  2. public class DataSourceRoutingService {
  3. @Resource
  4. private SysUserMapper sysUserMapper;
  5. @RoutingDataSource(DataSources.MASTER_DB) // 这个注解这时是可以省略,因为默认就是访问主库
  6. public SysUser test1(int id) {
  7. return sysUserMapper.selectByPrimaryKey(id);
  8. }
  9. @RoutingDataSource(DataSources.SLAVE_DB)
  10. public SysUser test2(int id) {
  11. return sysUserMapper.selectByPrimaryKey(id);
  12. }
  13. }
复制代码

如此,数据库切库就OK了。如果你的系统已经有主库、从库之分了,那么赶紧在你的系统里利用起来吧。

扩展

这里呢,还可以支持多个扩展。比如现在一个主库后面有多个从库,在切面拿到需要切换从库时,还可以选择随机选择一个,或者根据类名、方法名或业务配置等选择某一个从库,这样不但可以分担每个从库的压力,也可以有针对性的让指定的读请求打到指定的从库上。如果有多个主库,也可以有更多的选择~

本文转载自:http://url.cn/5ewMEc1



回复

使用道具 举报