MyBatis-Plus+多数据源+Druid配置及应用

最新推荐文章于 2025-10-13 10:20:10 发布
原创 最新推荐文章于 2025-10-13 10:20:10 发布 · 9k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了如何在项目中配置MyBatis-Plus，包括无需XML配置的简单使用，Maven插件设置，以及如何在application.properties中配置数据源。此外，还详细讲解了多数据源插件的两种用法，一种是在properties文件中配置，另一种是动态管理数据库连接。最后，文章提到了Druid数据源的配置，包括Maven依赖、properties配置和监控器设置。

Mybatis-Plus的配置

mybatis-plus可以在不配置xml和mapper的情况下进行数据存取(优于mybatis)
(只需要建一个空的mapper接口)

  1. Maven插件

velocity-engine-core是mybatis-plus自动生成代码所依赖的模板(不用自动生成代码功能可不用)

        <dependency>
    		<groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.6</version>
		</dependency>
		<dependency>
   			<groupId>org.apache.velocity</groupId>
    		<artifactId>velocity-engine-core</artifactId>
    		<version>2.2</version>
		</dependency>
  1. application.properties配置

和普通mysql配置相同,没有额外配置

#mysql 连接配置
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
  1. Mapper相关注解

@MapperScan中直接mapper文件所在的package

@SpringBootApplication
@EnableTransactionManagement
@EnableEurekaClient
@MapperScan("com.example.demo.dao")
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}
  1. 创建数据库表

略

  1. 创建JavaBean(推荐使用Lombok插件方式) - Model层
@Data
@TableName("area")
@ToString(callSuper=true, includeFieldNames=true)
@AllArgsConstructor
@NoArgsConstructor
public class Area implements Serializable{
	
	private static final long serialVersionUID = 1L;
	private String id;
	private String name;
	private int sort;
 
}
  1. 创建Mapper - DAO层

只有自定义SQL时,mapper中才有内容, 使用mybatis-plus自带CRUD语句或者构造器拼接语句时, mapper通常为空

public interface AreaMapper extends BaseMapper<Area> {
	
	//通过mybatis-plus提供的注解,直接自定义SQL
	@Select("select name from area where sort > ${sort}")
	List<String> getBySort2(@Param("sort")int sort);
}
  1. 创建逻辑接口 - Service层
public interface IAreaService {
	
	public Area getById(String id);
	
	public List<Area> selectAll();
	
	public int updateByPrimaryKeySelective(Area record);
	
	public int deleteByPrimaryKey(String id);
	
	public int insertSelective(Area record);
	
	public List<Area> getBySort();
	
	public List<String> getBySort2(int sort);

}
  1. 创建逻辑类 - Service层

Mybatis-Plus使用SQL的3种常见方法:
a. 使用mybatis-plus自带CRUD方法: 直接用mapper的自带方法
b. 使用mybatis-plus提供的条件构造器,拼接where条件
c. 使用@Select,@Update等注解, 自己写SQL+参数

@Service
public class AreaServiceImpl implements IAreaService {

	@Autowired
	public AreaMapper areaMapper;

	//使用mybatis-plus自带CRUD方法
	@Override
	public Area getById(String id) {
		return areaMapper.selectById(id);
	}	
	
	@Override
	public List<Area> selectAll() {
		return areaMapper.selectList(null);
	}
	
	@Override
	@Transactional
	public int updateByPrimaryKeySelective(Area record) {
		return areaMapper.updateById(record);
	}
	
	@Override
	public int deleteByPrimaryKey(String id) {
		return areaMapper.deleteById(id);
	}
	
	@Override
	public int insertSelective(Area record) {
		return areaMapper.insert(record);
	}
	
	//使用mybatis-plus提供的条件构造器,拼接条件
	@Override
	public List<Area> getBySort(){
		QueryWrapper<Area> queryWrapper = new QueryWrapper<>();
		queryWrapper.lambda().gt(Area::getSort, 40)
							 .lt(Area::getSort, 80);
		return areaMapper.selectList(queryWrapper);
	}
	
	//通过mybatis-plus提供的注解,直接自定义SQL(定义在mapper中)
	@Override
	public List<String> getBySort2(int sort){
		return areaMapper.getBySort2(sort);
		
	}

}
  1. 创建接口 - Controller层
@RestController
@RequestMapping("/area")
public class AreaController {

	@Autowired
	private IAreaService areaService;
	
	@Autowired
	private DbpropertiesService dbproService;
	
	@Autowired
	private Area area;
	
	@Resource
	protected HttpServletRequest request;

	@RequestMapping(value = "/getAreaInfo",method=RequestMethod.GET)
	public Area getAreaInfo(@RequestParam(value="id") String id) {
		area = areaService.getById(id);
		return area;
	}
	
	@RequestMapping(value = "/getAreaAllInfo",method=RequestMethod.GET)
	public List<Area> getAreaInfo() {
		List<Area> arlist = areaService.selectAll();
		return arlist;
	}
	
	@RequestMapping(value ="/updateAreaName",method=RequestMethod.PUT)
	public int updateAreaInfo(@RequestParam(value="id") String id,@RequestParam(value="name",required=false) String name,@RequestParam(value="sort",required=false) Integer sort) {
		area.setId(id);
		area.setName(name);	
		area.setSort(sort);
		int ar = areaService.updateByPrimaryKeySelective(area);
		return ar;
	}
	
	@RequestMapping(value ="/deleteAreaName",method=RequestMethod.DELETE)
	public int deleteAreaInfo(@RequestParam(value="id") String id) {
		int ar = areaService.deleteByPrimaryKey(id);
		return ar;
	}
	
//	@RequestMapping(value ="/insertAreaName",method=RequestMethod.POST)
//	public int insertAreaInfo(@RequestParam(value="id") String id,@RequestParam(value="name",required=false) String name,@RequestParam(value="sort",required=false) Integer sort) {
//		area.setId(id);
//		area.setName(name);	
//		area.setSort(sort);
//		int ar = areaService.insertSelective(area);
//		return ar;
//	}	
	
	@RequestMapping(value ="/insertAreaName",method=RequestMethod.POST)
	public int insertAreaInfo(@RequestBody Area area) {
		int ar = areaService.insertSelective(area);
		return ar;
	}
	
	@RequestMapping(value ="/selectBySort",method=RequestMethod.GET)
	public List<Area> selectAreaSort() {
		List<Area> arList = areaService.getBySort();
		return arList;
	}
	
	@RequestMapping(value ="/selectBySort2",method=RequestMethod.GET)
	public List<String> selectAreaSort2(@RequestParam(value="sort") int sort) {
		List<String> arList = areaService.getBySort2(sort);
		return arList;
	}
}

参考文档:
https://mp.baomidou.com/

多数据源插件

1. 默认用法

导入maven包

<dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>${dynamic-datasource.version}</version>
</dependency>

理论上应用需要一个主数据源, 多个副数据源, 全部写在properties文件中即可
automation就是默认连接的数据库,
其他3个就是副数据源.

#mysql 连接配置
spring.datasource.dynamic.primary=automation
spring.datasource.dynamic.datasource.automation.url=jdbc:mysql://172.25.4.235:3306/test_team?useSSL=false&serverTimezone=UTC
spring.datasource.dynamic.datasource.automation.username=j_test_team
spring.datasource.dynamic.datasource.automation.password=ys4TEDlrLARv
spring.datasource.dynamic.datasource.DRW.url=jdbc:mysql://172.25.4.205:3306/kf_darwin_auto_test?useSSL=false&serverTimezone=UTC
spring.datasource.dynamic.datasource.DRW.username=j_kf_darwin_wejb
spring.datasource.dynamic.datasource.DRW.password=YpM0ye7ruvoq
spring.datasource.dynamic.datasource.AUTHORITY.url=jdbc:mysql://172.25.4.205:3306/kf_authority?useSSL=false&serverTimezone=UTC
spring.datasource.dynamic.datasource.AUTHORITY.username=j_kf_authority
spring.datasource.dynamic.datasource.AUTHORITY.password=UgHzdODLu3To
spring.datasource.dynamic.datasource.IKBS.url=jdbc:mysql://172.25.4.214:3306/ikbs?useSSL=false&serverTimezone=UTC
spring.datasource.dynamic.datasource.IKBS.username=j_ikbs
spring.datasource.dynamic.datasource.IKBS.password=9PSAqLG4v7oh

使用: 在mapper文件中

// @DS是mybatis plus的多数据源注解, 使得不同方法可以访问不同的数据库

//使用默认数据库
@Select("${sql}")
List<JSONObject> executeSql_master(@Param("sql")String sql);

//使用指定数据库
@Select("${sql}")
@DS("IKBS")
List<JSONObject> executeSql_slave(@Param("sql")String sql);

2. 不使用properties

如果将所有数据库连接信息写在properties中, 如果在应用运行时,需要对数据库连接信息进行增删改查, 就需要重启应用, 为了增加灵活性, 我们可以将所有副数据库信息加入数据库中管理.

package com.project.automationplatform.configuration;

import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.baomidou.dynamic.datasource.creator.DataSourceCreator;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DataSourceProperty;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.project.automationplatform.dao.TestCaseAppManageMapper;
import com.project.automationplatform.model.TestCaseAppManage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.List;


/*
mybatis-plus多数据源的副数据库地址开始配置在application.properties中, 但为了在增加,修改,删除数据库连接信息时,
不需要修改代码,重启应用, 故将所有数据库连接信息储存于application表中, 在本连接类中启动应用时实时加入数据源列表
 */
@Configuration
public class DatasourceConfig implements BeanPostProcessor {

    Logger logger = LoggerFactory.getLogger(getClass());

    @Resource
    private TestCaseAppManageMapper testCaseAppManageMapper;

    //动态数据源
    @Autowired
    private DataSource dataSource;

    @Resource
    private DataSourceCreator dataSourceCreator;

    @Bean
    public void createNewDataSource(){
        DynamicRoutingDataSource drds = (DynamicRoutingDataSource) dataSource;
        QueryWrapper<TestCaseAppManage> wrapper = Wrappers.query();
        wrapper.lambda().eq(TestCaseAppManage::getStatus, 1);
        //获取application表中储存的数据库地址,用户名和密码列表
        List<TestCaseAppManage> allApp = testCaseAppManageMapper.selectList(wrapper);
        for(TestCaseAppManage app:allApp){
            if (null != app.getAppDbUrl()){
                DataSourceProperty dsp = new DataSourceProperty();
                dsp.setPollName(app.getAppCode());//链接池名称
                dsp.setUrl(app.getAppDbUrl());//数据库连接
                dsp.setUsername(app.getAppDbUserName());//用户名
                dsp.setPassword(app.getAppDbPassWord());//密码
                //dsp.setDriverClassName(driverClassName);//驱动
                //创建数据源并添加到系统中管理
                DataSource dataSource = dataSourceCreator.createDataSource(dsp);
                drds.addDataSource(app.getAppCode(), dataSource);
            }
        }
        logger.info("已加入列表的多数据源drds: " + drds.getCurrentDataSources());
        //return drds;
    }

}

使用:

 //执行'数据库查询SQL'中的SQL
    @Override
    public List<JSONObject> executeSql(String sql,String app){

        //为了避免一个线程在跑A应用的数据库SQL时,另一个线程B想要跑B应用的数据库SQL, 产生并发问题,
        //故加上排它锁
        Lock thisLock = new ReentrantLock();
        List<JSONObject> result = new ArrayList<JSONObject>();
        thisLock.lock();
        try{
            DynamicDataSourceContextHolder.push(app);//数据源名称
            result = testCaseTemplateMapper.executeSql_slave(sql);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            DynamicDataSourceContextHolder.poll();
            thisLock.unlock();
        }
        return result;
    }

数据源datasource

数据源是数据库连接的规范接口

Springboot默认支持4种数据源类型，定义在 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration 中，分别是：

org.apache.tomcat.jdbc.pool.DataSource
com.zaxxer.hikari.HikariDataSource
org.apache.commons.dbcp.BasicDataSource
org.apache.commons.dbcp2.BasicDataSource

在不指定数据源类型时, SpringBoot默认使用tomcat.jdbc

如果需要使用第三方数据源, 比如Druid, 步骤如下:

Druid的配置

  1. Maven配置
		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.3</version>
        </dependency>
  1. application.properties配置

spring.datasource.type需要指定为Druid

spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

其他的Druid自有属性,可以写在properties中也可以写在Druid的配置类中

@ConfigurationProperties(prefix = "spring.datasource")
public class DruidConfiguration {
	
	private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize = 5;
    private int minIdle = 5;
    private int maxActive = 10;
    private int maxWait = 2;
    private int timeBetweenEvictionRunsMillis = 1000 * 60;
    private int minEvictableIdleTimeMillis = 1000 * 60 * 30;
    private String validationQuery;
    private boolean testWhileIdle = false;
    private boolean testOnBorrow = true;
    private boolean testOnReturn = false;
    private boolean poolPreparedStatements = false;
    private int maxPoolPreparedStatementPerConnectionSize = -1;
    private String filters;
    private boolean useGlobalDataSourceStat = false;
    private String connectionProperties;
  1. 定义数据源


@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSource2Config {
 
	private String url;
	private String username;
	private String password;
 
	@Bean
	public DataSource getDataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setUrl(url);
		dataSource.setUsername(username);// 用户名
		dataSource.setPassword(password);// 密码
		return dataSource;
	}
 
	public String getUrl() {
		return url;
	}
 
	public void setUrl(String url) {
		this.url = url;
	}
 
	public String getUsername() {
		return username;
	}
 
	public void setUsername(String username) {
		this.username = username;
	}
 
	public String getPassword() {
		return password;
	}
 
	public void setPassword(String password) {
		this.password = password;
	}
}
  1. 配置Druid的监控器和为事务管理器指定Druid数据源, 最终Configuration文件如下:

Druid监控配置:
ServletRegistrationBean
FilterRegistrationBean
事务管理器配置:
PlatformTransactionManager

package com.example.demo.dao.druid;

import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;


@Configuration
public class DruidConfiguration {
	
	 @Bean
	 public ServletRegistrationBean druidServlet() {
	      //logger.info("init Druid Servlet Configuration ");
	      ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();
	      servletRegistrationBean.setServlet(new StatViewServlet());
	      servletRegistrationBean.addUrlMappings("/druid/*");
	      Map<String, String> initParameters = new HashMap<String, String>();
	      initParameters.put("loginUsername", "admin");
	      initParameters.put("loginPassword", "admin");
	      initParameters.put("resetEnable", "false");
	      initParameters.put("allow", ""); 
	      initParameters.put("deny", "");
	      servletRegistrationBean.setInitParameters(initParameters);
	      return servletRegistrationBean;
	  }

	  @Bean
	  public FilterRegistrationBean filterRegistrationBean() {
	      FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
	      filterRegistrationBean.setFilter(new WebStatFilter());
	      filterRegistrationBean.addUrlPatterns("/*");
	      filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
	      return filterRegistrationBean;
	  }
	  
	  @Bean
	  @Primary
	  public PlatformTransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource)  {
	      DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
	      dataSourceTransactionManager.setDataSource(dataSource);
	      return dataSourceTransactionManager;
	  }
	
	
}

//Druid配置Bean
@Component
@ConfigurationProperties(prefix = "spring.datasource")
class DruidDataSourceProperties {
	
	private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize = 5;
    private int minIdle = 5;
    private int maxActive = 10;
    private int maxWait = 2;
    private int timeBetweenEvictionRunsMillis = 1000 * 60;
    private int minEvictableIdleTimeMillis = 1000 * 60 * 30;
    private String validationQuery;
    private boolean testWhileIdle = false;
    private boolean testOnBorrow = true;
    private boolean testOnReturn = false;
    private boolean poolPreparedStatements = false;
    private int maxPoolPreparedStatementPerConnectionSize = -1;
    private String filters = "stat";
    private boolean useGlobalDataSourceStat = false;
    private String connectionProperties;
    
    @Bean     //声明其为Bean实例,将数据源设置为druid
    @Primary  //在同样的DataSource中，首先使用被标注的DataSource
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

        //configuration
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            System.err.println("druid configuration initialization filter: " + e);
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }
    
    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public int getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public int getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(int maxWait) {
        this.maxWait = maxWait;
    }

    public int getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public int getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }

    public int getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }

    public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    public String getFilters() {
        return filters;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }


    public boolean isUseGlobalDataSourceStat() {
        return useGlobalDataSourceStat;
    }

    public void setUseGlobalDataSourceStat(boolean useGlobalDataSourceStat) {
        this.useGlobalDataSourceStat = useGlobalDataSourceStat;
    }

    public String getConnectionProperties() {
        return connectionProperties;
    }

    public void setConnectionProperties(String connectionProperties) {
        this.connectionProperties = connectionProperties;
    }
}
  1. Druid性能监控台
    http://localhost:8092/druid/index.html
mybatis-plus+druid配置多套数据源
anan_yyds的博客
06-30 2191
1、首先引入需要用到的依赖
MyBatisPlus--多数据源
热门推荐
qq_45917176的博客
04-21 1万+
官网地址：多数据源 | MyBatis-Plus (baomidou.com) 支持 数据源分组 ，适用于多种场景、纯粹多库、读写分离、一主多从、混合模式。 目前来模拟一个纯粹多库的一个场景，其他场景类似；场景说明： 创建两个库，分别为：mybatis_plus与mybatis_plus_1，使每个库一张表，通过一个测试用例分别获取用户数据与商品数据，如果获取到说明多库模拟成功。 1、创建数据库及表 创建数据库mybatis_plus和表user CREATE DATABASE `mybatis_plu.
MybatisPlus
最新发布
sjdjjdkd的博客
10-13 872
MyBatisPlus 简化开发实践指南 本文介绍了MyBatisPlus在企业开发中的高效应用。针对单表CRUD重复编码问题，MyBatisPlus通过BaseMapper接口、条件构造器和常用注解，大幅提升开发效率。主要内容包括： 基础配置：快速集成MyBatisPlus，通过继承BaseMapper实现基本CRUD 核心功能： 条件构造器（QueryWrapper/UpdateWrapper）构建复杂查询 Lambda表达式避免字段名硬编码 Service层封装常用业务模板方法 高级特性： 枚举和JS
Spring boot Druid 多数据源JDBC和注解事务
tskyer的专栏
04-24 2534
1.引入依赖 gradle文件配置,用maven引入也可以 runtimeOnly 'com.microsoft.sqlserver:mssql-jdbc' //数据库驱动 implementation 'org.springframework.boot:spring-boot-starter-jdbc' //spring jdbc implementation 'com.alibaba:drui...
SpringBoot整合Mybatis-Plus、Druid配置多数据源
拾一二的博客
04-28 1万+
本文将介绍如何使用Spring Boot框架整合MyBatis和Druid多数据源，并包含以下内容： 概述Spring Boot、MyBatis和Druid 环境准备和依赖配置 配置多数据源 配置MyBatis 配置Druid连接池 使用MyBatis访问多数据源 代码实现和测试 通过本文的阅读，学习到如何使用Spring Boot框架整合MyBatis和Druid多数据源，能够帮助您更快速、更高效地开发企业级应用程序。
mybatisplus druid多数据源配置 spring boot
weixin_40572086的博客
07-15 257
实现MyBatisPlus Druid多数据源配置Spring Boot 一、整体流程 步骤 操作 1 添加MyBatisPlus、Druid等依赖 2 配置数据源 3 配置MyBatisPlus 4 编写多数据源配置 5 测试多数据源是否生效 二、具体步骤 1. 添加依赖 首先，在po...
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
总结起来，通过SpringBoot、Mybatis-Plus和Druid，我们可以方便地实现双数据源配置，使得应用能同时处理MySQL和Oracle数据库的数据。在实际开发中，要根据业务场景灵活切换数据源，确保数据操作的正确性和效率。同时...
精选资源
springboot+mybatis-plus+shardingsphere 实现读写分离
04-09
ShardingSphere提供了API和注解两种方式来进行数据源路由，可以根据业务需求灵活选择。同时，Spring Boot的自动配置能力可以帮助我们无缝集成ShardingSphere，减少手动配置的工作。 此外，为了更好地管理和监控...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar
08-12
存储过程等），用Redis做中间缓存，缓存数据 实现异步处理，定时任务，整合Quartz Job以及Spring Task 邮件管理功能， 整合spring-boot-starter-mail发送邮件等， 数据源:druid 用户管理，菜单管理，角色管理，代码...
mybatis-plus+动态数据源
09-28
综上所述，这个项目涉及到的IT知识点包括数据库操作的便捷工具Mybatis-Plus，多数据库管理的动态数据源技术，以及Spring框架下的自定义配置、XML解析、注解注入和AOP应用。通过这些技术的整合，可以构建出一个灵活、...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
12-15
数据源:druid 用户管理，菜单管理，角色管理，代码生成 运行环境 jdk8+oracle+redis+IntelliJ IDEA+maven 项目技术(必填) Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis 数据库文件 压缩包内 jar包文件 ...
Mybatis+Druid+MybatisPlus多数据源配置
我认不到你的博客
09-18 1453
平常我们使用的是 properties 或者 yaml 来配置数据库的地址、用户名、密码等，但是这样只能配置一个数据源，现在我们想在一个项目里面配置多个数据源，那么我们就需要配置自己的配置类
SpringBoot + Mybatis + Druid + PageHelper 实现多数据源分页
公众号-老炮说Java
09-18 583
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达 关注公众号后台回复pay或mall获取实战项目资料视频 点击此链接：多套SpringCloud/SpringBoot实战项目，...
Mybatis-Plus&&Druid多数据源配置
Big Data
06-21 3539
多数据源配置思路 目录 多数据源配置思路
SpringBoot MybatisPlus Druid 多数据源项目
Standup-jb的博客
10-19 466
写在前面：本文主要介绍SpringBoot MybatisPlus和Druid这些组件下，如何创建多数据源(DataSource)的web项目。写这篇博客的原因就是我在搜索同类型的问题的时候，其他人写的博客非常不清晰，完全无法按照介绍的步骤来实现。我希望我写的这篇博客可以真的替看这篇博客的人能解决这类问题。如果你看完之后还是没有解决可以评论留言，甚至加我的微信(JB328258)帮你解决。因为我觉...
sprinboot 之 mybatis plus + druid多数据源
天行健，君子以自强不息；地势坤，君子以厚德载物。
02-08 458
0x01：引入 pom 依赖<!-- 动态数据源 --> <dependency> <groupId>com.baomidou</g...
从0开始springboot后台管理项目-mybatis-plus/druid链接数据库多数据源
JAVA_WC的博客
05-09 1200
1.准备完成的功能 通过mybatis-plus/druid进行数据库链接 对pom文件中数据库密码进行加密 配置多数据源 使用mybatis-plus的原因就是太强大，比如支持Lambda，依赖少等等优点，可以搜索一下mybatis-plus和mybatis的区别。 druid ...
正确可用版：SpringBoot+Mybatis-plus+Druid 实现配置多数据源（数据库）
Oxye
01-04 1万+
前言 此文介绍的是在SpringBoot中使用Mybatis配置多数据源（多个数据库），整合Druid 网上有很多文章，翻了翻，但是都有问题啊，有的是没使用Druid，使用了默认的Hirika，有的是配置文件不给或者给的是Hirika能用的配置，层级不对，所以我自己来记一下 代码 pom文件maven依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid
springboot+mybatisplus+druid实现多数据源配置
傅老师的博客
12-07 745
【代码】springboot+mybatisplus+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`） ---
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值