快速搭建springboot maven项目 多数据源

最新推荐文章于 2024-05-24 10:57:31 发布
最新推荐文章于 2024-05-24 10:57:31 发布
阅读量475 收藏
点赞数 1
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pete1024/article/details/109273996
版权
  • 新建项目
  • 修改pom
  • 添加配置文件

新建父项目

  1. IDEA -->Spring Initializr, 设置报名,其他next完成
  2. 删除其他目录,值保留.gitignore 和 pom.xml
  3. 修改pom文件 
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<!--    1.删除parent:使用公司自己的parent控制版本 子项目不用再写版本号统一管理(子项目也可以自己修改,就近原则) -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
<!--    2.添加版本号-->
    <properties>
        <java.version>1.8</java.version>
    </properties>
<!--    3.使用 dependencyManagement 管理版本号-->
    <dependencyManagement></dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 常用工具类 -->
        <dependency>  
            <groupId>org.apache.commons</groupId>  
            <artifactId>commons-lang3</artifactId>  
            <version>3.12.0</version>  
        </dependency>
        <dependency>  
            <groupId>org.apache.commons</groupId>  
            <artifactId>commons-collections4</artifactId>  
            <version>4.4</version>  
        </dependency>
        <dependency>  
            <groupId>commons-beanutils</groupId>  
            <artifactId>commons-beanutils</artifactId>  
            <version>1.9.4</version>  
        </dependency>
        <dependency>  
            <groupId>commons-io</groupId>  
            <artifactId>commons-io</artifactId>  
            <version>2.8.0</version>  
        </dependency>
        <dependency>  
            <groupId>com.google.guava</groupId>  
            <artifactId>guava</artifactId>  
            <version>30.1.1-jre</version>  
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

     

  4. 修改后

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>


    <groupId>com.ajlily.dev</groupId>
    <artifactId>qinjiao</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>zhuawacourse</name>

    <properties>
        <java.version>1.8</java.version>
        <course.version>0.0.1-SNAPSHOT</course.version>
        <!--spring依赖版本控制（和spring-boot-parent版本保持一致）-->
        <springframework.version>4.3.13.RELEASE</springframework.version>
        <!--spring-boot-parent版本号，通过spring-boot管理其他第三方依赖版本-->
        <spring.boot.version>2.2.1.RELEASE</spring.boot.version>
        <mybatisplus.version>3.2.0</mybatisplus.version>
        <jedis.version>2.9.0</jedis.version>
    </properties>

    <dependencyManagement>

        <dependencies>
            <!-- 统一管理Spring依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.8</version>
                <optional>true</optional>
            </dependency>

            <!--mybatis plus-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>
            <!--MyBatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.1</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.13</version>
            </dependency>
            <dependency>
                <groupId>p6spy</groupId>
                <artifactId>p6spy</artifactId>
                <version>3.8.5</version>
            </dependency>
            <!--mybatis文件生成需要-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-generator</artifactId>
                <version>3.3.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.velocity</groupId>
                <artifactId>velocity-engine-core</artifactId>
                <version>2.0</version>
            </dependency>
            <!--mybatis文件生成需要-->
            <!-- 动态数据源 -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
                <version>2.5.4</version>
            </dependency>
            <!--kafka-->
            <!-- https://mvnrepository.com/artifact/org.springframework.kafka/spring-kafka -->
            <dependency>
                <groupId>org.springframework.kafka</groupId>
                <artifactId>spring-kafka</artifactId>
                <version>2.4.0.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
            <dependency>
                <groupId>org.apache.kafka</groupId>
                <artifactId>kafka-clients</artifactId>
                <version>2.4.0</version>
            </dependency>

            <!-- 用于日志切面中，以 json 格式打印出入参 -->
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>2.8.6</version>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${jedis.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!--统一插件配置版本管理 TODO-->
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <!--指定编译时的jdk版本-->
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

     

新建子项目

  1. New -> Module-->Maven 修改ArifactId;;取名建议-增加标识性
  2. 修改pom;去掉版本号,父项目统一管理 
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>lily</artifactId>
        <groupId>com.qin</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>pete-service</artifactId>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>com.qin</groupId>
            <artifactId>pete-persistence</artifactId>
            <version>${project.parent.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!-- aop 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!-- 用于日志切面中，以 json 格式打印出入参 -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${jedis.version}</version>
        </dependency>
        <!--        <dependency>-->
        <!--            <groupId>org.springframework</groupId>-->
        <!--            <artifactId>spring</artifactId>-->
        <!--            <version>2.5.6.SEC03</version>-->
        <!--            <exclusions>-->
        <!--                <exclusion>-->
        <!--                    <artifactId>commons-logging</artifactId>-->
        <!--                    <groupId>commons-logging</groupId>-->
        <!--                </exclusion>-->
        <!--            </exclusions>-->
        <!--        </dependency>-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.edas.acm</groupId>
            <artifactId>acm-sdk</artifactId>
            <version>1.0.8</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>


</project>

     

  3. 添加springboot相关配置文件;添加数据源,开发环境

     

jpa多数据源配置

  1. 配置文件 
    spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/test1?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.primary.username=root
spring.datasource.primary.password=
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.secondary.jdbc-url=jdbc:mysql://localhost:3306/test2?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.secondary.username=root
spring.datasource.secondary.password=
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

#sql\u8F93\u51FA
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.hbm2ddl.auto=create
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
#format\u4E00\u4E0Bsql\u8FDB\u884C\u8F93\u51FA
spring.jpa.properties.hibernate.format_sql=true

     

  2. 注入DataSource

    1. package com.neo.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
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 javax.sql.DataSource;
import java.util.Map;

@Configuration
public class DataSourceConfig {

    @Autowired
    private JpaProperties jpaProperties;
    @Autowired
    private HibernateProperties hibernateProperties;

    @Bean(name = "primaryDataSource")
    @Primary
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource firstDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "vendorProperties")
    public Map<String, Object> getVendorProperties() {
        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
    }
}

       

    2. package com.neo.config;

import java.util.Map;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
		entityManagerFactoryRef="entityManagerFactoryPrimary",
		transactionManagerRef="transactionManagerPrimary",
		basePackages= { "com.neo.repository.test1" })//设置dao（repo）所在位置
public class PrimaryConfig {

    @Autowired
    @Qualifier("primaryDataSource")
    private DataSource primaryDataSource;

    @Autowired
    @Qualifier("vendorProperties")
    private Map<String, Object> vendorProperties;

    @Bean(name = "entityManagerFactoryPrimary")
    @Primary
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(primaryDataSource)
                .properties(vendorProperties)
                .packages("com.neo.model") //设置实体类所在位置
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }

    @Bean(name = "entityManagerPrimary")
    @Primary
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }

    @Bean(name = "transactionManagerPrimary")
    @Primary
    PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }

}

       

使用

package com.neo.repository.test1;

import com.neo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserTest1Repository extends JpaRepository<User, Long> {
    User findById(long id);
    User findByUserName(String userName);
    User findByUserNameOrEmail(String username, String email);
}

mybatis

  • 配置文件 
    mybatis.type-aliases-package=com.neo.model

spring.datasource.test1.jdbc-url=jdbc:mysql://localhost:3306/test1?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.test1.username=root
spring.datasource.test1.password=
spring.datasource.test1.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.test2.jdbc-url=jdbc:mysql://localhost:3306/test2?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.test2.username=root
spring.datasource.test2.password=
spring.datasource.test2.driver-class-name=com.mysql.cj.jdbc.Driver

     

  • datasource

    package com.neo.datasource;

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;

/**
 * 多数据源  配置类 basePackages指定 mapper数据库
 */
@Configuration
@MapperScan(basePackages = "com.neo.mapper.test2", sqlSessionTemplateRef  = "test2SqlSessionTemplate")
public class DataSource2Config {

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

    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

     

  • package com.neo.mapper.test1;

import com.neo.model.User;
import com.neo.enums.UserSexEnum;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface User1Mapper {


	@Select("SELECT * FROM users")
	@Results({
			@Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
			@Result(property = "nickName", column = "nick_name")
	})
	List<User> getAll();

	@Select("SELECT * FROM users WHERE id = #{id}")
	@Results({
			@Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
			@Result(property = "nickName", column = "nick_name")
	})
	User getOne(Long id);

	@Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})")
	void insert(User user);

	@Update("UPDATE users SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}")
	void update(User user);

	@Delete("DELETE FROM users WHERE id =#{id}")
	void delete(Long id);

}

     

ajLily-1024
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
maven搭建 Spinrgboot + mybais 实现多数据源(SQL server) 2.多数据源配置
浩
11-05 754
2.多数据源 2.1  多数据源  DataSourceConfig 类   多的不说，上代码，上一篇有关于appliaction.yml   pom.xml  mybatis.xml 等配置文件    地址：.https://blog.csdn.net/qq_41129021/article/details/83538706 import org.apache.log4j.Log...
springboot druid maven多数据源（mysql+SqlServer）
03-27
SpringBoot +Maven +Druid 多数据源（Mysql+SqlServer）动态切换数据源
Java maven项目（通用mapper，多数据源）
06-20
该项目（SSM）使用了，mybatis通用mapper 技术，减少代码开发量， 多数据源（切换想要的数据库），连接池， 项目解压就可用， （主看看各配置文件）之间的关系，又不清楚的地方加QQ群614241086 欢迎交流
如何使用maven运行SpringBoot程序？
最新发布
杨荧的CSDN博客
05-24 1268
Spring Boot是一个开源的Java框架，由Pivotal团队（现为VMware的一部分）开发，用于简化Spring应用程序的创建和部署过程。Spring Boot基于Spring框架，提供了一种快速、易于配置的方法来构建独立、生产级别的基于Spring的应用程序。
maven ssh项目配置多数据源
qq_41955582的博客
06-05 791
ssh项目（使用的是oracle数据库）配置多数据源： 1、首先配置多个数据库的连接：在applicationContext_ds.xml中使用配置数据库的连接： 第一个数据源 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" ...
SpringMVC +Mybatis 多个数据源配置 DEMO + maven
11-06
pringMVC +Mybatis 多个数据源配置 DEMO + maven,利用AbstractDataSource抽象化完成多了个数据源的配置
Maven搭建springboot项目的方法步骤
08-19
- 项目中可能会涉及到与数据库的交互，需要添加相应的数据源依赖和配置。 - 为了便于管理Spring Boot应用的配置，可以使用application.yml或application.properties文件在项目资源目录下进行配置。 - 在开发过程中，...
基于Springboot的maven项目
07-14
在IT行业中，Spring Boot是一个备受推崇的框架，它...通过这个项目，你可以学习到如何使用Spring Boot搭建应用，结合MyBatis进行数据操作，以及如何利用Maven管理项目构建。这些都是现代Java开发中不可或缺的重要技能。
springboot maven基础搭建.rar
06-03
通过以上步骤，你就完成了一个基础的SpringBoot、MyBatis、Maven和MySQL项目搭建。这只是一个起点，你可以根据需求进一步扩展，例如添加更多的SpringBoot特性、集成其他服务、优化MyBatis的配置等。对于初学者来说，...
springboot项目框架，多数据源配置，日志，maven多环境打包，集成redis
09-27
SpringBoot项目框架是一种高效、便捷的应用开发工具，它基于Spring框架，简化了Spring应用的初始搭建以及开发过程。SpringBoot的核心理念是“约定优于配置”，它内置了Tomcat服务器，可以快速启动并运行Web应用。在...
springboot多数据源切换mysql+sql server事例
04-28
本示例“springboot多数据源切换mysql+sql server”是关于如何在Spring Boot项目中配置和使用多个数据库的数据源切换。下面将详细阐述这个主题的知识点。 首先，**多数据源**是指在一个应用中同时连接并操作多个...
Maven项目springMVC_Mybatis多数据源_Jersey_Task
06-15
Maven项目springMVC_Mybatis多数据源_Jersey_Task，相关jar包可以参考pom.xml
springmvc+mybatis+maven 多数据源源码
12-06
springmvc+mybatis+maven 多数据源源码,包含ssm框架，多数据源，maven技术
SpringMVC+Mybatis框架的maven Spring boot项目，多数据源的实践
bug_love的博客
05-25 2723
目前最流行的也只是这种SpringMVC+Mybatis框架,做一个项目，公司也不可能让项目只涉及到一个数据源。因为后期可能数据量大的情况，可能项目要重新安排，分布式处理数据也是少不了的。所以无论是后期维护，还是前期准备，都应该多方面考虑，我们用一个数据源可能以后不能满足我们的需求，所以，在搭建框架时，为了以后可扩展性做相应的准备。废话不多说，直接讲如题说的，spring boot 项目如何引用多
eclipse 使用maven 搭建 springboot+mybatis + 多数据源
zhouzhiwengang的专栏
03-16 4402
本文转载至：http://www.cnblogs.com/java-zhao/p/5413845.html 在实际开发中，我们一个项目可能会用到多个数据库，通常一个数据库对应一个数据源。 代码结构： 简要原理： 1）DatabaseType列出所有的数据源的key---key 2）DatabaseContextHolder是一个线程安全的DatabaseTyp
springBoot配置多个数据源
hq091117的博客
06-14 842
有时候项目不止只有一个数据库，可能需要有多个，根据需要切换 准备 1，新建一个springBoot项目，用idea新建很方便，不多说，pom文件的包引入 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoc
Springboot多数据源配置
lizhengyu891231的博客
07-12 250
转载自：https://www.cnblogs.com/carrychan/p/9401471.html 目前，业界流行的数据操作框架是 Mybatis，那 Druid 是什么呢？ Druid 是 Java 的数据库连接池组件。Druid 能够提供强大的监控和扩展功能。比如可以监控 SQL ，在监控业务可以查询慢查询 SQL 列表等。Druid 核心主要包括三部分： 1. DruidDriver...
Maven+SSM——自动切换多数据源
小白的博客
03-26 2292
项目说明：框架：Spring + Spring MVC + Mybatis + AspectJ开发环境：jdk1.7，Tomcat7使用框架AspectJ实现自动切换多数据源，原理是AOP技术，类似于过滤器、监听器、拦截器底层也都是与AOP技术相似，都是将某个你想要做处理的“块”，当成切面或切点。Maven如何创建，我并没有作说明，因为网上的例子实在是太多了，如果有需要我也会添加上的。本文大部分大...
Maven数据源配置
zhangzikui的专栏
09-08 4224
http://blog.sina.com.cn/s/blog_4f925fc30102ed5g.html http://www.360doc.com/content/16/0621/10/33667232_569462412.shtml
快速搭建springboot框架
09-03
总结起来，快速搭建Spring Boot框架主要包括创建项目、配置属性、定义业务类和数据访问类、实现控制器和API等步骤。通过使用Spring Boot的自动配置和集成，我们可以快速地开发和部署一个基于Spring Boot的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值