springboot + mybatis-plus + druid

于 2025-03-04 18:27:06 发布
阅读量464 收藏 4
点赞数 7
CC 4.0 BY-SA版权
分类专栏： Spring boot+cloud java 开发 文章标签： spring boot mybatis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sszdzq/article/details/146023117

 目录架构

config

MyMetaObjectHandler.java

package com.example.config;


import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
        this.strictInsertFill(metaObject, "updateTime", Date.class, new Date());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}

controller

DetachedDemoController.java

package com.example.controller;

import com.example.Mapper.DetachedDemoMapper;
import com.example.entity.DetachedDemo;
import com.example.entity.vo.Response;
import com.example.service.DetachedDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * @author sszdzq
 */
@RequestMapping
@RestController
@Validated
public class DetachedDemoController {


    @Autowired
    private DetachedDemoService detachedDemoService;


    @PostMapping(value = "test")
    public Response test(@RequestBody DetachedDemo demo) {
        demo = new DetachedDemo().setName("test").setCreateTime(new Date());
        detachedDemoService.save(demo);
        return Response.success(demo);
    }

}

entity

vo

Response.java
package com.example.entity.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Response<T> {
    private int code; // 状态码
    private String message; // 消息
    private T data; // 数据

    // 成功响应的静态方法
    public static <T> Response<T> success(T data) {
        return new Response<>(200, "成功", data);
    }

    // 失败响应的静态方法
    public static <T> Response<T> fail(int code, String message) {
        return new Response<>(code, message, null);
    }
}

DetachedDemo.java

package com.example.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.util.Date;


@NoArgsConstructor
@AllArgsConstructor
@Data
@Accessors(chain = true)
@TableName(value = "detached_demo")
public class DetachedDemo {
    @TableId(type = IdType.AUTO)
    private String id;
    private String name;

    @TableField(fill = FieldFill.INSERT)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

}

 exception

GlobalExceptionHandler.java

package com.example.exception;


import com.example.entity.vo.Response;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.multipart.MaxUploadSizeExceededException;

import javax.validation.ConstraintViolationException;
import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * 全局异常类
 *
 * @author duwenchao
 */
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    @Value("${spring.servlet.multipart.max-file-size}")
    private String MAX_SIZE;

    /**
     * 全局异常
     *
     * @param e
     * @return
     */
    @ResponseBody
    @ResponseStatus(HttpStatus.OK)
    @ExceptionHandler(Exception.class)
    public Response handleException(Exception e) {
        String msg = "系统异常";
        if (e instanceof MaxUploadSizeExceededException) {
            msg = "文件上传大小限制为：" + MAX_SIZE;
        }
        if (e instanceof BindException) {
            msg = ((BindException) e).getBindingResult().getFieldError().getDefaultMessage();
        }
        if(e instanceof ConstraintViolationException){
            msg=e.getMessage();
        }
        e.printStackTrace();
        log.error("系统捕获异常");
        log.error(e.getMessage());
        StringWriter sw = new StringWriter();
        e.printStackTrace(new PrintWriter(sw, true));
        log.error(sw.toString());

        return  Response.fail(-1, msg);
    }
}

mapper

DetachedDemoMapper.java

package com.example.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.entity.DetachedDemo;
import org.springframework.stereotype.Repository;

/**
 * @author Lenovo
 */
@Repository
public interface DetachedDemoMapper extends BaseMapper<DetachedDemo> {
}

service

serviceimpl

DetachedDemoServiceImpl.java
package com.example.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.Mapper.DetachedDemoMapper;
import com.example.entity.DetachedDemo;
import com.example.service.DetachedDemoService;
import org.springframework.stereotype.Repository;

@Repository
public class DetachedDemoServiceImpl extends ServiceImpl<DetachedDemoMapper, DetachedDemo> implements DetachedDemoService {
    // 可实现自定义业务方法
}

 DetachedDemoService.java

package com.example.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.entity.DetachedDemo;
import org.springframework.stereotype.Service;

@Service
public interface DetachedDemoService extends IService<DetachedDemo> {
}

DetachedApplication.java

package com.example;

import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author Lenovo
 */
@SpringBootApplication
@Slf4j
@MapperScan(value = "com.example.Mapper")
public class DetachedApplication {
    public static void main(String[] args) {
        SpringApplication.run(DetachedApplication.class);
        log.info("启动成功");
    }
}

resource

application.yml

server:
  port: 19980
spring:
  application:
    name: spring detached
  datasource:
    dynamic:
      primary: master
      strict: true
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
  servlet:
    multipart:
      max-file-size: 50MB

logback-spring.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">
    <contextName>logback</contextName>

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

    <!--0. 日志格式和颜色渲染 -->
    <!-- 彩色日志依赖的渲染类 -->
    <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}}"/>

    <!--1. 输出到控制台-->
    <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>

    <!--2. 输出到文档-->
    <!-- 2.1 level为 DEBUG 日志，时间滚动输出  -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web-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}/web-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>${log.maxHistory}</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.2 level为 INFO 日志，时间滚动输出  -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web-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}/web-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>${log.maxHistory}</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.3 level为 WARN 日志，时间滚动输出  -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web-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}/web-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>${log.maxHistory}</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.4 level为 ERROR 日志，时间滚动输出  -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web-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}/web-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>${log.maxHistory}</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <appender name="MyBatis" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/MyBatisLogs/mybatis-sql.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${log.path}/MyBatisLogs/%d{yyyy-MM-dd}.-mybatis-sql.%i.log</FileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <maxHistory>${log.maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%thread|%d{yyyy-MM-dd HH:mm:ss.SSS}|%level|%logger{36}|%m%n</pattern>
        </encoder>
    </appender>
    <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>
</configuration>

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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>sring-detached</artifactId>
    <version>1.0-SNAPSHOT</version>

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


    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>2.0.9</version>
        </dependency>

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

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


        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

        <dependency>
            <groupId>commons-daemon</groupId>
            <artifactId>commons-daemon</artifactId>
            <version>1.0.13</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>

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

    </dependencies>

    <build>
        <finalName>${project.name}</finalName>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.yml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.5</version>
                <configuration>
                    <includeSystemScope>true</includeSystemScope>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

SpringBoot整合MyBatis、MyBatis-Plus、Druid
chenxingxingxing的博客
04-28 1698
我们在前web阶段学了MyBatis、MyBatis-Plus、Druid等技术，SpringBoot是如何整合这些技术的呢，下面就来总结一下整合步骤。 一、整合Mybatis 1、导入对应的start 你可以通过在pom.xml文件里面导入MyBatis与数据库驱动对应的坐标，但是springboot作为一个比较成熟的框架，它在对应版本下就已经测试好各个依赖之间版本兼容问题。系统为我们配置的依赖一定比我们手动修改的可靠，所以在创建工程时就应该导入MyBatis相应的start。就是在我们选择springw
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
hikaricp druid比较_Spring Boot整合MybatisPlus和Druid
weixin_39564368的博客
11-20 1132
在Java中，我比较ORM熟悉的只有Hibernate和Mybatis,其他的并未实践使用过，在这二者之间我更喜欢Mybatis,因为它精简、灵活(毕竟我是上年纪的程序员，喜欢自己写SQL)。刚才有提到Mybatis，但是这里的重点是介绍Mybatis-Plus，它是Mybatis的增强版，如果要了解Mybatis的细节的话请点击这里。简介据MyBatis-Plus官网介绍，MyBatis-Plu...
SpringBoot整合Mybatis-Plus、Druid配置多数据源
拾一二的博客
04-28 1万+
本文将介绍如何使用Spring Boot框架整合MyBatis和Druid多数据源，并包含以下内容： 概述Spring Boot、MyBatis和Druid 环境准备和依赖配置 配置多数据源 配置MyBatis 配置Druid连接池 使用MyBatis访问多数据源 代码实现和测试 通过本文的阅读，学习到如何使用Spring Boot框架整合MyBatis和Druid多数据源，能够帮助您更快速、更高效地开发企业级应用程序。
SpringBoot集成MyBatis-Plus&Druid
cuishujian_2003的博客
09-09 2656
MyBatis-Plus简介‌‌（简称MP）是一个基于MyBatis的增强工具，旨在简化开发过程并提高开发效率。它通过在MyBatis的基础上进行增强，而不改变MyBatis的核心功能，来实现这一目标。MyBatis-Plus的愿景是成为MyBatis最好的搭档，通过提供一系列增强功能，如无侵入性、损耗小、强大的CRUD操作等，来优化开发者的使用体验。这些特性使得MyBatis-Plus成为许多开发者在简化数据库操作时的首选工具。‌无侵入性。
SpringBoot整合Druid和Mybatis
我这孩子从小记性就不好，什么东西都要写下来才放心
07-25 6919
这里使用IntelliJIDEA2022.1.2演示个人认为IDEA用新不用旧，老有人说新版本bug多，其实呢，正在用的时候我是感知不到，相反他会在新版本修复老版本的bug，我觉得新版更好用更智能。如果你也深有其感，去拥抱新版本吧！.........
springboot+mybatis-plus+shardingsphere 实现读写分离
04-09
本项目以"springboot+mybatis-plus+shardingsphere 实现读写分离"为主题，结合了Spring Boot的快速开发能力、MyBatis-Plus的简化数据操作以及ShardingSphere的分布式数据库解决方案，旨在提高系统的读取性能和可扩展...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
04-19
用了两个多月的时间完成的：Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级开发系统，Springboot作为容器，使用mybatis作为持久层框架 使用官方推荐的thymeleaf做为模板引擎，shiro作为安全框架,主流技术 ...
springboot+swagger3+mybatis-plus3.5.1代码生成+druid+log4j2【最完美】的一次配置
12-21
在本次配置中，我们将探讨如何整合SpringBoot与Swagger3、MyBatis-Plus 3.5.1、Druid和Log4j2，打造一套高效且易维护的后台系统。 Swagger3是一个强大的API文档生成工具，它可以自动生成RESTful API接口的文档，...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar
08-12
项目描述 在上家公司自己集成的一套系统，用了两个多月的时间完成的：Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级开发系统 Springboot作为容器，使用mybatis作为持久层框架 使用官方推荐的thymeleaf做为...
SpringBoot整合Mybatis-Plus+Druid实现多数据源
FeelTouch Labs
02-26 1623
Spring Boot是一个基于Spring框架的开源Java开发框架，旨在简化Spring应用程序的开发、配置和部署。它提供了一种快速、敏捷的方式来构建独立的、生产级别的Spring应用程序，同时还提供了许多开箱即用的功能和工具，如自动配置、内嵌式Web容器、健康检查、监控和管理等。Mybatis-Plus是一个基于Mybatis的增强工具，它在Mybatis的基础上扩展了许多实用的功能，可以帮助开发人员更加高效地完成数据库操作，提高开发效率和代码质量。
springboot+druid+mybatis plus整合demo
12-13
springboot（1.5.9） + druid（1.0.2） + mybatis plus（2.1.4） 来自我的文章--springBoot整合druid+MyBatis Plus文章的附件代码
SpringBoot使用druid数据源整合mybatis(配置文件版)并实现增删改查（源码）（一个简单的例子）(没有使用逆向工程)
12-22
第一步： 导入依赖： org.springframework.boot spring-boot-starter-jdbc org.springframework.boot spring-boot-starter-web org.mybatis.spring.boot mybatis-spring-boot-starter 2.1.1 mysql mysql-connector-j
SpringBoot整合mybatis-plus+druid组件，实现增删改查
qq_27682773的博客
03-18 575
前言 本篇文章主要介绍的是SpringBoot整合mybatis-plus，实现增删改查。 GitHub源码链接位于文章底部。 建库建表 创建springboot数据库，创建t_user表，字段id主键自增，name,age。 工程结构 添加依赖 新建一个maven项目，在pom文件中添加以下依赖 <!--父级依赖，它用来提供相关的 Maven 默认依赖。 使用它之后，常用的sp...
springboot-整合mybatis、mybatis_plus和druid
weixin_51725434的博客
11-08 639
springboot-整合mybatis、mybatis_plus和druid
SpringBoot整合mybatisplus和druid
热门推荐
Venus's Blog
07-23 4万+
jdk 17如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot,spring cloud等系列文章，一系列干货随时送达!
MyBatis-Plus&Druid
qq_48609783的博客
09-03 675
MyBatis-Plus&DruidMyBatis-Plus核心功能Spring Boot 集成 Druid 数据源 MyBatis-Plus MyBatis-Plus(简称 MP) 是一个MyBatis 的增强工具,在MyBatis 的基础只做增强不做改变,为简化开发,提高效率而生 官方地址: https://mybatis.plus/ MyBatis-Plus特征 官网说的特征太多了,挑了几个有特点的分享给大家. : 无侵入:只做增强不做改变,引入他不会对现有的工程产生影响,如丝般顺滑 :损耗
MybatisPlus & druid(德鲁伊)
m0_69005620的博客
12-11 722
(opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。Druid首先是一个数据库连接池。Druid是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。
SpringBoot整合JUnit、MyBatis、MyBatis-plus、Druid详解
Learning_xzj的博客
06-15 608
Spring Boot的核心功能就是为整合第三方框架提供自动配置，SpringBoot之所以好用，就是它能方便快捷的整合其他技术，这一部分咱们就来聊聊一些技术的整合方式，通过本文的学习，大家能够感受到SpringBoot到底有多酷炫。本文将学习如下技术的整合方式： - 整合JUnit - 整合MyBatis - 整合MyBatis-Plus - 整合Druid......
springboot + mybatis-plus + druid 多数据源
最新发布
03-13
<think>好的，我现在需要帮助用户在Spring Boot项目中集成MyBatis-Plus和Druid来实现多数据源配置。首先，我要理清楚用户的需求：他们想要在应用中使用这两个技术栈，并且能够切换和管理多个数据源。接下来，我需要回忆一下相关的知识，并结合提供的引用内容来构建答案。 首先，用户提到了MyBatis-Plus和Druid，这两个都是常用的Java库。MyBatis-Plus是对MyBatis的增强，提供了很多便捷的功能，比如CRUD接口、条件构造器等。Druid是阿里巴巴开源的数据库连接池，提供了强大的监控和扩展功能。结合这两个工具，可以有效地管理数据库连接和操作。 接下来，用户需要多数据源的支持。多数据源的配置通常涉及多个数据源的实例化，以及在不同情况下切换使用不同的数据源。在Spring Boot中，默认的数据源是自动配置的，但多数据源需要手动配置，并且需要解决事务管理等问题。 根据引用[1]和[2]，用户可能需要整合sharding-jdbc-spring-boot-starter、mybatis-plus-boot-starter和druid。不过用户的问题主要集中在多数据源的切换和管理，所以可能需要分步骤讲解如何配置多个数据源，每个数据源使用Druid作为连接池，并且通过MyBatis-Plus来操作数据库。 首先，我应该考虑添加依赖。用户的项目需要引入MyBatis-Plus、Druid以及可能的动态数据源依赖，比如dynamic-datasource-spring-boot-starter，这个库可以帮助简化多数据源的配置。不过引用中没有提到这个，可能需要结合常见的做法。 然后，配置数据源信息。在application.yml中定义两个数据源，比如master和slave，分别配置它们的url、username、password等信息，并且指定使用Druid作为连接池类型。 接下来，创建数据源配置类。使用@Configuration和@Bean注解来创建两个不同的DataSource实例，并且为每个数据源配置Druid的相关属性，比如过滤器、监控统计等。同时，需要设置@Primary注解来指定主数据源。 然后，配置MyBatis-Plus。每个数据源对应的SqlSessionFactory和事务管理器需要分别配置，并且指定不同的Mapper包路径，以便区分不同数据源的DAO层。 在业务层，需要使用@DS注解（来自dynamic-datasource）来指定具体使用哪个数据源。这样在Service层的方法上添加注解即可切换数据源。 事务管理方面，需要注意每个数据源的事务管理器要正确配置，避免跨数据源事务的问题。通常，在多数据源环境下，分布式事务处理比较复杂，可能需要额外的事务管理器，但用户的问题可能暂时不需要涉及这个，可以建议在需要的时候使用JTA或其他解决方案。 最后，测试验证，确保两个数据源都能正常工作，并且能够根据注解切换。 现在，我需要检查是否有遗漏的步骤，比如是否需要在启动类上排除默认的数据源自动配置，避免冲突。另外，动态数据源的选择是否需要额外的配置，比如AOP切面或者自定义的注解处理器。 可能还需要考虑Druid监控界面的配置，让用户能够访问Druid提供的监控页面，查看数据源的状态和SQL执行情况。 总结下来，步骤应该是： 1. 添加相关依赖（MyBatis-Plus、Druid、动态数据源starter） 2. 配置多数据源信息 3. 排除默认数据源，手动配置每个数据源的Bean 4. 配置MyBatis-Plus的SqlSessionFactory和Mapper扫描 5. 使用@DS注解切换数据源 6. 配置事务管理器 7. 启用Druid监控 8. 测试验证 同时，需要提醒用户注意事务管理和连接池配置的最佳实践，比如合理设置连接池参数，监控SQL性能等。 可能的问题包括依赖冲突、配置错误导致数据源无法正确注入，或者事务不生效。需要确保每一步配置正确，并且依赖版本兼容。 最后，生成相关问题，可能涉及性能优化、监控配置、事务管理深入等方向。</think>### 分步实现Spring Boot集成MyBatis-Plus与Druid多数据源配置 #### 一、添加依赖 在`pom.xml`中引入以下依赖： ```xml <!-- MyBatis-Plus --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.2</version> </dependency> <!-- Druid连接池 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.2.16</version> </dependency> <!-- 动态数据源（支持多数据源切换） --> <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId> <version>3.5.1</version> </dependency> ``` #### 二、配置多数据源信息 在`application.yml`中定义数据源： ```yaml spring: datasource: dynamic: primary: master # 默认主数据源 strict: false # 允许非明确标注时使用主数据源 datasource: master: url: jdbc:mysql://localhost:3306/db1 username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource slave: url: jdbc:mysql://localhost:3306/db2 username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource # Druid监控配置 druid: stat-view-servlet: enabled: true url-pattern: /druid/* login-username: admin login-password: admin ``` #### 三、配置数据源与MyBatis-Plus 1. **主数据源配置类** ```java @Configuration @MapperScan(basePackages = "com.example.mapper.master", sqlSessionFactoryRef = "masterSqlSessionFactory") public class MasterDataSourceConfig { @Bean("master") @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master") public DataSource masterDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean("masterSqlSessionFactory") public SqlSessionFactory masterSqlSessionFactory(@Qualifier("master") DataSource dataSource) throws Exception { MybatisSqlSessionFactoryBean factoryBean = new MybatisSqlSessionFactoryBean(); factoryBean.setDataSource(dataSource); return factoryBean.getObject(); } @Bean("masterTransactionManager") public PlatformTransactionManager masterTransactionManager(@Qualifier("master") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } } ``` 2. **从数据源配置类**（结构与主数据源类似，替换包路径和Bean名称） #### 四、使用@DS注解切换数据源 在Service层方法上标注`@DS("slave")`： ```java @Service public class UserService { @Autowired private UserMapper userMapper; @DS("master") // 默认使用主数据源 public void addUser(User user) { userMapper.insert(user); } @DS("slave") // 切换至从数据源 public User getUserById(Long id) { return userMapper.selectById(id); } } ``` #### 五、启用Druid监控 访问`http://localhost:8080/druid`输入配置的用户名密码即可查看监控信息[^1]。 #### 六、事务管理 - 单数据源事务：使用`@Transactional`注解，默认绑定主数据源事务管理器 - 跨数据源事务：需引入分布式事务框架（如Seata）或使用JTA --- ### 注意事项 1. 确保各数据源的`Mapper`接口和`XML`文件路径隔离（如`com.example.mapper.master`和`com.example.mapper.slave`） 2. 动态数据源依赖需与MyBatis-Plus版本兼容 3. 生产环境中建议配置Druid连接池参数（如`initialSize`、`maxActive`） ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值