首页 > 编程语言 >【详解】JavaSpringMVC+MyBitis+多数据源切换

【详解】JavaSpringMVC+MyBitis+多数据源切换

时间：2025-01-19 19:03:37浏览次数：3  
标签：数据源 JavaSpringMVC springframework MyBitis dataSource import org public

目录

Java Spring MVC + MyBatis + 多数据源切换

1. 环境准备

2. 添加依赖

3. 配置多数据源

4. 创建数据源配置类

5. 动态数据源切换

5.1 动态数据源类

5.2 数据源上下文持有者

5.3 切面管理数据源选择

5.4 自定义注解

6. 使用示例

6.1 UserMapper

6.2 OrderMapper

6.3 Service层

1. 配置文件

2. 自定义数据源切换策略

3. Service层

4. Controller层

5. Mapper接口和XML文件

6. 实体类

1. 添加依赖

2. 配置数据源

3. 实现动态数据源切换

4. 数据源上下文管理

5. 切换数据源

6. Mapper接口

7. XML映射文件

Java Spring MVC + MyBatis + 多数据源切换

在企业级应用开发中，经常需要处理来自不同数据库的数据。为了满足这一需求，我们可以通过配置多个数据源来实现对不同数据库的访问。本文将介绍如何在Spring MVC框架下结合MyBatis实现多数据源的动态切换。

1. 环境准备

  • Java：1.8 或更高版本
  • Spring Boot：2.3.0.RELEASE
  • MyBatis：3.5.2
  • 数据库：MySQL（示例使用两个不同的数据库实例）

2. 添加依赖

首先，在​​pom.xml​​文件中添加必要的依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- MyBatis Spring Boot Starter -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.1</version>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- Spring Boot Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

3. 配置多数据源

在​​application.properties​​文件中配置两个数据源：

# 数据源1
spring.datasource.datasource1.jdbc-url=jdbc:mysql://localhost:3306/db1?useSSL=false&serverTimezone=UTC
spring.datasource.datasource1.username=root
spring.datasource.datasource1.password=password
spring.datasource.datasource1.driver-class-name=com.mysql.cj.jdbc.Driver

# 数据源2
spring.datasource.datasource2.jdbc-url=jdbc:mysql://localhost:3306/db2?useSSL=false&serverTimezone=UTC
spring.datasource.datasource2.username=root
spring.datasource.datasource2.password=password
spring.datasource.datasource2.driver-class-name=com.mysql.cj.jdbc.Driver

4. 创建数据源配置类

创建一个配置类来管理多个数据源：

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.boot.jdbc.DataSourceBuilder;
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 javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.example.mapper", sqlSessionFactoryRef = "sqlSessionFactory")
public class DataSourceConfig {

    @Bean(name = "datasource1")
    @ConfigurationProperties(prefix = "spring.datasource.datasource1")
    public DataSource dataSource1() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "datasource2")
    @ConfigurationProperties(prefix = "spring.datasource.datasource2")
    public DataSource dataSource2() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "sqlSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactory(@Qualifier("datasource1") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return factoryBean.getObject();
    }

    @Bean(name = "transactionManager")
    @Primary
    public DataSourceTransactionManager transactionManager(@Qualifier("datasource1") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

5. 动态数据源切换

为了实现动态数据源切换，我们需要创建一个动态数据源类和一个切面来管理数据源的选择：

5.1 动态数据源类
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceKey();
    }
}
5.2 数据源上下文持有者
public class DynamicDataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceKey(String key) {
        contextHolder.set(key);
    }

    public static String getDataSourceKey() {
        return contextHolder.get();
    }

    public static void clearDataSourceKey() {
        contextHolder.remove();
    }
}
5.3 切面管理数据源选择
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class DataSourceAspect {

    @Before("@annotation(com.example.annotation.TargetDataSource)")
    public void switchDataSource(JoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        TargetDataSource targetDataSource = signature.getMethod().getAnnotation(TargetDataSource.class);
        if (targetDataSource != null) {
            String dataSource = targetDataSource.value();
            DynamicDataSourceContextHolder.setDataSourceKey(dataSource);
        }
    }
}
5.4 自定义注解
import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String value();
}

6. 使用示例

假设我们有两个数据库表​​user​​和​​order​​分别位于​​db1​​和​​db2​​中，我们可以这样编写DAO层：

6.1 UserMapper
import com.example.entity.User;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user WHERE id = #{id}")
    User getUserById(@Param("id") int id);
}
6.2 OrderMapper
import com.example.entity.Order;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OrderMapper {

    @Select("SELECT * FROM order WHERE id = #{id}")
    Order getOrderById(@Param("id") int id);
}
6.3 Service层
import com.example.annotation.TargetDataSource;
import com.example.entity.User;
import com.example.entity.Order;
import com.example.mapper.UserMapper;
import com.example.mapper.OrderMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private OrderMapper orderMapper;

    @TargetDataSource("datasource1")
    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }

    @TargetDataSource("datasource2")
    public Order getOrderById(int id) {
        return orderMapper.getOrderById(id);
    }
}

通过上述步骤，我们成功地在Spring MVC项目中实现了MyBatis的多数据源动态切换。这种方法不仅提高了系统的灵活性，还使得跨数据库操作变得更加简单和高效。希望这篇文章能对你有所帮助！

以上是一个关于在Spring MVC框架下结合MyBatis实现多数据源动态切换的技术博客文章。希望对你有所帮助！当然可以！下面是一个简单的示例，展示如何在Spring MVC项目中使用MyBatis实现多数据源切换。这个例子将包括以下几个部分：

  1. 配置文件：定义多个数据源和对应的SQLSessionFactory。
  2. 自定义数据源切换策略：通过一个注解来动态选择数据源。
  3. Service层：使用自定义注解来指定数据源。
  4. Controller层：调用Service层的方法。
1. 配置文件

首先，我们需要在​​applicationContext.xml​​中配置多个数据源和对应的SQLSessionFactory。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 数据源1 -->
    <bean id="dataSource1" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/db1"/>
        <property name="username" value="user1"/>
        <property name="password" value="password1"/>
    </bean>

    <!-- 数据源2 -->
    <bean id="dataSource2" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/db2"/>
        <property name="username" value="user2"/>
        <property name="password" value="password2"/>
    </bean>

    <!-- 动态数据源 -->
    <bean id="dynamicDataSource" class="com.example.config.DynamicDataSource">
        <property name="targetDataSources">
            <map key-type="java.lang.String">
                <entry key="dataSource1" value-ref="dataSource1"/>
                <entry key="dataSource2" value-ref="dataSource2"/>
            </map>
        </property>
        <property name="defaultTargetDataSource" ref="dataSource1"/>
    </bean>

    <!-- SQLSessionFactory1 -->
    <bean id="sqlSessionFactory1" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource1"/>
        <property name="mapperLocations" value="classpath:mapper/db1/*.xml"/>
    </bean>

    <!-- SQLSessionFactory2 -->
    <bean id="sqlSessionFactory2" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource2"/>
        <property name="mapperLocations" value="classpath:mapper/db2/*.xml"/>
    </bean>

    <!-- SqlSessionTemplate1 -->
    <bean id="sqlSessionTemplate1" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory1"/>
    </bean>

    <!-- SqlSessionTemplate2 -->
    <bean id="sqlSessionTemplate2" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory2"/>
    </bean>

    <!-- Transaction Manager -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dynamicDataSource"/>
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!-- 扫描Service层 -->
    <context:component-scan base-package="com.example.service"/>

</beans>
2. 自定义数据源切换策略

创建一个动态数据源类​​DynamicDataSource​​，并定义一个注解​​@TargetDataSource​​来指定数据源。

package com.example.config;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

package com.example.config;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String value();
}

创建一个线程本地变量​​DataSourceContextHolder​​来保存当前的数据源。

package com.example.config;

public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}
3. Service层

在Service层中使用​​@TargetDataSource​​注解来指定数据源。

package com.example.service;

import com.example.config.TargetDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    @TargetDataSource("dataSource1")
    public void addUserToDB1(User user) {
        userMapper.insertUser(user);
    }

    @Transactional
    @TargetDataSource("dataSource2")
    public void addUserToDB2(User user) {
        userMapper.insertUser(user);
    }
}
4. Controller层

在Controller层中调用Service层的方法。

package com.example.controller;

import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/db1")
    public String addUserToDB1(@RequestBody User user) {
        userService.addUserToDB1(user);
        return "User added to DB1";
    }

    @PostMapping("/db2")
    public String addUserToDB2(@RequestBody User user) {
        userService.addUserToDB2(user);
        return "User added to DB2";
    }
}
5. Mapper接口和XML文件

定义Mapper接口和对应的XML文件。

package com.example.mapper;

import com.example.entity.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {

    @Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
    void insertUser(User user);
}

在​​src/main/resources/mapper/db1/UserMapper.xml​​和​​src/main/resources/mapper/db2/UserMapper.xml​​中定义SQL映射。

<!-- src/main/resources/mapper/db1/UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insertUser" parameterType="com.example.entity.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>

<!-- src/main/resources/mapper/db2/UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insertUser" parameterType="com.example.entity.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>
6. 实体类

定义一个简单的实体类​​User​​。

package com.example.entity;

public class User {
    private String name;
    private String email;

    // Getters and Setters
}

以上代码展示了如何在Spring MVC项目中使用MyBatis实现多数据源切换。通过自定义注解和动态数据源类，可以在运行时根据需要切换不同的数据源。希望这个示例对你有帮助！如果有任何问题或需要进一步的帮助，请随时告诉我。在Java项目中使用Spring MVC框架结合MyBatis进行开发时，如果需要处理多个数据库的数据源切换，可以通过配置Spring的​​AbstractRoutingDataSource​​来实现。以下是一个详细的步骤和示例代码，展示如何在一个Spring MVC + MyBatis项目中实现多数据源切换。

1. 添加依赖

首先，在你的​​pom.xml​​文件中添加Spring、MyBatis及相关依赖：

<dependencies>
    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.10</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.4</version>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>

    <!-- HikariCP Connection Pool -->
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
        <version>4.0.3</version>
    </dependency>
</dependencies>
2. 配置数据源

创建一个配置类来定义多个数据源，并通过​​AbstractRoutingDataSource​​实现数据源的动态切换。

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

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

@Configuration
@MapperScan("com.example.mapper")
public class DataSourceConfig {

    @Bean
    public DataSource dataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("dataSource1", dataSource1());
        targetDataSources.put("dataSource2", dataSource2());
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(dataSource1());
        return dynamicDataSource;
    }

    @Bean
    public DataSource dataSource1() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public DataSource dataSource2() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db2");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();
    }

    @Bean
    public DataSourceTransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}
3. 实现动态数据源切换

创建一个继承自​​AbstractRoutingDataSource​​的类来管理数据源的切换逻辑。

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceKey();
    }
}
4. 数据源上下文管理

创建一个线程安全的上下文管理器来保存当前线程使用的数据源键。

public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceKey(String key) {
        contextHolder.set(key);
    }

    public static String getDataSourceKey() {
        return contextHolder.get();
    }

    public static void clearDataSourceKey() {
        contextHolder.remove();
    }
}
5. 切换数据源

在需要切换数据源的地方，调用​​DataSourceContextHolder​​的方法来设置当前线程使用的数据源。

@RestController
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @GetMapping("/users1")
    public List<User> getUsersFromDataSource1() {
        DataSourceContextHolder.setDataSourceKey("dataSource1");
        List<User> users = userMapper.selectAll();
        DataSourceContextHolder.clearDataSourceKey();
        return users;
    }

    @GetMapping("/users2")
    public List<User> getUsersFromDataSource2() {
        DataSourceContextHolder.setDataSourceKey("dataSource2");
        List<User> users = userMapper.selectAll();
        DataSourceContextHolder.clearDataSourceKey();
        return users;
    }
}
6. Mapper接口

定义MyBatis的Mapper接口，用于访问数据库。

public interface UserMapper {
    List<User> selectAll();
}
7. XML映射文件

在​​resources/mapper​​目录下创建XML映射文件，例如​​UserMapper.xml​​。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectAll" resultType="com.example.model.User">
        SELECT * FROM user
    </select>
</mapper>

以上步骤展示了如何在Spring MVC + MyBatis项目中实现多数据源切换。通过这种方式，你可以在不同的请求或业务逻辑中灵活地切换数据源。

标签：数据源,JavaSpringMVC,springframework,MyBitis,dataSource,import,org,public
From： https://blog.csdn.net/q7w8e9r4/article/details/145245990

相关文章

  • 从单数据源到多数据源的探讨
    今天我想简单地分享一下如何将一个老项目从单数据源切换为多数据源的过程。这个项目是一个使用WAR部署的传统JSPWeb项目，运行在JDK1.7环境下，项目中并没有使用SpringBoot，而仅仅采用了SpringMVC框架。我的主要任务是将原本使用单一数据源的架构，升级为支持多数据源的架构......
  • springboot环境下的rokectMQ多数据源实现
    业务原因，需要在一个项目中与多方MQ进行业务通信；步骤一，复制一份RocketMQProperties配置文件，避免与原来的冲突packagecom.heit.road.web.config;importorg.apache.rocketmq.common.topic.TopicValidator;importjava.util.HashMap;importjava.util.Map;publicclassMu......
  • DevExpress gridControl 绑定数据源之后添加非绑定列
    using(DevExpress.Utils.WaitDialogFormdlg=newDevExpress.Utils.WaitDialogForm("请稍等","查询中......",newSystem.Drawing.Size(100,50))){stringsqlString="SELECTITEM,DESCRIPTION,CATEGORY3FROMW......
  • dolphinscheduler 创建 mssql 数据源失败解决
    解决方法：在参数处加入{"encryp":"false","trustServerCertificate":"true"}现象：[ERROR]2025-01-1110:44:36.821+0800org.apache.dolphinscheduler.plugin.datasource.api.datasource.AbstractDataSourceProcessor:[124]-Checkdataso......
  • 《深入理解Mybatis原理》MyBatis数据源与连接池详解
    MyBatis数据源DataSource分类MyBatis把数据源DataSource分为三种：UNPOOLED不使用连接池的数据源POOLED使用连接池的数据源JNDI使用JNDI实现的数据源相应地，MyBatis内部分别定义了实现了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource类来表示UNPOOLED、P......
  • 【数据库开发】Mybatis 拦截器实现单数据源内多数据库切换
    物流的分拣业务在某些分拣场地只有一个数据源，因为数据量比较大，将所有数据存在一张表内查询速度慢，也为了做不同设备数据的分库管理，便在这个数据源内创建了多个不同库名但表完全相同的数据库，如下图所示：现在需要上线报表服务来查询所有数据库中的数据进行统计，那么现在的问题来了，该......
  • 前端学习openLayers配合vue3（加载线上数据源）
    现在我们学习一下加载网上的线上数据再加上点矢量图层，紧接着上一步关键代码layers:[//瓦片图层source第三方，或者自带的,地图的底层newTileLayer({//source:newOSM(),//内置的国外地址，需要代理source:newXYZ({url......
  • blade-boot配置多数据源(JDK17版)
    blade-boot默认选择了mysql作为数据源，现在需要增加一个SQLsever的数据源，配置如下：第一步，修改java.security路径：java安装目录\conf\security\java.security第二步，修改pom文件增加如下内容：<dependency><groupId>com.microsoft.sqlserver</groupId><artifactId>mss......
  • 多数据源配置：使用Dynamic-datasource框架实现数据源切换、动态新增且使用新数据源、查
    前言多数据源的切换具有十分广泛的应用场景，同时可以简化主从复制、读写分离等方案的实现过程，通过继承AbstractRoutingDataSource并重写相关方法，结合拦截器、AOP以及自定义注解即可实现，但过程比较繁琐。因此可以利用Dynamic-datasource框架轻松实现数据源切换，并且通过框架预留......
  • spring boot 增加dynamic-datasource-spring-boot-starter多数据源依赖，项目打包后运行
    在本地idea运行正常，打包部署后运行会报错，经过github查询是dynamic-datasource-spring-boot-starter3.3.0版本存在问题，需要升级到3.3.1以上版本就可以正常运行<dependency><groupId>com.baomidou</groupId><artifactId>dynamic-datasource-spring-boot-st......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99