关于Springboot 配置多数据源 Druid 德鲁伊

最新推荐文章于 2024-05-30 15:38:25 发布
最新推荐文章于 2024-05-30 15:38:25 发布
阅读量793 收藏 1
点赞数 1
文章标签： mysql spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45168276/article/details/120043580
版权

关于Springboot 配置多数据源 Druid 德鲁伊

yml

server:
  port: 8080
  servlet:
    encoding:
      charset: UTF-8
spring:
  resources:
    static-locations: classpath:/static
  application:
    name:springboot_list
  aop:
    proxy-target-class: true
    auto: true
  mvc:
    static-path-pattern: /**
    thymeleaf:
      check-template-location: true  # 检查模板位置是否正确（默认值 :true ）
      check-template: true  # 检查模板是否存在，然后再呈现
      content-type: text/html
      enabled: true
      encoding: UTF-8
      cache: false  # 开启模板缓存（默认值： true ）
      mode: HTML5
      prefix: classpath:/templates/
      suffix: .html
  datasource:
    #使用druid连接池
    type: com.alibaba.druid.pool.DruidDataSource

primary:
  datasource:
    #druid相关配置
    druid:
      #监控统计拦截的filters
      filters: stat
      driverClassName: com.mysql.cj.jdbc.Driver
      #配置基本属性
      url: 
      username: 
      password: 
      #配置初始化大小/最小/最大
      initialSize: 1
      minIdle: 1
      maxActive: 20
      #获取连接等待超时时间
      maxWait: 60000
      #间隔多久进行一次检测，检测需要关闭的空闲连接
      timeBetweenEvictionRunsMillis: 60000
      #一个连接在池中最小生存的时间
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 20

# 自定义的从数据源配置信息
time:
  datasource:
    #druid相关配置
    druid:
      #监控统计拦截的filters
      filters: stat
      driverClassName: com.mysql.cj.jdbc.Driver
      #配置基本属性
      url: 
      username: 
      password: 
      #配置初始化大小/最小/最大
      initialSize: 1
      minIdle: 1
      maxActive: 20
      #获取连接等待超时时间
      maxWait: 60000
      #间隔多久进行一次检测，检测需要关闭的空闲连接
      timeBetweenEvictionRunsMillis: 60000
      #一个连接在池中最小生存的时间
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 20

sqlser:
  datasource:
    druid:
      #监控统计拦截的filters
      filters: stat
      username: 
      password: 
      url: 
      driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
      initialSize: 1
      minIdle: 1
      maxActive: 20
      #获取连接等待超时时间
      maxWait: 60000
      #间隔多久进行一次检测，检测需要关闭的空闲连接
      timeBetweenEvictionRunsMillis: 60000
      #一个连接在池中最小生存的时间
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 20


#      url: jdbc:mysql://192.168.1.66:3306/hnks_qzj?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&serverTimezone=GMT&useSSL=false
#      driver-class-name: com.mysql.cj.jdbc.Driver
#      username: hnks
#      password: hnksadmin
#      initial-size: 1
#      min-idle: 1
#      max-active: 20

mybatis-plus:
  mapper-locations: classpath:mapper/*/*.xml
  type-aliases-package: com.hnks.springboot_list.entity.*
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true #驼峰

  logging:
    level:
      com.hnks.springboot_list.mapper.*: debug

config

import com.alibaba.druid.pool.DruidDataSource;
import lombok.Data;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.SQLException;

/**
 * @Description: 后台数据源配置类
 */

@Data
@Configuration
@Component
@ConfigurationProperties(prefix = "time.datasource.druid")
@MapperScan(basePackages = BackDataBaseConfig.PACKAGE, sqlSessionFactoryRef = "backSqlSessionFactory")
public class BackDataBaseConfig {


    /**
     * dao层的包路径
     */
    static final String PACKAGE = "com.hnks.springboot_list.mapper.time";

    /**
     * mapper文件的相对路径
     */
    private static final String MAPPER_LOCATION = "classpath:mapper/time/*.xml";

    private String filters;
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private long maxWait;
    private long timeBetweenEvictionRunsMillis;
    private long minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;


    @Bean(name = "backDataSource")
    public DataSource backDataSource() throws SQLException {
        DruidDataSource druid = new DruidDataSource();
        // 监控统计拦截的filters
        druid.setFilters(filters);

        // 配置基本属性
        druid.setDriverClassName(driverClassName);
        druid.setUsername(username);
        druid.setPassword(password);
        druid.setUrl(url);

        //初始化时建立物理连接的个数
        druid.setInitialSize(initialSize);
        //最大连接池数量
        druid.setMaxActive(maxActive);
        //最小连接池数量
        druid.setMinIdle(minIdle);
        //获取连接时最大等待时间，单位毫秒。
        druid.setMaxWait(maxWait);
        //间隔多久进行一次检测，检测需要关闭的空闲连接
        druid.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        //一个连接在池中最小生存的时间
        druid.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        //用来检测连接是否有效的sql
        druid.setValidationQuery(validationQuery);
        //建议配置为true，不影响性能，并且保证安全性。
        druid.setTestWhileIdle(testWhileIdle);
        //申请连接时执行validationQuery检测连接是否有效
        druid.setTestOnBorrow(testOnBorrow);
        druid.setTestOnReturn(testOnReturn);
        //是否缓存preparedStatement，也就是PSCache，oracle设为true，mysql设为false。分库分表较多推荐设置为false
        druid.setPoolPreparedStatements(poolPreparedStatements);
        // 打开PSCache时，指定每个连接上PSCache的大小
        druid.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

        return druid;
    }

    @Bean(name = "backTransactionManager")
    public DataSourceTransactionManager backTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(backDataSource());
    }



    @Bean(name = "backSqlSessionFactory")
    public SqlSessionFactory backSqlSessionFactory(@Qualifier("backDataSource") DataSource backDataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(backDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(BackDataBaseConfig.MAPPER_LOCATION));

        return sessionFactory.getObject();
    }
}



import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
import lombok.Data;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.SQLException;

@Data
@Configuration
// 前缀为primary.datasource.druid的配置信息
@Component
@ConfigurationProperties(prefix = "primary.datasource.druid")
@MapperScan(basePackages = PrimaryDataBaseConfig.PACKAGE, sqlSessionFactoryRef = "primarySqlSessionFactory")
public class PrimaryDataBaseConfig {

    /**
     * dao层的包路径
     */
    static final String PACKAGE = "com.hnks.springboot_list.mapper.primary";

    /**
     * mapper文件的相对路径
     */
    private static final String MAPPER_LOCATION = "classpath:mapper/primary/*.xml";

    private String filters;
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private long maxWait;
    private long timeBetweenEvictionRunsMillis;
    private long minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;

    // 主数据源使用@Primary注解进行标识
    @Primary
    @Bean(name = "primaryDataSource")
    public DataSource primaryDataSource() throws SQLException {
        DruidDataSource druid = new DruidDataSource();
        // 监控统计拦截的filters
        druid.setFilters(filters);

        // 配置基本属性
        druid.setDriverClassName(driverClassName);
        druid.setUsername(username);
        druid.setPassword(password);
        druid.setUrl(url);

        //初始化时建立物理连接的个数
        druid.setInitialSize(initialSize);
        //最大连接池数量
        druid.setMaxActive(maxActive);
        //最小连接池数量
        druid.setMinIdle(minIdle);
        //获取连接时最大等待时间，单位毫秒。
        druid.setMaxWait(maxWait);
        //间隔多久进行一次检测，检测需要关闭的空闲连接
        druid.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        //一个连接在池中最小生存的时间
        druid.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        //用来检测连接是否有效的sql
        druid.setValidationQuery(validationQuery);
        //建议配置为true，不影响性能，并且保证安全性。
        druid.setTestWhileIdle(testWhileIdle);
        //申请连接时执行validationQuery检测连接是否有效
        druid.setTestOnBorrow(testOnBorrow);
        druid.setTestOnReturn(testOnReturn);
        //是否缓存preparedStatement，也就是PSCache，oracle设为true，mysql设为false。分库分表较多推荐设置为false
        druid.setPoolPreparedStatements(poolPreparedStatements);
        // 打开PSCache时，指定每个连接上PSCache的大小
        druid.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

        return druid;
    }

    // 创建该数据源的事务管理
    @Primary
    @Bean(name = "primaryTransactionManager")
    public DataSourceTransactionManager primaryTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(primaryDataSource());
    }

    // 创建Mybatis的连接会话工厂实例
    @Primary
    @Bean(name = "primarySqlSessionFactory")
    public SqlSessionFactory primarySqlSessionFactory(@Qualifier("primaryDataSource") DataSource primaryDataSource, MybatisPlusProperties mybatisPlusProperties) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(primaryDataSource);  // 设置数据源bean
        sessionFactory.setConfiguration(mybatisPlusProperties.getConfiguration());//配置mybatisPlus sql打印日志
//        sessionFactory.setConfiguration(mybatisProperties.getConfiguration());// mybatis 配置sql打印日志
//        MybatisProperties mybatisProperties
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(PrimaryDataBaseConfig.MAPPER_LOCATION));  // 设置mapper文件路径

        return sessionFactory.getObject();
    }
}



import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import lombok.Data;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.SQLException;

/**
 * @Description: 后台数据源配置类
 */

@Data
@Configuration
@Component
@ConfigurationProperties(prefix = "sqlser.datasource.druid")
@MapperScan(basePackages = SqlServerDataBaseConfig.PACKAGE, sqlSessionFactoryRef = "sqlServerDataBase")
public class SqlServerDataBaseConfig {

    /**
     * dao层的包路径
     */
    static final String PACKAGE = "com.hnks.springboot_list.mapper.sqlser";

    /**
     * mapper文件的相对路径
     */
    private static final String MAPPER_LOCATION = "classpath:mapper/sqlser/*.xml";

    private String filters;
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private long maxWait;
    private long timeBetweenEvictionRunsMillis;
    private long minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;


    @Bean(name = "sqlBaseConfig")
    public DataSource sqlBaseConfig() throws SQLException {
        DruidDataSource druid = new DruidDataSource();
        // 监控统计拦截的filters
        druid.setFilters(filters);

        // 配置基本属性
        druid.setDriverClassName(driverClassName);
        druid.setUsername(username);
        druid.setPassword(password);
        druid.setUrl(url);

        //初始化时建立物理连接的个数
        druid.setInitialSize(initialSize);
        //最大连接池数量
        druid.setMaxActive(maxActive);
        //最小连接池数量
        druid.setMinIdle(minIdle);
        //获取连接时最大等待时间，单位毫秒。
        druid.setMaxWait(maxWait);
        //间隔多久进行一次检测，检测需要关闭的空闲连接
        druid.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        //一个连接在池中最小生存的时间
        druid.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        //用来检测连接是否有效的sql
        druid.setValidationQuery(validationQuery);
        //建议配置为true，不影响性能，并且保证安全性。
        druid.setTestWhileIdle(testWhileIdle);
        //申请连接时执行validationQuery检测连接是否有效
        druid.setTestOnBorrow(testOnBorrow);
        druid.setTestOnReturn(testOnReturn);
        //是否缓存preparedStatement，也就是PSCache，oracle设为true，mysql设为false。分库分表较多推荐设置为false
        druid.setPoolPreparedStatements(poolPreparedStatements);
        // 打开PSCache时，指定每个连接上PSCache的大小
        druid.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        return druid;
    }

    @Bean(name = "backManager")
    public DataSourceTransactionManager backManager() throws SQLException {
        return new DataSourceTransactionManager(sqlBaseConfig());
    }



    @Bean(name = "sqlServerDataBase")
    public SqlSessionFactory sqlServerDataBaseConfig(@Qualifier("sqlBaseConfig") DataSource backDataSource) throws Exception {
        final MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
        sessionFactory.setDataSource(backDataSource);

        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(SqlServerDataBaseConfig.MAPPER_LOCATION));

        return sessionFactory.getObject();
    }
}

特别注意

mybatis 和mybatisplus 是不一样的 mybatis->SqlSessionFactoryBean
mybatisplus->MybatisSqlSessionFactoryBean（曾经也是吃了我半天时间！！）

打印控制台sql：mybatis -》MybatisProperties sessionFactory.setConfiguration(mybatisProperties.getConfiguration());// mybatis 配置sql打印日志

打印控制台sql：mybatisplus-》MybatisPlusProperties
sessionFactory.setConfiguration(mybatisPlusProperties.getConfiguration());//配置mybatisPlus sql打印日志

SporadicLife
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot druid配置多数据源
大唐响马的博客
05-29 1519
一、Pom.xml <!--mybatis--> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version> </dependency> <dependency&gt
springboot 配置DRUID数据源的方法实例分析
08-25
主要介绍了springboot 配置DRUID数据源的方法,结合实例形式分析了springboot 配置阿里DRUID数据源的具体步骤与相关操作技巧,需要的朋友可以参考下
SpringBoot--使用Druid(德鲁伊)数据源
天行健 君子以自强不息，地势坤 君子以厚德载物。
05-27 2855
1.1 使用Druid(德鲁伊)数据源 1.1.1 添加上 Druid 数据源依赖 pom.xml <!-- https://mvnrepository.com/artifact/com.alibaba/druid --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.6
Springboot+druid+多数据源
最新发布
fonjames的专栏
05-30 932
1.在Spring Boot中配置两个不同的Oracle数据源，你需要在配置类中分别定义两个数据源，并使用AbstractRoutingDataSource来路由到不同的数据源。当然，如果你的应用需要配置多个Druid数据源，并且每个数据源的密码都需要通过自定义的解密方法解密，你可以扩展上面的配置方法以适应多数据源的场景。这样，每次调用到数据源的地方，都会根据你的逻辑动态切换到不同的数据源。3. 使用多数据源在业务代码中，你可以通过@DS注解器来指定使用特定的数据源，或者不指定时使用默认的数据源。
mybatisPlus之自动填充工具MetaObjectHandler使用demo及注意点
热门推荐
雨剑的博客
01-10 1万+
文章目录一. 使用场景二. 使用姿势1.实现MetaObjectHandler接口2. 实体类上添加注解三. 不生效的场景1. 试试2. dad 一. 使用场景 MetaObjectHandler是元对象字段填充控制器抽象类，实现公共字段自动写入。 比如通常，我们在建表时，会设置几个公共字段：创建人（creator）、更新人（uptater）、创建时间（create_time）、更新时间（update_time）。 每次将实体对象新增入库时，都要设置创建人和创建时间；每次更新实体对象时，都要设置更新人和更新
SSM整合Mybatis-Plus自动填充MyMetaObjectHandler
NULL_YM
05-22 7126
概述 先说一下在springboot中，我们要使用mybatis-plus做自动填充的步骤 实体类中公共字段，添加@TableField注解 @Data @EqualsAndHashCode(callSuper = false) @Accessors(chain = true) @TableName("bbs_module") public class Module implements Serializable { private static final long serialVersion
mybatisplus MetaObjectHandler 失效解决方案
qq_39084191的博客
10-25 4857
myabtisplus MetaObjectHandler填充字段失效的场景、原因及解决方案
MyBatis MetaObjectHandler：动态字段处理与对象元数据处理
wddblog的博客
03-07 2251
这种机制允许开发者在不修改实体类代码的情况下，对实体对象的字段值进行自定义处理，如自动填充创建时间、更新时间等。在开发过程中，经常需要为实体类的某些字段设置默认值，比如创建时间、更新时间等。是 MyBatis-Plus 提供的一个强大功能，它允许开发者在不修改实体类代码或 XML 映射文件的情况下，动态地处理实体类的字段值。的工作原理是通过反射机制，获取实体类的字段信息，然后根据开发者定义的规则，对字段值进行处理。还支持在更新操作时，对实体类的字段进行动态处理，如根据条件自动更新某些字段的值。
mybatisPlus之自动填充工具MetaObjectHandler的简单使用
weixin_45616758的博客
05-25 1633
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录使用步骤1.给实体类需要自动填充的字段添加注解2.自定义实现类实现MetaObjectHandler接口3.BaseContext工具类 使用步骤 1.给实体类需要自动填充的字段添加注解 代码如下（示例）： 注解中的fill属性表示字段填充标记，配合自动填充使用。 fill对应的值： DEFAULT ：默认不处理 INSERT ： 插入操作时进行填充字段 UPDATE ：更新操作时填充字段 INSERT_UPDATE ：插入和更.
springboot多数据源,DruidDataSource多数据源切换，不重启项目，修改数据库名解决方案
01-04
项目背景： 1. Springboot项目 ... 一个主数据源，数据名称库不变。 3. 一个副数据源，数据库名称每天都在变，比如今天1号，是db_01； 明天2号，是db_02。 4.不重启项目切换数据源。 5.项目介绍： ...
SpringBoot Mybatis如何配置多数据源并分包
08-19
主要介绍了SpringBoot Mybatis如何配置多数据源并分包,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
通过springboot+mybatis+druid配置动态数据源
08-25
我们可以创建一个数据源配置类，用于管理多个数据源： ```java @Configuration public class DynamicDataSourceConfig { @Bean public DataSource dataSource() { DynamicDataSource dynamicDataSource = new ...
Springboot Druid多数据源 多线程
05-14
首先，Spring Boot的多数据源配置是通过Spring的@Configuration和@Bean注解来实现的。每个数据源都会被定义为一个DataSource bean，并配置相应的数据库连接信息，如URL、用户名和密码。在Spring Boot中，我们可以...
MyMetaObjectHandler
Cchy_yhc的博客
06-23 2028
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 MetaObjectHandle
metaObjecthandler 的基本理解与使用
fengzheng1232的博客
04-18 8487
metaObjecthandler:元数据对象处理器 MetaObjectHandler接口是mybatisPlus为我们提供的的一个扩展接口，我们可以利用这个接口在我们插入或者更新数据的时候，为一些字段指定默认值。 使用场景：公共字段填充等，如updateTime、createTime、createUser、updateUser等公共字段多的填充。
MyBatis-Plus，MetaObjectHandler没生效，完美解决
weixin_43703519的博客
08-08 3711
若依框架集成mybatis-plus，自动填充字段不生效
Mybatis-Plus公共字段自动填充（MetaObjectHandler接口）
weixin_72979483的博客
05-30 845
通常数据表中一般都有的字段，也就是公共字段，比如create_time，update_time,每次修改或插入新数据的时候都要设置一次值，操作很繁琐，所以mybatis-puls提供了公共字段填充这一个接口。
springmvc mybatis-plus myMetaObjectHandler 自动注入不生效
weixin_44123053的博客
04-11 1491
问题详情: 使用SpringMVC 参照官方文档使用 MetaObjectHandler 接口进行自动注入无效 debug 代码根本未进入方法 MetaObjectHandler代码如下: public class MyMetaObjectHandler implements MetaObjectHandler { // 插入时的填充策略 @Override public void insertFill(MetaObject metaObject) { // set
Mybatis-Plus 自定义ObjectHandler填充字段无效的问题
weixin_38158701的博客
07-13 3317
Mybatis-Plus 自定义ObjectHandler填充字段无效的问题可能的原因 最近项目正在用MP重构，重构过程中遇到这样的问题。公共字段填充失效，Debug发现没有进到改实现中，也就是配置失效了，去访问官方文档，我的配置也完全符合文档中的要求，几经周折，终于得到解决方案，在这里记录一下。 可能的原因 1.如果不是多数据源 自定义Handler实现元对象处理器接口：com.baomidou.mybatisplus.core.handlers.MetaObjectHandler 需要填充的字段上加注
springboot如何配置多数据源druid
08-18
Spring Boot可以通过配置多个数据源来实现多数据源的使用，而Druid是一种数据库连接池，可以提供对多个数据源的连接管理和监控功能。 首先，在`pom.xml`文件中添加Druid和对应数据库驱动的依赖： ```xml <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.2.6</version> </dependency> <!-- 添加其他数据库驱动的依赖 --> ``` 然后，在`application.properties`或`application.yml`中配置多个数据源的相关信息，例如： ```properties # 主数据源 spring.datasource.url=jdbc:mysql://localhost:3306/db1 spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver # 第二个数据源 spring.datasource.second.url=jdbc:mysql://localhost:3306/db2 spring.datasource.second.username=root spring.datasource.second.password=123456 spring.datasource.second.driver-class-name=com.mysql.cj.jdbc.Driver ``` 接下来，创建多个数据源的配置类，例如： ```java @Configuration public class DataSourceConfig { @Primary @Bean(name = "dataSource") @ConfigurationProperties(prefix = "spring.datasource") public DataSource dataSource() { return DruidDataSourceBuilder.create().build(); } @Bean(name = "secondDataSource") @ConfigurationProperties(prefix = "spring.datasource.second") public DataSource secondDataSource() { return DruidDataSourceBuilder.create().build(); } } ``` 注意，`@Primary`注解用于标识默认的主数据源。 最后，在需要使用数据源的地方，通过`@Qualifier`注解指定要使用的数据源，例如： ```java @Service public class MyService { @Autowired @Qualifier("dataSource") private DataSource dataSource; // 使用dataSource进行数据库操作 @Autowired @Qualifier("secondDataSource") private DataSource secondDataSource; // 使用secondDataSource进行数据库操作 } ``` 这样就完成了Spring Boot中多数据源Druid的配置。在使用数据源时，可以根据需要在不同的地方注入不同的数据源。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值