Idea Springboot2.2+MybatisPlus+Druid整合多数据源及多module项目

最新推荐文章于 2024-06-08 14:56:49 发布

mr_foxsand

最新推荐文章于 2024-06-08 14:56:49 发布

阅读量1.3k

点赞数

文章标签： springboot动态数据源切换

本文链接：https://blog.csdn.net/mr_foxsand/article/details/103788638

版权

技术参考文档：https://www.cnblogs.com/SimpleWu/p/10930388.html【转载请说明出处】。

谢绝任何商业转载

项目结构规划：

技术选型：

1. Springboot + druid + MybatisPlus + dynamic-datasource-spring-boot-starter(动态切换数据源核心)

2. 数据库：Oracle 、MySql

使用dynamic-datasource的优势：

网上关于动态数据源的切换的文档有很多，核心只有两种。

构建多套环境，优势是方便控制也容易集成一些简单的分布式事务，缺点是非动态同时代码量较多,配置难度大。
基于spring提供原生的 AbstractRoutingDataSource ，参考一些文档自己实现切换。

如果你的数据源较少，场景不复杂，选择以上任意一种都可以。如果你需要更多特性，请尝试本动态数据源。

数据源分组，适用于多种场景纯粹多库读写分离一主多从混合模式。
简单集成Druid数据源监控多数据源，简单集成Mybatis-Plus简化单表，简单集成P6sy格式化sql，简单集成Jndi数据源。
简化Druid和HikariCp配置，提供全局参数配置。
提供自定义数据源来源(默认使用yml或properties配置)。
项目启动后能动态增减数据源。
使用spel动态参数解析数据源，如从session，header和参数中获取数据源。（多租户架构神器）
多层数据源嵌套切换。（一个业务ServiceA调用ServiceB，ServiceB调用ServiceC，每个Service都是不同的数据源）
使用正则匹配或spel表达式来切换数据源（实验性功能）。

以上是原文作者的分析，其实对于我来说，最大的好处就是无需修改代码，仅修改springboot配置文件即可实现数据库的增减修改修改！

一、创建多module的空项目

1.新建spring项目

2.填写groupid等信息

3.选择springboot版本（其他信息空着）

4.设置项目存放目录等信息（这里截图是路径输入错了，应为：D:\workspace\demo），设置完成后点finish.

5.删除没有用的文件，像我这样。

6.编辑pom.xml文件（重点是: <packaging>pom</packaging>）

7.新建module

注：无用的resources可以删除（根据项目需求自行决定）

8.修改pom.xml文件，将需要的jar及module依赖添加进来（我的项目添加很多我常用但是项目目前用不到的jar包）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.foxsand</groupId>
    <artifactId>demo</artifactId>
    <version>${demo.version}</version>
    <name>demo</name>
    <packaging>pom</packaging>
    <description>Demo project for Spring Boot</description>

    <modules>
        <module>demo-common</module>
        <module>demo-generator</module>
        <module>demo-core</module>
    </modules>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <demo.version>0.0.1-SNAPSHOT</demo.version>
        <guava.verison>23.6-jre</guava.verison>
        <lombok.version>1.18.2</lombok.version>
        <druid.version>1.1.10</druid.version>
        <mybatisplus.version>3.1.1</mybatisplus.version>
        <swagger.version>2.7.0</swagger.version>
        <velocity.verison>1.7</velocity.verison>
        <slf4j.verison>1.7.25</slf4j.verison>
        <logback.verison>1.2.3</logback.verison>
        <testng.verison>6.14.3</testng.verison>
        <okhttp.version>3.11.0</okhttp.version>
        <fastjson.version>1.2.51</fastjson.version>
        <commons.codec.verison>1.11</commons.codec.verison>
        <core.version>3.3.0</core.version>
        <mysql.version>5.1.48</mysql.version>
        <oracle.version>11.2.0.1.0</oracle.version>
        <dynamic.version>2.5.4</dynamic.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- 动态数据源 -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
                <version>${dynamic.version}</version>
            </dependency>

            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <!--data pool druid-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>

            <!--MybatisPlus-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>

            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>

            <!--swagger-->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>${swagger.version}</version>
            </dependency>

            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger-ui</artifactId>
                <version>${swagger.version}</version>
            </dependency>

            <dependency>
                <groupId>org.apache.velocity</groupId>
                <artifactId>velocity</artifactId>
                <version>${velocity.verison}</version>
            </dependency>

            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.verison}</version>
            </dependency>

            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>${logback.verison}</version>
            </dependency>

            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback.verison}</version>
            </dependency>

            <dependency>
                <groupId>org.testng</groupId>
                <artifactId>testng</artifactId>
                <version>${testng.verison}</version>
            </dependency>

            <dependency>
                <groupId>com.squareup.okhttp3</groupId>
                <artifactId>okhttp</artifactId>
                <version>${okhttp.version}</version>
            </dependency>

            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>

            <dependency>
                <groupId>com.google.zxing</groupId>
                <artifactId>core</artifactId>
                <version>${core.version}</version>
            </dependency>

            <dependency>
                <groupId>commons-codec</groupId>
                <artifactId>commons-codec</artifactId>
                <version>${commons.codec.verison}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- mybatis plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatisplus.version}</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.verison}</version>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.verison}</version>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>${logback.verison}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

</project>

二、demo-core中编写springboot启动类

1.编辑demo-core中的pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>demo</artifactId>
        <groupId>cn.foxsand</groupId>
        <version>${demo.version}</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>demo-core</artifactId>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>cn.foxsand</groupId>
            <artifactId>demo-common</artifactId>
            <version>${demo.version}</version>
        </dependency>

        <!-- 动态数据源 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>${dynamic.version}</version>
        </dependency>

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

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

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

        <!--jdbc-->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>${oracle.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>
    </dependencies>

    <profiles>
        <profile>
            <id>dev</id>
            <activation>
                <!--默认激活-->
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <spring.profiles.active>dev</spring.profiles.active>
            </properties>
        </profile>
        <profile>
            <id>test</id>
            <properties>
                <spring.profiles.active>test</spring.profiles.active>
            </properties>
        </profile>
        <profile>
            <id>pro</id>
            <properties>
                <spring.profiles.active>pro</spring.profiles.active>
            </properties>
        </profile>
    </profiles>


</project>

2.增加yml及log日志配置文件

2.1 application.yml:

# Tomcat
server:
  tomcat:
    uri-encoding: UTF-8
    max-threads: 1000
    min-spare-threads: 30
  port: 8980
  servlet:
    context-path: /a

# Spring
spring:
  profiles:
    active: @spring.profiles.active@
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
      enabled: true

#slf4j log管理
logging:
  config: classpath:logback-spring.xml

2.2 application-dev.yml

spring:
  autoconfigure:
    #自动化配置 例外处理
    exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      #druid 监控配置
      stat-view-servlet:
        login-username: admin
        login-password: 134095
    #多数据源配置
    dynamic:
      primary: master
      datasource:
        # master 主数据库配置
        master:
          driver-class-name: oracle.jdbc.OracleDriver
          url: jdbc:oracle:thin:@192.168.3.201:1521/orcl
          username: spring
          password: MISMALL
        # slave_1 从库1 配置
        slave_1:
          driver-class-name: com.mysql.jdbc.Driver
          url: jdbc:mysql://192.168.3.202:3306/demo?useSSL=false&characterEncoding=utf8
          username: root
          password: 134095
      #dynamic - 公共配置
      druid:
        initial-size: 10
        max-active: 100
        min-idle: 10
        max-wait: 60000
        pool-prepared-statements: true
        max-pool-prepared-statement-per-connection-size: 20
        time-between-eviction-runs-millis: 60000
        min-evictable-idle-time-millis: 300000
        validation-query: SELECT 'x' from dual
        test-while-idle: true
        test-on-borrow: false
        test-on-return: false
#MybatisPlus 配置
mybatis-plus:
  mapper-locations: classpath:/mapper/**/*Dao.xml
  type-aliases-package: cn.foxsand.demo.module.**.entity
  configuration:
    #开启驼峰命名转换
    map-underscore-to-camel-case: true
    #配置JdbcTypeForNull, oracle数据库必须配置
    jdbc-type-for-null: 'null'
    #关闭缓存
    cache-enabled: false
    #指定当结果集中值为 null 的时候是否调用映射对象的 Setter（Map 对象时为 put）方法，通常运用于有 Map.keySet() 依赖或 null 值初始化的情况。
    #通俗的讲，即 MyBatis 在使用 resultMap 来映射查询结果中的列，如果查询结果中包含空值的列，则 MyBatis 在映射的时候，不会映射这个字段，这就导致在调用到该字段的时候由于没有映射，取不到而报空指针异常。
    #当您遇到类似的情况，请针对该属性进行相关配置以解决以上问题。
    call-setters-on-nulls: true
  global-config:
    db-config:
      #主键类型  AUTO:"数据库ID自增", INPUT:"用户输入ID",ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";
      id-type: INPUT
      #字段策略 IGNORED:"忽略判断",NOT_NULL:"非 NULL 判断"),NOT_EMPTY:"非空判断"
      field-strategy: NOT_NULL
      #数据库大写下划线转换
      capital-mode: true

2.3 logback-sprin.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration  scan="true" scanPeriod="10 seconds">

    <!--<include resource="org/springframework/boot/logging/logback/base.xml" />-->

    <contextName>logback</contextName>
    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
    <!--<property name="log.path" value="D:/nmyslog/nmys" />-->
    <property name="log.path" value="../logs" />

    <!-- 彩色日志(IDE下载插件才可以生效) -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>


    <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>


    <!--输出到文件-->

    <!-- 时间滚动输出 level为 DEBUG 日志 -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_debug.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 INFO 日志 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_info.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 WARN 日志 -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_warn.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>


    <!-- 时间滚动输出 level为 ERROR 日志 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_error.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>error</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
        以及指定<appender>。<logger>仅有一个name属性，
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
    -->
    <!--<logger name="org.springframework.web" level="info"/>-->
    <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
     -->


    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->

    <!--开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="cn.foxsand" level="trace"/>
    </springProfile>

    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="DEBUG_FILE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="WARN_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>

    <!--生产环境:输出到文件-->
    <!--<springProfile name="pro">-->
    <!--<root level="info">-->
    <!--<appender-ref ref="CONSOLE" />-->
    <!--<appender-ref ref="DEBUG_FILE" />-->
    <!--<appender-ref ref="INFO_FILE" />-->
    <!--<appender-ref ref="ERROR_FILE" />-->
    <!--<appender-ref ref="WARN_FILE" />-->
    <!--</root>-->
    <!--</springProfile>-->

</configuration>

2.4 编写启动类

package cn.foxsand.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("cn.foxsand.demo.module.**.dao")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }
}

三、项目测试

1. 在demo-common中写一个实体父类：BaseEntity

1.1这里为做测试，所以每个属性都用注解@Setter、@Getter生成get、set方法。实际上可以在类上加@Data注解

1.2 @NoArgsConstructor(force = true)：生成无参构造器

@TableField(exist = false)：该注解表示此属性非数据库字段

package cn.foxsand.demo.base;

import com.baomidou.mybatisplus.annotation.TableField;
import lombok.*;

import java.io.Serializable;
import java.util.Date;

@ToString
@NoArgsConstructor(force = true)
public abstract class BaseEntity<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    @Setter
    @Getter
    @NonNull
    protected String    id;
    @Setter
    @Getter
    protected String    createBy;
    @Setter
    @Getter
    protected Date      createDate;
    @Setter
    @Getter
    protected String    updateBy;
    @Setter
    @Getter
    protected Date      updateDate;
    @Setter
    @Getter
    protected String    status;
    @Setter
    @Getter
    protected String    remarks;
    @Setter
    @Getter
    protected String    corpCode;
    @Setter
    @Getter
    protected String    corpName;

    @TableField(exist = false)
    protected boolean   isNewRecord;
}

2. CreateGUIDUtil：生成GUID工具类

package cn.foxsand.demo.utils;

import java.util.UUID;

public class CreateGUIDUtil {
    private CreateGUIDUtil(){
        throw new AssertionError();
    }

    public static final String GenerateGUID(){
        UUID uuid = UUID.randomUUID();
        String guid = uuid.toString();
        return guid.replace("-" , "");
    }
}

3. 加密解密工具类

package cn.foxsand.demo.utils;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.IOException;
import java.math.BigInteger;
import java.security.MessageDigest;

public class EncryptUtil {
    private EncryptUtil() {
        throw new AssertionError();
    }

    /**
     * 将传入的字符串按指定方式加密
     * @param str
     * @param method
     * @return
     */
    private static String encode(String str , String method){
        MessageDigest md ;
        String dstr = null;
        try {
            md = MessageDigest.getInstance(method);
            md.update(str.getBytes());
            dstr = new BigInteger(1,md.digest()).toString(16);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dstr;
    }

    /**
     * 用base64算法加密
     * @param str
     * @return
     */
    public static String encodeBase64String(String str){
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(str.getBytes());
    }

    /**
     * 用base64算法加密
     * @param bytes
     * @return
     */
    public static String encodeBase64String(byte[] bytes){
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(bytes);
    }

    /**
     * 用MD5算法加密
     * @param str
     * @return
     */
    public static String encodeMD5String(String str){
        return encode(str , "MD5").toUpperCase();
    }

    /**
     * SHA算法加密
     * @param str
     * @return
     */
    public static String encodeSHAString(String str){
        return encode(str , "SHA");
    }

    /**
     * MD5加密后的字符串转Base64
     * @param str
     * @return
     */
    public static String encodeMD5ToBase64String(String str){
        return encodeBase64String(encodeMD5String(str));
    }

    /**
     * 用base64算法解密
     * @param str
     * @return
     * @throws IOException
     */
    public static String decodeBase64String(String str) throws IOException {
        BASE64Decoder encoder = new BASE64Decoder();
        return new String(encoder.decodeBuffer(str));
    }
}

4. demo-core中测试多数据源动态切换：

4.1 实体类：User

package cn.foxsand.demo.module.entity;

import cn.foxsand.demo.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;


@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@TableName(value = "sys_user")
public class User extends BaseEntity {
    private String loginCode;
    private String userName;
    private String password;
    private String userType;
    private String mgrType;
}

4.2 mapper接口:UserDao(个人习惯于用Dao结尾)

package cn.foxsand.demo.module.dao;

import cn.foxsand.demo.module.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;


public interface UserDao extends BaseMapper<User> {
}

4.3 Service：UserService。写两个方法，分别调用不同的数据源

package cn.foxsand.demo.module.service;

import cn.foxsand.demo.module.dao.UserDao;
import cn.foxsand.demo.module.entity.User;
import cn.foxsand.demo.utils.CreateGUIDUtil;
import cn.foxsand.demo.utils.EncryptUtil;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

@Service
public class UserService extends ServiceImpl<UserDao, User> implements IService<User> {

    /**
     * 调用 master 数据源，表中插入一条数据
     * @param entity
     * @return
     */
    @DS("master")
    @Override
    public boolean save(User entity) {
        entity.setId(CreateGUIDUtil.GenerateGUID());
        entity.setLoginCode("admin");
        entity.setUserName("admin");
        entity.setPassword(EncryptUtil.encodeMD5String("134095"));
        entity.setUserType("1");
        entity.setMgrType("1");
        entity.setStatus("0");
        java.sql.Date sqlDate = new java.sql.Date(new Date().getTime());
        entity.setCreateBy("system");
        entity.setCreateDate(sqlDate);
        entity.setUpdateBy("system");
        entity.setUpdateDate(sqlDate);
        entity.setCorpCode("0");
        entity.setCorpName("Foxsand");
        return super.save(entity);
    }

    /**
     * 调用 slave_1 数据源，查看 从库 表中数据
     * @param queryWrapper
     * @return
     */
    @Override
    @DS("slave_1")
    public List<User> list(Wrapper<User> queryWrapper) {
        return super.list(queryWrapper);
    }
}

4.4 controller：UserController。项目测试，代码就不那么严谨了，大家见谅！

package cn.foxsand.demo.module.controller;

import cn.foxsand.demo.module.entity.User;
import cn.foxsand.demo.module.service.UserService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/demo")
    public String demo(){
        User user = new User();
        userService.save(user);
        QueryWrapper<User> u1 = new QueryWrapper<>();
        List<User> userList = userService.list(u1);
        for (User u2:userList
             ) {
            System.out.println(u2);
        }
        return "123";
    }
}

4.5 测试。数据库查询结果就不截图了。

前端返回结果：123

mr_foxsand

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Idea Springboot2.2+MybatisPlus+Druid整合多数据源及多module项目

技术参考文档：https://www.cnblogs.com/SimpleWu/p/10930388.html【转载请说明出处】。谢绝任何商业转载项目结构规划：技术选型：1. Springboot + druid + MybatisPlus +dynamic-datasource-spring-boot-starter(动态切换数据源核心)2.数据库：Oracle...
复制链接

扫一扫