springboot整合mybatis_plus配置多数据源aop方式的问题

喜欢ヅ旅行 2021-10-19 11:50 343阅读 0赞

刚转springboot还不熟悉，想配置双数据源，看来下网上大家写的一些，很多都是利用AOP的方式去切换数据源。实现思路如下：（最终结果是实现了主从但不支持从库事务，如需完美的下文就帮不到你了，不过里面有好多问题一定是你遇到过的，也可以排排坑）

注：如果想要正常的请看下一篇博客springboot实现多数据源方法二。

1、在yum中配置自定义的多数据源的url、username、password等

spring:
      datasource:
        druid:
          first:
            url: jdbc:mysql://10.0.0.0:3306/xxx?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
            username: root
            password: root
            initial-size: 5
            max-active: 60
            max-wait: 60000
            min-idle: 5
            time-between-eviction-runs-millis: 60000
            min-evictable-idle-time-millis: 300000
            filters: mergeStat,wall
          second:
            url: jdbc:mysql://10.0.0.0:3306/xxx2?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
            username: root
            password: root
            initial-size: 5
            max-active: 60
            max-wait: 60000
            min-idle: 5
            time-between-eviction-runs-millis: 60000
            min-evictable-idle-time-millis: 300000
            filters: mergeStat,wall

2、创建多数据配置文件（配置多个datasource、配置DynamicDataSource、配置SqlSessionFactoryBean等）

@Configuration
    public class DataSourceConfig {
    
        @Bean(name = "database1")
        @ConfigurationProperties("spring.datasource.druid.first")
        public DataSource initDataSource() {
            DruidDataSource source = new DruidDataSource();
            return source;
        }
    
        @Bean(name = "database2")
        @ConfigurationProperties("spring.datasource.druid.second")
        public DataSource initDataSource2() {
            DruidDataSource source = new DruidDataSource();
            return source;
        }
    
        @Bean(name = "datasource")
        @Primary//这个一定要加
        public DynamicDataSource dynamicDataSource(@Qualifier(value = "database1") DataSource firstDatasource,
                                                   @Qualifier(value = "database2") DataSource secondDatasource) {
            DynamicDataSource bean = new DynamicDataSource();
            Map<Object, Object> targetDataSources = new HashMap<>();
            targetDataSources.put("database1", firstDatasource);
            targetDataSources.put("database2", secondDatasource);
            bean.setTargetDataSources(targetDataSources);
            bean.setDefaultTargetDataSource(firstDatasource);
            return bean;
        }
    
        @Bean(name = "SqlSessionFactoryBean")
        public SqlSessionFactoryBean sqlSessionFactory(
                @Qualifier(value = "datasource") DynamicDataSource dataSource) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            // 扫描相关mapper文件
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            String packageSearchPath = PathMatchingResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "mapper/**/*.xml";
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources(packageSearchPath));
            // 调用dataSource
            sqlSessionFactoryBean.setDataSource(dataSource);
            // 映射实体类 typeAliasesPackage 默认只能扫描某一个路径下，或以逗号等分割的 几个路径下的内容，不支持通配符和正则
            sqlSessionFactoryBean.setTypeAliasesPackage("com.xlkh.boot");
            return sqlSessionFactoryBean;
        }
    
    }

3、创建相关类：

创建DynamicDataSource实现AbstractRoutingDataSource冲写determineCurrentLookupKey方法用来选择使用哪个数据库。

public class DynamicDataSource extends AbstractRoutingDataSource {
    
        /**
         * 取得当前使用哪个数据源
         *
         * @return
         */
        @Override
        protected Object determineCurrentLookupKey() {
            return DbContextHolder.getDbType();
        }
    
    }

在源码中可以看到是在datasources中根据key获取到datasources

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzZDM3MjUwNjU4OQ_size_16_color_FFFFFF_t_70][]

创建一个DbContextHolder，用来获取和设置数据源

public class DbContextHolder {
        private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
    
        /**
         * 设置数据源
         *
         * @param dbTypeEnum
         */
        public static void setDbType(DBTypeEnum dbTypeEnum) {
            contextHolder.set(dbTypeEnum.getValue());
            System.out.println("内部set："+contextHolder.get());
        }
    
        /**
         * 取得当前数据源
         *
         * @return
         */
        public static String getDbType() {
            System.out.println("内部get："+contextHolder.get());
            return contextHolder.get();
        }
    
        /**
         * 清除上下文数据
         */
        public static void clearDbType() {
            contextHolder.remove();
        }
    }

创建一个枚举存放数据源

public enum DBTypeEnum {
        FIRSTDATASOURCE("database1"),
        SECONDDATASOURCE("database2");
    
        private String value;
    
        DBTypeEnum(String value) {
            this.value = value;
        }
    
        public String getValue() {
            return value;
        }
    }

创建一个AOP来负责选择数据库

@Component
    @Aspect
    @Order(-1000)
    public class DataSourceInterceptor {
    
        @Pointcut(value = "execution(public * com.boot.service..*.*(..))")
        private void firstServicePointcut() {
        }
    
        @Pointcut(value = "execution(public * com.boot.service2..*.*(..))")
        private void secondServicePointcut() {
        }
    
        /**
         * 切换数据源1
         */
        @Before("firstServicePointcut()")
        public void firstDataSourceInterceptor() {
            System.out.println("切换到数据源{}..............................firstDataSource");
            DbContextHolder.setDbType(DBTypeEnum.FIRSTDATASOURCE);
            System.out.println(DbContextHolder.getDbType());
        }
    
        /**
         * 切换数据源2
         */
        @Before("secondServicePointcut()")
        public void secondDataSourceInterceptor() {
            System.out.println("切换到数据源{}..............................secondDataSource");
            DbContextHolder.setDbType(DBTypeEnum.SECONDDATASOURCE);
            System.out.println(DbContextHolder.getDbType());
        }
    }

4、我的问题

这样基本就完成了数据库的切换，看起来是没有问题的。但是跑起来会发现第二个库的事务是失效的。dubug走下发现使用事务注解@Transactional在执行的时候会先选择一次数据库。而且优先级是高于我们自定义的aop的。导致事务注解执行了而数据库没有被切换会使用默认的第一个库。determineCurrentLookupKey部分为null。

/**
    	 * Retrieve the current target DataSource. Determines the
    	 * {@link #determineCurrentLookupKey() current lookup key}, performs
    	 * a lookup in the {@link #setTargetDataSources targetDataSources} map,
    	 * falls back to the specified
    	 * {@link #setDefaultTargetDataSource default target DataSource} if necessary.
    	 * @see #determineCurrentLookupKey()
    	 */
    	protected DataSource determineTargetDataSource() {
    		Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
    		Object lookupKey = determineCurrentLookupKey();
    		DataSource dataSource = this.resolvedDataSources.get(lookupKey);
    		if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
    			dataSource = this.resolvedDefaultDataSource;
    		}
    		if (dataSource == null) {
    			throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
    		}
    		return dataSource;
    	}

1) @Transactional对databases选择的操作结束后进入我们的自定义aop中，更改了datasource。但是数据库的选择在之前已经结束了。aop更改后，sql执行并不会选择我们想要的数据库而是默认的数据库。

所以我们考虑将自定义的aop优先于事务执行。

2) 使用@Order数据，order中的值越低优先级越高(支持负数)。

在自定义aop中@Order(-1000)，在springboot的启动类上@EnableTransactionManagement(order = 0)配置完之后发现根本没有生效.

3) 再接着看事务的默认模式是proxy@EnableTransactionManagement(order = 0,mode = AdviceMode.PROXY)，而我们自定义的aop属于aspect。接着我们将事务的模式更改为aspect@EnableTransactionManagement(order = 0,mode = AdviceMode.ASPECTJ)。之后直接报错了。

4）发现少包，接着引入spring-aspects与aspectjweaver

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
            </dependency>

5）引入包之后发现order数据的确是可以用了。自定义aop与事务的优先级更改了。但是接着发现事务的注解根本不起作用了，发现源码中TransactionAspectSupport类中的invokeWithinTransaction根本不执行了。下面断点不进入。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzZDM3MjUwNjU4OQ_size_16_color_FFFFFF_t_70 1][]

6）发现变更mode之后需要配置Advisor类，接着又写bean配置文件如下

@Aspect
    @Configuration
    public class GlobalTransactionAdviceConfig {
        private static final String AOP_POINTCUT_EXPRESSION = "execution (* com.boot.service2..*.*(..))";
    
        @Autowired
        private PlatformTransactionManager transactionManager;
    
        @Bean
        public TransactionInterceptor txAdvice() {
            DefaultTransactionAttribute txAttr_REQUIRED = new DefaultTransactionAttribute();
            txAttr_REQUIRED.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    
            DefaultTransactionAttribute txAttr_REQUIRED_READONLY = new DefaultTransactionAttribute();
            txAttr_REQUIRED_READONLY.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
            txAttr_REQUIRED_READONLY.setReadOnly(true);
    
            NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();
            source.addTransactionalMethod("add*", txAttr_REQUIRED);
            source.addTransactionalMethod("insert*", txAttr_REQUIRED);
            source.addTransactionalMethod("save*", txAttr_REQUIRED);
            source.addTransactionalMethod("create*", txAttr_REQUIRED);
            source.addTransactionalMethod("delete*", txAttr_REQUIRED);
            source.addTransactionalMethod("update*", txAttr_REQUIRED);
            source.addTransactionalMethod("exec*", txAttr_REQUIRED);
            source.addTransactionalMethod("set*", txAttr_REQUIRED);
            source.addTransactionalMethod("test*", txAttr_REQUIRED);
            source.addTransactionalMethod("get*", txAttr_REQUIRED_READONLY);
            source.addTransactionalMethod("query*", txAttr_REQUIRED_READONLY);
            source.addTransactionalMethod("find*", txAttr_REQUIRED_READONLY);
            source.addTransactionalMethod("list*", txAttr_REQUIRED_READONLY);
            source.addTransactionalMethod("count*", txAttr_REQUIRED_READONLY);
            source.addTransactionalMethod("is*", txAttr_REQUIRED_READONLY);
            source.addTransactionalMethod("select*", txAttr_REQUIRED_READONLY);
            return new TransactionInterceptor(transactionManager, source);
        }
    
        @Bean
        public Advisor txAdviceAdvisor() {
            AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
            pointcut.setExpression(AOP_POINTCUT_EXPRESSION);
            return new DefaultPointcutAdvisor(pointcut, txAdvice());
        }
    }

7） 这回事务一切都可以按照我们想要的顺序执行了。但是事务还是不能回滚。这回是真心看不下去了。

最终成果是数据库可以切换，从库事务不生效。将aop改成正对dao层去切入更改数据库。现在这个版本只针对主从库，主库增删，从库查询这种模式剩下。要想主从事务都可用，我用这种AOP的方式还真没搞定，还是自己才疏学浅。java路上还要继续学习。以上就是利用aop方式实现多库的进展和问题。以后如果有机会再回头看看这个问题~~~

有大牛看到希望指定我一二。。。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzZDM3MjUwNjU4OQ_size_16_color_FFFFFF_t_70]: /images/20211018/f018ff6ea66743d990fac2fa86e359ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzZDM3MjUwNjU4OQ_size_16_color_FFFFFF_t_70 1]: /images/20211018/ee5aa95a061f411f81fff4856ee670fa.png