springBoot+mybatisPlus+druid 实现多数据源+分页

mybatisPlus+druid实现多数据源

只需要复制下面的5个文件，放到项目任意地方。
再修改yml文件，即可使用多数据源，访问对应mapper自动切换数据源，无需其他设置。
5个配置文件只需要修改其中两个文件的mapper包名和mapper.xml地址.其他可以直接照搬。使用简单。


开始~~~~
自己创建springboot项目，先上pom.xml

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

<!--        aop多数据源要用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- 阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!-- 提供mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <!-- lombok 省去get/set -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.26</version>
            <scope>provided</scope>
        </dependency>
<!--        实体类注释需要 ApiModel-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <!--        json-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.2</version>
        </dependency>

然后是yml文件，你改成properties也可以。

spring:
  datasource:
    druid:
      db1:
        url: jdbc:mysql://127.0.0.1:3306/test1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
        username: root
        password: 123456
        driver-class-name: com.mysql.cj.jdbc.Driver
      db2:
        url: jdbc:mysql://127.0.0.1:3306/test2?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
        username: root
        password: 123456
        driver-class-name: com.mysql.cj.jdbc.Driver
      #初始连接数 默认0
      initial-size: 10
      #最大连接数，默认8
      max-active: 30
      #最小闲置数
      min-idle: 10
      #获取连接的最大等待时间，单位毫秒
      max-wait: 2000

#mybatis-plus:
#  configuration:
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 打印SQL

下面5个是多数据源的配置相关文件。
DataSourceAspect.java,需要注意，这里就是mapper.java文件对应数据源的地方，更改@Pointcut里的mapper路径。 多数据源下存放mapper.java的目录需要单独创建文件夹。

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(-100)
@Slf4j
@Aspect
public class DataSourceAspect {

    @Pointcut("execution(* com.example.datasource.mapper..*.*(..))")
    private void db1Aspect() {
    }


    @Pointcut("execution(* com.example.datasource.mapper2..*.*(..))")
    private void db2Aspect() {
    }

    @Before("db1Aspect()")
    public void db1DataSource() {

        log.info("切换数据源为：{}", DataSourceTypeEnum.db1DataSource.getValue());
        DataSourceContextHolder.setDataSourceType(DataSourceTypeEnum.db1DataSource);
    }

    @Before("db2Aspect()")
    public void db2DataSource() {
        log.info("切换数据源为：{}", DataSourceTypeEnum.db2DataSource.getValue());
        DataSourceContextHolder.setDataSourceType(DataSourceTypeEnum.db2DataSource);
    }

}

DataSourceContextHolder.java

public class DataSourceContextHolder {


    private static final ThreadLocal CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源
     *
     * @param dataSourceTypeEnum
     */
    public static void setDataSourceType(DataSourceTypeEnum dataSourceTypeEnum) {
        CONTEXT_HOLDER.set(dataSourceTypeEnum.getValue());
    }

    /**
     * 取得当前数据源
     *
     * @return
     */
    public static String getDataSourceType() {
        return (String) CONTEXT_HOLDER.get();
    }

    /**
     * 清除上下文数据
     *
     * @return
     */
    public static void clearDataSourceType() {
        CONTEXT_HOLDER.remove();
    }
}

DataSourceTypeEnum.java

public enum DataSourceTypeEnum {

    /**
     * mysql数据源源
     */
    db1DataSource("db1DataSource"),
    /**
     * postgresql数据源
     */
    db2DataSource("db2DataSource");

    private String value;

    DataSourceTypeEnum(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

DynamicDataSource.java

import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {

    /**
     * @description:  动态数据源决策
     * @param: null
     * @return:
     * @author
     * @date: 2021/6/16 11:09
     */
    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceType = DataSourceContextHolder.getDataSourceType();
        log.info("当前数据源为：{}", dataSourceType);
        return dataSourceType;
    }
}

MybatisPlusConfig.java,这个需要注意，更改类上面的@MapperScan注释，改成对应数据源的mapper路径，更改sqlSessionFactory方法的mapper.xml文件路径。
如果要使用分页，需要手动把分页插件配置到sqlsession里 如果不注入则分页插件不生效

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@EnableTransactionManagement
@Configuration
@MapperScan("com.tx.ether.mapper")
@MapperScan("com.tx.ether.mapper2")
public class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //如果是别的数据库自己选择枚举里面的
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }


    /**
     * mysql数据源
     * @return 1
     */
    @Bean("db1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.druid.db1")
    public DataSource db1DataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 数据源2
     *
     * @return 1
     */
    @Bean("db2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.druid.db2")
    public DataSource db2DataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * @description: 动态数据源配置
     * @param: db1DataSource mysql数据源，db2DataSource postgresql数据源
     * @return:
     * @author czl
     * @date: 2021/6/16 11:02
     */
    @Bean
    @Primary
    public DataSource multipleDataSource(@Qualifier("db1DataSource") DataSource db1DataSource, @Qualifier("db2DataSource") DataSource db2DataSource) {
        /** 创建动态数据源决策者 */
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        /** 存放多个数据源 */
        Map<Object, Object> targerDataSource = new HashMap<>(16);
        targerDataSource.put(DataSourceTypeEnum.db1DataSource.getValue(), db1DataSource);
        targerDataSource.put(DataSourceTypeEnum.db2DataSource.getValue(), db2DataSource);
        /** 讲多个数据源注入targetDataSources */
        dynamicDataSource.setTargetDataSources(targerDataSource);
        /** 默认数据源 */
        dynamicDataSource.setDefaultTargetDataSource(db1DataSource);
        return dynamicDataSource;
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        /** 创建mybatis中的sqlSessionFactoryBean工厂 */
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        /** 向sqlSessionFactoryBean工厂中注入数据源 */
        sqlSessionFactory.setDataSource(this.multipleDataSource(db1DataSource(), db2DataSource()));
//        设置mapper的xml路径
        sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mappers/*.xml"));
        /** 创建MybatisConfiguration */
        MybatisConfiguration mybatisConfiguration = new MybatisConfiguration();
        mybatisConfiguration.setJdbcTypeForNull(JdbcType.NULL);
        /** 开启驼峰命名规则 */
        mybatisConfiguration.setMapUnderscoreToCamelCase(true);
        /** 是否开启缓存 */
        mybatisConfiguration.setCacheEnabled(false);
        sqlSessionFactory.setConfiguration(mybatisConfiguration);
//        这里需要手动把分页插件配置到sqlsession里 如果不注入则分页插件不生效
        sqlSessionFactory.setPlugins(mybatisPlusInterceptor());
        return sqlSessionFactory.getObject();
    }
}

到这里就可以了，多数据源只需要访问对应的mapper就可以了，
Controller访问对应的Service，Service继承对应mapper。

import com.example.datasource.entity.UserInfo;
import com.example.datasource.mapper.UserInfoMapper;
import com.example.datasource.service.IUserInfoService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wto
 * @since 2023-03-23
 */
@Service
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements IUserInfoService {

    @Override
    public List<UserInfo> selectUserInfo() {
        return baseMapper.selectUserInfo();
    }

//分页功能
        @Override
    public List<UserInfo> userListPage(int pageNum, int pageSize) {
        Page<UserInfo> page= new Page<>(pageNum,pageSize);
        LambdaQueryWrapper<UserData> queryWrapper = new LambdaQueryWrapper<>();
        //是否置顶进行排序 创建日期排序
        queryWrapper.orderByDesc(UserData::getCreateTime);
        Page<UserInfo> page1 = baseMapper.selectPage(page, queryWrapper);
        return page1.getRecords();
    }

}

分页实现：

其他就是基本了，自己写了，难得上传了。留一个项目目录。

 结束~~~~~

如果有什么问题，欢迎大佬指正，最后如果对你有一点点帮助，麻烦支持一下。

全国寄快递5元起，电影票8.8折。更多优惠微信关注公众号：【折价寄件】

感谢观看！！！！