国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

springboot+mybatis實現(xiàn)多數據源

2年前作者：老F的技術屋分類：Toy博客閱讀(28)違法舉報

這篇具有很好參考價值的文章主要介紹了springboot+mybatis實現(xiàn)多數據源。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

1. 前言

最近做項目碰到了一個需要連4個不同數據庫的需求，其中db1、db2表結構都不相同；另外兩個數據庫same_db_private、same_db_public表結構完全相同，一個對內一個對外，只是從物理上隔離了數據而已。

所以打算通過靜態(tài)配置包路徑的方式來實現(xiàn)db1、db2的操作，并且通過擴展Spring的AbstractRoutingDataSource的方式來實現(xiàn)same_db_private、same_db_public的動態(tài)切換數據源。

2. 數據準備

db1創(chuàng)建表并準備數據

create table goods_info
(
    id bigint auto_increment comment '主鍵' primary key,
	name varchar(50) not null
)collate=utf8mb4_bin;

insert into db1.goods_info (id, name)
values  (1, '商品1'),
        (2, '商品2'),
        (3, '商品3');

db1創(chuàng)建表并準備數據

create table user_info
(
    id bigint auto_increment comment '主鍵' primary key,
    name varchar(50) not null
)collate=utf8mb4_bin;

insert into db2.user_info (id, name)
values  (1, '用戶1'),
        (2, '用戶2'),
        (3, '用戶3');

same_db_private創(chuàng)建表并準備數據

create table brand_info
(
    id bigint auto_increment comment '主鍵' primary key,
    name varchar(50) not null
)collate=utf8mb4_bin;

insert into brand_info (id, name)
values  (1, '內部品牌1');

same_db_public創(chuàng)建表并準備數據

create table brand_info
(
    id bigint auto_increment comment '主鍵' primary key,
    name varchar(50) not null
)collate=utf8mb4_bin;

insert into brand_info (id, name)
values  (1, '外部品牌1');

3. 代碼細節(jié)

3.1 工程目錄

springboot mybatis 多數據源,springboot,mybatis,spring boot,java

3.2 配置文件

spring.datasource.db1.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.db1.username=root
spring.datasource.db1.password=xxxxxx
spring.datasource.db1.jdbc-url=jdbc:mysql://localhost:3306/db1

spring.datasource.db2.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.db2.username=root
spring.datasource.db2.password=xxxxxx
spring.datasource.db2.jdbc-url=jdbc:mysql://localhost:3306/db2

spring.datasource.same-db-private.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.same-db-private.username=root
spring.datasource.same-db-private.password=xxxxxx
spring.datasource.same-db-private.jdbc-url=jdbc:mysql://localhost:3306/same_db_private

spring.datasource.same-db-public.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.same-db-public.username=root
spring.datasource.same-db-public.password=xxxxxx
spring.datasource.same-db-public.jdbc-url=jdbc:mysql://localhost:3306/same_db_public

3.3 靜態(tài)配置數據源

在config中創(chuàng)建db1和db2的靜態(tài)數據源配置

package com.aresbf.multi.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.aresbf.multi.mapper.db1", sqlSessionFactoryRef = "db1SqlSessionFactory")
public class DataSource1 {

    /**
     * 配置db1數據庫
     *
     * @return
     */
    @Bean(name = "db1Datasource")
    @ConfigurationProperties(prefix = "spring.datasource.db1")
    public DataSource testDatasource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 創(chuàng)建SqlSessionFactory
     *
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "db1SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("db1Datasource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return bean.getObject();
    }

    /**
     * 配置事務管理
     *
     * @param dataSource
     * @return
     */
    @Bean(name = "db1TransactionManager")
    public DataSourceTransactionManager testTransactionManager(
            @Qualifier("db1Datasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "db1SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("db1SqlSessionFactory")
                                                             SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

package com.aresbf.multi.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.aresbf.multi.mapper.db2", sqlSessionFactoryRef = "db2SqlSessionFactory")
public class DataSource2 {

    /**
     * 配置db2數據庫
     *
     * @return
     */
    @Bean(name = "db2Datasource")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource testDatasource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 創(chuàng)建SqlSessionFactory
     *
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "db2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("db2Datasource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return bean.getObject();
    }

    /**
     * 配置事務管理
     *
     * @param dataSource
     * @return
     */
    @Bean(name = "db2TransactionManager")
    public DataSourceTransactionManager testTransactionManager(
            @Qualifier("db2Datasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "db2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("db2SqlSessionFactory")
                                                             SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

3.4 動態(tài)切換數據源

創(chuàng)建動態(tài)數據源配置

package com.aresbf.multi.config;

import com.aresbf.multi.dynamicdatasource.DataSourceRouting;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
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 javax.sql.DataSource;

/**
 * @description:sameDb動態(tài)數據源
 * @author: aresbf
 * @createDate: 2022/10/21
 */
@Configuration
@Slf4j
@MapperScan(basePackages = "com.aresbf.multi.mapper.same_db", sqlSessionTemplateRef = "sameDbDynamicSqlSessionTemplate")
public class SameDbDynamicDataSourceConfig {

    /**
     * 自定義動態(tài)datasource
     *
     * @param sameDbPrivateDataSource 對內datasource
     * @param sameDbPublicDataSource  對外datasource
     * @return DataSource
     */
    @Bean(name = "sameDbDynamicDataSource")
    @Primary
    public DataSource dataSource(@Qualifier("sameDbPrivateDataSource") DataSource sameDbPrivateDataSource, @Qualifier("sameDbPublicDataSource") DataSource sameDbPublicDataSource) {
        DataSourceRouting routingDataSource = new DataSourceRouting();
        routingDataSource.initDatasource(sameDbPrivateDataSource,
                sameDbPublicDataSource);
        return routingDataSource;
    }

    /**
     * 對內datasource
     *
     * @return DataSource
     */
    @Bean(name = "sameDbPrivateDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.same-db-private")
    public DataSource sameDbPrivateDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 對外datasource
     *
     * @return DataSource
     */
    @Bean(name = "sameDbPublicDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.same-db-public")
    public DataSource sameDbPublicDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 自定義SqlSessionFactory
     *
     * @param dataSource 自定義datasource
     * @return SqlSessionFactory
     * @throws Exception
     */
    @Bean(name = "sameDbDynamicSqlSessionFactory")
    public SqlSessionFactory customSqlSessionFactory(@Qualifier("sameDbDynamicDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //實現(xiàn)數據庫下劃線字段到POJO類駝峰形式的自動映射
        bean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return bean.getObject();
    }

    /**
     * 自定義DataSourceTransactionManager
     *
     * @param dataSource 自定義datasource
     * @return DataSourceTransactionManager
     */
    @Bean(name = "sameDbDynamicTransactionManager")
    @Primary
    public DataSourceTransactionManager customTransactionManager(@Qualifier("sameDbDynamicDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * 自定義SqlSessionTemplate
     *
     * @param sqlSessionFactory 自定義SqlSessionFactory
     * @return SqlSessionTemplate
     */
    @Bean(name = "sameDbDynamicSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate customSqlSessionTemplate(@Qualifier("sameDbDynamicSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

創(chuàng)建區(qū)分動態(tài)數據源枚舉項

package com.aresbf.multi.dynamicdatasource;

import lombok.Getter;

/**
 * @description: 動態(tài)數據源枚舉
 * @author: aresbf
 * @createDate: 2022/10/26
 */
public enum DynamicDataSourceEnum {
    /**
     * 對內系統(tǒng)數據庫
     */
    SAME_DB_PRIVATE("SAME_DB_PRIVATE", "對內系統(tǒng)數據庫"),
    /**
     * 對外系統(tǒng)數據庫
     */
    SAME_DB_PUBLIC("SAME_DB_PUBLIC", "對外系統(tǒng)數據庫"),
    ;

    /**
     * 數據源code
     */
    @Getter
    private final String dataSource;
    /**
     * 描述
     */
    private final String description;

    /**
     * 構造器
     *
     * @param dataSource  數據源標識
     * @param description 描述
     */
    DynamicDataSourceEnum(String dataSource, String description) {
        this.dataSource = dataSource;
        this.description = description;
    }
}

動態(tài)數據源切換上下文

package com.aresbf.multi.dynamicdatasource;

import lombok.extern.slf4j.Slf4j;

/**
 * @description: 動態(tài)數據源切換用上下文
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Slf4j
public class DataSourceContextHolder {

    /**
     * 用于存在數據源切換標識
     */
    private static ThreadLocal<DynamicDataSourceEnum> datasourceContext = new ThreadLocal<>();

    /**
     * 切換數據源
     *
     * @param dynamicDataSourceEnum 要切換的數據源標識
     */
    public static void switchDataSource(DynamicDataSourceEnum dynamicDataSourceEnum) {
        log.debug("switchDataSource: {}", dynamicDataSourceEnum.getDataSource());
        datasourceContext.set(dynamicDataSourceEnum);
    }

    /**
     * 獲取當前的數據源標識
     *
     * @return
     */
    public static DynamicDataSourceEnum getDataSource() {
        return datasourceContext.get();
    }

    /**
     * 清理上下文中的數據源標識
     */
    public static void clear() {
        datasourceContext.remove();
    }
}

動態(tài)路由

package com.aresbf.multi.dynamicdatasource;

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

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

/**
 * @description:動態(tài)數據源路由
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Slf4j
public class DataSourceRouting extends AbstractRoutingDataSource {

    /**
     * 決定使用哪個數據源標識
     *
     * @return 數據源標識
     */
    @Override
    protected Object determineCurrentLookupKey() {
        DynamicDataSourceEnum dynamicDataSourceEnum = DataSourceContextHolder.getDataSource();
        //如果沒有設置數據源標識，默認使用對內數據源標識
        if (dynamicDataSourceEnum == null) {
            dynamicDataSourceEnum = DynamicDataSourceEnum.SAME_DB_PRIVATE;
        }
        log.debug("use{}", dynamicDataSourceEnum.getDataSource());
        return dynamicDataSourceEnum;
    }

    /**
     * 初始化數據源列表
     *
     * @param sameDbPrivate 對內數據源
     * @param sameDbPublic  對外數據源
     */
    public void initDatasource(DataSource sameDbPrivate,
                               DataSource sameDbPublic) {
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put(DynamicDataSourceEnum.SAME_DB_PRIVATE, sameDbPrivate);
        dataSourceMap.put(DynamicDataSourceEnum.SAME_DB_PUBLIC, sameDbPublic);
        this.setTargetDataSources(dataSourceMap);
        this.setDefaultTargetDataSource(sameDbPrivate);
    }
}

自定義動態(tài)數據源注解

package com.aresbf.multi.dynamicdatasource;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @description:自定義動態(tài)數據源注解
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SameDbDynamicDataSource {
    /**
     * 數據源標識
     *
     * @return DynamicDataSourceEnum
     */
    DynamicDataSourceEnum name() default DynamicDataSourceEnum.SAME_DB_PRIVATE;
}

動態(tài)數據源攔截

package com.aresbf.multi.dynamicdatasource;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @description:動態(tài)數據源攔截
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Aspect
@Component
public class HandleDatasourceAspect {

    /**
     * 所有標識sameDbDynamicDataSource注解的類和方法
     */
    @Pointcut("@annotation(com.aresbf.multi.dynamicdatasource.SameDbDynamicDataSource)||@within(com.aresbf.multi.dynamicdatasource.SameDbDynamicDataSource)")
    public void pointcut() {
    }

    /**
     * 方法執(zhí)行前
     *
     * @param joinPoint 攔截點
     */
    @Before("pointcut()")
    public void beforeExecute(JoinPoint joinPoint) {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        SameDbDynamicDataSource annotation = method.getAnnotation(SameDbDynamicDataSource.class);
        if (null == annotation) {
            annotation = joinPoint.getTarget().getClass().getAnnotation(SameDbDynamicDataSource.class);
        }
        if (null != annotation) {
            // 切換數據源
            DataSourceContextHolder.switchDataSource(annotation.name());
        }
    }

    /**
     * 方法執(zhí)行后
     */
    @After("pointcut()")
    public void afterExecute() {
        DataSourceContextHolder.clear();
    }
}

3.5 編寫測試類

通過SameDbDynamicDataSource動態(tài)指定需要訪問的數據源，避免相同的mapper代碼重復寫文章來源地址http://www.zghlxwxcb.cn/news/detail-700221.html

package com.aresbf.multi.controller;

import com.aresbf.multi.dynamicdatasource.DynamicDataSourceEnum;
import com.aresbf.multi.dynamicdatasource.SameDbDynamicDataSource;
import com.aresbf.multi.entity.BrandInfoPO;
import com.aresbf.multi.entity.GoodsInfoPO;
import com.aresbf.multi.entity.UserInfoPO;
import com.aresbf.multi.service.BrandInfoService;
import com.aresbf.multi.service.GoodsInfoService;
import com.aresbf.multi.service.UserInfoService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
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.HashMap;
import java.util.List;

/**
 * @description: 測試
 * @author: aresbf
 * @createDate: 2022/10/24
 */
@RestController
@RequestMapping
@Slf4j
public class TestController {
    @Autowired
    private GoodsInfoService goodsInfoService;
    @Autowired
    private UserInfoService userInfoService;
    @Autowired
    private BrandInfoService brandInfoService;

    /**
     * 查內部
     *
     * @return ok
     */
    @GetMapping("/queryPrivate")
    @SameDbDynamicDataSource(name = DynamicDataSourceEnum.SAME_DB_PRIVATE)
    public String queryPrivate() throws JsonProcessingException {
        List<GoodsInfoPO> goodsInfoPOS = goodsInfoService.queryAll();
        List<UserInfoPO> userInfoPOS = userInfoService.queryAll();
        List<BrandInfoPO> brandInfoPOS = brandInfoService.queryAll();
        HashMap<String, List> resultMap = new HashMap<>();
        resultMap.put("goodsInfo", goodsInfoPOS);
        resultMap.put("userInfo", userInfoPOS);
        resultMap.put("brandInfo", brandInfoPOS);
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.writeValueAsString(resultMap);
    }

    /**
     * 查外部
     *
     * @return ok
     */
    @GetMapping("/queryPublic")
    @SameDbDynamicDataSource(name = DynamicDataSourceEnum.SAME_DB_PUBLIC)
    public String queryPublic() throws JsonProcessingException {
        List<GoodsInfoPO> goodsInfoPOS = goodsInfoService.queryAll();
        List<UserInfoPO> userInfoPOS = userInfoService.queryAll();
        List<BrandInfoPO> brandInfoPOS = brandInfoService.queryAll();
        HashMap<String, List> resultMap = new HashMap<>();
        resultMap.put("goodsInfo", goodsInfoPOS);
        resultMap.put("userInfo", userInfoPOS);
        resultMap.put("brandInfo", brandInfoPOS);
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.writeValueAsString(resultMap);
    }
}

3.6 測試結果

3.6.1 請求http://localhost:8080/queryPublic

{"userInfo":[{"id":1,"name":"用戶1"},{"id":2,"name":"用戶2"},{"id":3,"name":"用戶3"}],"brandInfo":[{"id":1,"name":"外部品牌1"}],"goodsInfo":[{"id":1,"name":"商品1"},{"id":2,"name":"商品2"},{"id":3,"name":"商品3"}]}

3.6.2 請求http://localhost:8080/queryPrivate

{"userInfo":[{"id":1,"name":"用戶1"},{"id":2,"name":"用戶2"},{"id":3,"name":"用戶3"}],"brandInfo":[{"id":1,"name":"內部品牌1"}],"goodsInfo":[{"id":1,"name":"商品1"},{"id":2,"name":"商品2"},{"id":3,"name":"商品3"}]}

到了這里，關于springboot+mybatis實現(xiàn)多數據源的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！

本文來自互聯(lián)網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。如若轉載，請注明出處：如若內容造成侵權/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經查實，立即刪除！

分享到：

領支付寶紅包贊助服務器費用

springboot+mybatis實現(xiàn)多數據源
最近做項目碰到了一個需要連4個不同數據庫的需求，其中db1、db2表結構都不相同；另外兩個數據庫same_db_private、same_db_public表結構完全相同，一個對內一個對外，只是從物理上隔離了數據而已。所以打算通過靜態(tài)配置包路徑的方式來實現(xiàn)db1、db2的操作，并且通過擴展Spring的
2024年02月09日
瀏覽(28)
使用dynamic-datasource-spring-boot-starter動態(tài)切換數據源操作數據庫(MyBatis-3.5.9)
記錄：383 場景：使用dynamic-datasource-spring-boot-starter動態(tài)切換數據源，使用MyBatis操作數據庫。提供三種示例：一，使用@DS注解作用到類上。二，使用@DS注解作用到方法上。三，不使用注解，使用DynamicDataSourceContextHolder類在方法內靈活切換不同數據源。源碼： https://github.com/
2024年01月20日
瀏覽(25)
MyBatis整合Springboot多數據源實現(xiàn)
數據源，實際就是數據庫連接池，負責管理數據庫連接，在 Springboot 中，數據源通常以一個 bean 的形式存在于 IOC 容器中，也就是我們可以通過依賴注入的方式拿到數據源，然后再從數據源中獲取數據庫連接。那么什么是多數據源呢，其實就是 IOC 容器中有多個數據源的 bea
2023年04月22日
瀏覽(25)
SpringBoot結合MyBatis實現(xiàn)多數據源配置
SpringBoot框架實現(xiàn)多數據源操作，首先需要搭建Mybatis的運行環(huán)境。由于是多數據源，也就是要有多個數據庫，所以，我們創(chuàng)建兩個測試數據庫，分別是：【sp-demo01】和【sp-demo02】，如下圖所示：具體SQL代碼：創(chuàng)建【sp-demo01】數據庫。創(chuàng)建【sp-demo02】數據庫。 MyBatis框架中，
2024年02月09日
瀏覽(15)
springboot+mybatis實現(xiàn)mysql和oracle多數據源
在實際項目中很多時候會涉及到多個數據庫的訪問，或者數據庫讀寫分離的形式。下面通過使用 Aspect+注解來實現(xiàn)mysql+oracle的多數據源配置（注意：事務一致性未提供）首先要去oracle官網下載ojdbc的jar包，根據oracle的版本去下載，或者在下載的oracle的jdbc包下的lib里面有，然后
2024年02月07日
瀏覽(28)
springBoot-Mybatis-Plus 多數據源切換實現(xiàn)
前言：本文主要通過AbstractRoutingDataSource，實現(xiàn)根據 http 訪問攜帶的標識動態(tài)切換數據源； 1 AbstractRoutingDataSource 介紹： AbstractRoutingDataSource 是 Spring 框架中的一個抽象類，它可以用來實現(xiàn)動態(tài)數據源切換。在多數據源場景下，AbstractRoutingDataSource 可以根據不同的請求來動態(tài)地選
2024年02月03日
瀏覽(23)
SpringBoot整合Mybatis-Plus+Druid實現(xiàn)多數據源
??本文主要講解 springboot +mybatisplus + druid 實現(xiàn)多數據源配置功能 ?? 主頁傳送門：?? 傳送 Spring Boot： ? ?Spring Boot是一個基于Spring框架的開源Java開發(fā)框架，旨在簡化Spring應用程序的開發(fā)、配置和部署。它提供了一種快速、敏捷的方式來構建獨立的、生產級別的Spring應用程
2024年02月09日
瀏覽(25)
使用Spring Boot和JPA實現(xiàn)多數據源的方法
使用Spring Boot和JPA實現(xiàn)多數據源的方法：添加相關依賴：在pom.xml文件中添加Spring Boot和JPA的依賴項，例如Spring Boot Starter Data JPA和相應的數據庫驅動。配置數據源：在application.properties（或application.yml）文件中，配置多個數據源的連接信息，如數據庫URL、用戶名和密碼。創(chuàng)建數
2024年01月21日
瀏覽(70)
如何在Spring Boot應用中使用Nacos實現(xiàn)動態(tài)更新數據源
???? 博主貓頭虎帶您 Go to New World.??? ?? 博客首頁——貓頭虎的博客?? ??《面試題大全專欄》文章圖文并茂??生動形象??簡單易學！歡迎大家來踩踩~?? ?? 《IDEA開發(fā)秘籍專欄》學會IDEA常用操作，工作效率翻倍~?? ?? 《100天精通Golang(基礎入門篇）》學會Golang語言
2024年02月10日
瀏覽(22)
Spring Boot集成Druid實現(xiàn)多數據源的兩種方式
目錄項目場景：一、集成com.baomidou的方式 1、maven依賴： 2、?配置文件： 3、?使用注解切換數據源：? 二、基于AOP手動實現(xiàn)多數據源原生的方式 1、maven依賴： 2、?配置文件： 3、?多數據源名稱類 4、自定義注解? 5、配置類 6、動態(tài)數據源配置 ?7、AOP切面攔截注解 8、Dao層，
2024年02月09日
瀏覽(20)