springboot+jpa整合多(mysql+oracle+mongo)数据源用自定义注解方式+aop+动态数据库绑定实现

最新推荐文章于 2023-10-16 12:06:13 发布
最新推荐文章于 2023-10-16 12:06:13 发布
阅读量922 收藏 5
点赞数
分类专栏： 后端开发（偏java向）经验交流 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy294636185/article/details/118810889
版权

配置类： 

application.properties：

spring:
  datasource:
    default:  //默认数据源
      username: ${MYSQL_USER}
      password: ${MYSQL_PASSWORD}
      jdbc-url: jdbc:mysql://${MYSQL_ADDRESS}/${MYSQL_DB}?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&autoReconnect=true&sessionVariables=sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.alibaba.druid.pool.DruidDataSource
      druid:
        initialSize: 5
        minIdle: 5
        maxActive: 20
        maxWait: 60000
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 1 FROM DUAL
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        filters: slf4j
    mlbmysql:  //mysql
      username: ${MYSQL_USER2}
      password: ${MYSQL_PASSWORD2}
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://${MYSQL_ADDRESS2}/${MYSQL_DB2}?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&autoReconnect=true
    mlboracle:  //oracle
      jdbc-url: jdbc:oracle:thin:@${ORACLE_ADDRESS}/MLBDB
      username: ${ORACLE_USER}
      password: ${ORACLE_PASSWORD}
      driver-class-name: oracle.jdbc.OracleDriver
      type: com.alibaba.druid.pool.DruidDataSource
  data:
     mongodb1:
       uri: mongodb://${MONGODB_USER}:${MONGODB_PASSWORD}@${MONGODB_ADDRESS}/MLB?authSource=admin
     mongodb2:
       uri: mongodb://${MONGODB_USER2}:${MONGODB_PASSWORD2}@${MONGODB_ADDRESS2}/MLB?authSource=admin

  jpa:
    properties:
      hibernate:
        format_sql: true
    database: mysql
    hibernate:
      ddl-auto: none
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    #    show-sql: true

配置数据源Config：

目录结构：

DatabaseConfig：

package com.fii.eodc.intellect.decistionbrain.config.datasource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.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;

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

/**
 * @author aric
 * @create 2021-07-15-15:55
 * @fun
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryPrimary",
        transactionManagerRef = "defaultTransactionManager",
        //设置Repository所在位置-设置扫包范围
        basePackages = {"com.fii.eodc.intellect.decistionbrain.repository"})
public class DatabaseConfig {
    public static final String DEFAULT_T_M = "defaultTransactionManager";
    public static final String MLB_MYSQL_T_M = "mlbmysqlTransactionManager";
    public static final String MLB_ORACLE_T_M = "mlboracleTransactionManager";

    @Autowired
    private JpaProperties jpaProperties;

    @Autowired
    private HibernateProperties hibernateProperties;

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

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

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

    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource(@Qualifier("default") DataSource defaultDataSource,
                                        @Qualifier("mlbmysql") DataSource mlbmysql,
                                        @Qualifier("mlboracle") DataSource mlboracle){
        DynamicDatabase dynamicDataSource = new DynamicDatabase();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
        // 配置多数据源
        Map<Object, Object> dsMap = new HashMap<>();
        dsMap.put("default", defaultDataSource);
        dsMap.put("mlbmysql", mlbmysql);
        dsMap.put("mlboracle", mlboracle);
        dynamicDataSource.setTargetDataSources(dsMap);
        return dynamicDataSource;
    }

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

    @Primary
    @Bean(name = "entityManagerFactoryPrimary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder,@Qualifier("default") DataSource defaultDataSource) {
        return builder
                // 设置数据源
                .dataSource(defaultDataSource)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置hibernate配置
                .properties(getVendorProperties())
                //设置实体类所在位置
                .packages("com.fii.eodc.intellect.decistionbrain.model")
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }

    private Map getVendorProperties() {
        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
    }

    @Primary
    @Bean(name = DEFAULT_T_M)
    public PlatformTransactionManager defaultTransactionManager(EntityManagerFactoryBuilder builder,@Qualifier("default") DataSource defaultDataSource) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder,defaultDataSource).getObject());
    }

//    每个事务管理器需要在不同类下按上述操作重写设置，不然只能查找，不能增删改
//    @Bean(name = MLB_MYSQL_T_M)
//    public PlatformTransactionManager mlbmysqlTransactionManager(@Qualifier("mlbmysql") DataSource mlbmysql) {
//        return new DataSourceTransactionManager(mlbmysql);
//    }
//
//    @Bean(name = MLB_ORACLE_T_M)
//    public PlatformTransactionManager mlboracleTransactionManager(@Qualifier("mlboracle") DataSource mlboracle) {
//        return new DataSourceTransactionManager(mlboracle);
//    }

    //mongoDB连接配置
    @Value("${spring.data.mongodb1.uri}")
    private String mongodb1Url;

    @Value("${spring.data.mongodb2.uri}")
    private String mongodb2Url;

    @Primary
    @Bean
    public MongoTemplate mongoTemplate1(MongoDatabaseFactory mongoDatabaseFactory1){
        return new MongoTemplate(mongoDatabaseFactory1);
    }

    @Bean
    public MongoTemplate mongoTemplate2(@Qualifier("mongoDatabaseFactory2") MongoDatabaseFactory mongoDatabaseFactory2){
        return new MongoTemplate(mongoDatabaseFactory2);
    }

    @Primary
    @Bean
    public MongoDatabaseFactory mongoDatabaseFactory1(){
        return new SimpleMongoClientDatabaseFactory(new ConnectionString(mongodb1Url));
    }

    @Bean
    public MongoDatabaseFactory mongoDatabaseFactory2(){
        return new SimpleMongoClientDatabaseFactory(new ConnectionString(mongodb2Url));
    }
}

 附：配置另一个数据源的事务管理器，以MLB_MYSQL为例：

package com.fii.eodc.intellect.decistionbrain.config.datasource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

/**
 * @author aric
 * @create 2021-07-19-14:58
 * @fun
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryForMLB",
        transactionManagerRef = "mlbmysqlTransactionManager",
        //设置Repository所在位置-设置扫包范围
        basePackages = {"com.fii.eodc.intellect.decistionbrain.mlbRepository"})
public class MlbDatabaseConfig {

    @Autowired
    private JpaProperties jpaProperties;

    @Autowired
    private HibernateProperties hibernateProperties;

    public static final String MLB_MYSQL_T_M = "mlbmysqlTransactionManager";

    /*****************B次Mysql数据源*******************/
    @Bean(name = "entityManagerForMLB")
    public EntityManager entityManagerForMLB(EntityManagerFactoryBuilder builder, @Qualifier("mlbmysql") DataSource mlbmysql) {
        return entityManagerFactoryForMLB(builder,mlbmysql).getObject().createEntityManager();
    }

    @Bean(name = "entityManagerFactoryForMLB")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryForMLB(EntityManagerFactoryBuilder builder, @Qualifier("mlbmysql") DataSource mlbmysql) {
        return builder
                // 设置数据源
                .dataSource(mlbmysql)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置hibernate配置
                .properties(getVendorProperties())
                //设置实体类所在位置
                .packages("com.fii.eodc.intellect.decistionbrain.model")
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("mlbPersistenceUnit")
                .build();
    }

    private Map getVendorProperties() {
        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
    }


    @Bean(name = MLB_MYSQL_T_M)
    public PlatformTransactionManager mlbmysqlTransactionManager(@Qualifier("mlbmysql") DataSource mlbmysql) {
        return new DataSourceTransactionManager(mlbmysql);
    }
}

DatabaseHolder：

package com.fii.eodc.intellect.decistionbrain.config.datasource;

/**
 * @author aric
 * @create 2021-07-15-16:07
 * @fun
 */
public class DatabaseHolder {

    // ThreadLocal每个线程都独有的保存其线程所属的变量值
    private static ThreadLocal<String> holder = new ThreadLocal<>();

    public static void setDatabaseSource(String ds) {
        holder.set(ds);
    }

    public static String getDatabaseSource() {
        return holder.get();
    }

    public static void clearDatabaseSource() {
        holder.remove();
    }

}

DatasourceAspect：

package com.fii.eodc.intellect.decistionbrain.config.datasource;

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.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @author aric
 * @create 2021-07-15-17:12
 * @fun
 */
@Order(1)
@Aspect
@Component
public class DatasourceAspect {

    @Pointcut("@annotation(com.fii.eodc.intellect.decistionbrain.config.datasource.MLBDataSource)")
    public void annotationPointCut() {
    }

    @Before(value = "annotationPointCut()&&@annotation(datasource)")
    public void beforeSwitchDS(JoinPoint point, MLBDataSource datasource) {
        DatabaseHolder.setDatabaseSource(datasource.value().getData());
    }

    @After(value = "annotationPointCut()")
    public void afterSwitchDS(JoinPoint point) {
        DatabaseHolder.clearDatabaseSource();
    }
}

DynamicDatabase：

package com.fii.eodc.intellect.decistionbrain.config.datasource;

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

/**
 * @author aric
 * @create 2021-07-15-16:06
 * @fun
 */
public class DynamicDatabase extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DatabaseHolder.getDatabaseSource();
    }
}

MLBDataCode：

package com.fii.eodc.intellect.decistionbrain.config.datasource;

/**
 * @author aric
 * @create 2021-07-15-17:08
 * @fun
 */
public enum MLBDataCode {

    DEFAULT("default"),

    MLBMYSQL("mlbmysql"),

    MLBORACLE("mlboracle"),
    ;

    private String data;

    MLBDataCode(String data) {

        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

MLBDataSource： 

package com.fii.eodc.intellect.decistionbrain.config.datasource;

import java.lang.annotation.*;

/**
 * @author aric
 * @create 2021-07-15-16:22
 * @fun
 * <p>多数据源标识</p>
 * <p>使用方式：必须用在方法上</p>
 */
@Target(ElementType.METHOD)
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface MLBDataSource {

    MLBDataCode value() default MLBDataCode.DEFAULT;
}

编写测试用例：

DemoController：

package com.fii.eodc.intellect.decistionbrain.controller;

import com.fii.eodc.intellect.decistionbrain.common.response.Result;
import com.fii.eodc.intellect.decistionbrain.model.vo.DemoVO;
import com.fii.eodc.intellect.decistionbrain.service.DemoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
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.List;

/**
 * @author aric
 * @create 2021-06-09-14:09
 * @fun
 */
@Api(tags = "demo")
@RestController
@RequestMapping("/demo")
public class DemoController {

    @Autowired
    private DemoService demoService;

    @ApiOperation(value = "demo",httpMethod = "GET",notes = "demo")
    @GetMapping("/getDemo")
    public Result<List<DemoVO>> getDemo(){
        return Result.success(demoService.getDemo());
    }
}

DemoService：

package com.fii.eodc.intellect.decistionbrain.service;

import com.fii.eodc.intellect.decistionbrain.config.datasource.MLBDataCode;
import com.fii.eodc.intellect.decistionbrain.config.datasource.MLBDataSource;
import com.fii.eodc.intellect.decistionbrain.model.dto.DemoDTO;
import com.fii.eodc.intellect.decistionbrain.model.vo.DemoVO;
import com.fii.eodc.intellect.decistionbrain.repository.DemoRepo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author aric
 * @create 2021-06-09-14:16
 * @fun
 */
@Service
public class DemoService {

    @Autowired
    private DemoRepo demoRepo;

    @MLBDataSource(value = MLBDataCode.MLBMYSQL)  //使用注解方式导入动态数据库
    public List<DemoVO> getDemo() {
        List<DemoDTO> demo = demoRepo.getDemo();
        return demo.stream().map(DemoVO::new).collect(Collectors.toList());
    }
}

DemoRepostity：

@Transactional(transactionManager = DatabaseConfig.DEFAULT_T_M, rollbackFor = { Exception.class })  //注入事务管理器，不然只能查找，不能增删改
public interface DemoRepo extends JpaRepository<DemoEntity,Long> {

    @Query(nativeQuery = true,value = "select * from tb_xuyu")
    List<DemoDTO> getDemo();

}

MongoDemo：

@Repository
public class OeeYieldMongo {

    private final MongoTemplate mongoTemplate1;
    private final MongoTemplate mongoTemplate2;

    public OeeYieldMongo(
            MongoTemplate mongoTemplate1,
            @Qualifier("mongoTemplate2") MongoTemplate mongoTemplate2
    ) {
        this.mongoTemplate1 = mongoTemplate1;
        this.mongoTemplate2 = mongoTemplate2;
    }

    //查询1
    public Object getSpiFail(String series) {
        MongoTemplate mongoTemplate = mongoTemplate1;
        if (databaseSelect.equals(series)) {
            mongoTemplate = mongoTemplate2;
        }
        Object Resuslt = mongoTemplate.aggregate(param1, "param2", Object.class);
    }

    //条件查询2
	long getmongo(String startTime, String endTime, String line) {
		Criteria c = Criteria.where("Time").gte(startTime.replace("-", "")).lt(endTime.replace("-", ""))
				.and("LineName").is(line)
				.and("CheckResult").is("fail");
		Query q = Query.query(c);
		long count = mongoTemplate.count(q, "AutoSPIResult");
		return count;
	}

    //sql语句查询
	Object getmongo(String collection, String type, String startTime, String endTime) {
		String sql[] = new String[4];
		sql[0] = String.format("{" + 
				"                \"$match\": {" + 
				"                    \"FileCreationTime\": {" + 
				"                        \"$gte\": '%s'," + 
				"                        \"$lt\": '%s'" + 
				"                    }," + 
				"                    \"Line\": {" + 
				"                        \"$in\": [\"C104F01BS\", \"C104F01TS\", \"C10402BS\", \"C10402TS\", \"test\"]" + 
				"                    }" + 
				"                }" + 
				"            }", startTime, endTime);
		sql[1] = String.format("{" + 
				"                \"$project\": {" + 
				"                    \"line\": \"$Line\"," + 
				"                    \"machine\": '%s'," + 
				"                    \"_id\": 0," + 
				"                }" + 
				"            }", "SPI".equals(type) ? "$Machine" : "$MachineId");
		sql[2] = String.format("{" + 
				"                \"$group\":{\"_id\":{\"line\":\"$line\",\"machine\":\"$machine\"}, \"count\":{\"$sum\":1}}" + 
				"            }");
		sql[3] = String.format("{" + 
				"                \"$project\": {" + 
				"                    \"_id\": 0," + 
				"                    \"line\": \"$_id.line\"," + 
				"                    \"machine\": \"$_id.machine\"," + 
				"                    \"number\": \"$count\"," + 
				"                    \"type\": '%s'" + 
				"                }" + 
				"            }", type);
		List<Bson> l = new ArrayList<Bson>();
		l.add(BsonDocument.parse(sql[0]));
		l.add(BsonDocument.parse(sql[1]));
		l.add(BsonDocument.parse(sql[2]));
		l.add(BsonDocument.parse(sql[3]));
		AggregateIterable<Document> iter = mongoTemplate.getCollection(collection).aggregate(l);
    }
}

启动类：

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class xuyuApplication {

    public static void main(String[] args) {
        System.out.println("Hello World!");
        SpringApplication.run(xuyuApplication .class, args);
    }

}

xy294636185
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot+jpa+aop自定义注解多数据源配置
焚琴煮鹤呀的博客
03-16 2462
springboot+jpa+aop自定义注解多数据源配置
springboot+JPA 多数据源配置
08-29
springboot+JPA 多数据源配置springboot+JPA 多数据源配置
Spring Boot 实践折腾记（19）：自定义配置JPA使用多数据源
热门推荐
mickjoust的技术小屋
05-17 1万+
圣爱克苏佩里在《小王子》里写道：用心去看才看得清楚，本质的东西用肉眼是看不见的。 今天的内容有点多，希望你能耐心看完，因为会复习 Spring Boot 和 Sping 的相关内容。 Java持久性API（JPA）是一个对象关系映射（ORM）框架，它是Java EE平台的一部分。 JPA通过让开发人员使用面向对象的API，而不是手动编写SQL查询来简化数据访问层的实现。目前，流行的...
springdata-jpa多数据源配置
最新发布
weixin_43278573的博客
10-16 926
jpa配置多数据源就是配置多个repository，每个 repository对应操作不同的数据源。
springboot的mongodb 事务管理的实现
weixin_44518082的博客
02-26 611
Mongo db的事务管理 网上的方式都报错 提示不能自动装配MongoDbFactory 这个接口 通过看官网学习，被我实现了 version：springboot 2.3.7 springboot mongodb 2.3.7 1 import com.mongodb.client.MongoClient; import com.mongodb.client.MongoClients; import org.springframework.context.annotation.Bean; import o
Spring Data for Mongo 介绍
caomiao2006的专栏
06-14 2105
本文将快速介绍 Spring Data for Mongo 的使用。 Spring Data for MongoDB是Spring Data的一个子模块。 目标是为MongoDB提供一个相近的一致的基于Spring的编程模型。 Spring Data for MongoDB核心功能是映射POJO到Mongo的DBCollection中的文档，并且提供Repository 风格数据访问层
【Java注解系列】内置注解与AOP实现自定义注解
qq_35789269的博客
03-27 4213
1、深入理解Java注解类型(@Annotation)_zejian_的博客-CSDN博客_java注解 2、java之aop使用及自定义注解 - 沦陷 - 博客园 3、SpringAOP中的JointPoint和ProceedingJoinPoint使用详解（附带详细示例）_如何在5年薪百万的博客-CSDN博客_proceedingjoinpoint有什么用 ...
springboot集成canal 实现mysql增量同步mongodb
qq_41369135的博客
03-03 1975
1. 1.6版本有bug（如果只是部署deployer，那没问题，如果你想部署admin模块来监控，那就会报错：java.nio.ByteBuffer.clear()Ljava/nio/ByteBuffer），这是因为这版本对jdk1.8不支持。 报错：can't find destination:example
Spring Boot 之 整合MongoDB
探索er的博客
04-12 780
整合MongoDB
SpringBoot 整合 MongoDB 实现数据的增删改查功能
程序人生
06-04 1451
在 MongoDB 中有三个比较重要的名词：数据库、集合、文档数据库（Database）：和关系型数据库一样，每个数据库中有自己的用户权限，不同的项目组可以使用不同的数据库集合（Collection）： 集合指的是文档组（类似于 Mysql 中的表的概念），里面可以存储许多文档文档（Document）： 文档是 MongoDB 中最基本的数据单元，由键值对组成，类似于 JSON 格式，可以存储不同字段，字段的值可以包括其他文档、数组和文档数组。
SpringBoot整合MongoDB实现批量更新数据
Java程序媛，欢迎大家一起交流学习~
05-06 1323
本文介绍了SpringBoot如何整合MongoDB实现批量更新数据
Oracle 数据怎么实时同步到 MongoDB | 亲测干货分享建议收藏
java李阳勇的博客
09-02 3169
摘要： 很多 DBA 同学经常会遇到要从一个数据库实时同步到另一个数据库的问题，同构数据还相对容易，遇上异构数据、表多、数据量大等情况就难以同步。我自己亲测了一种方式，可以非常方便地完成 Oracle 数据实时同步到 MongoDB，跟大家分享一下，希望对你有帮助。 Oracle 数据实时同步到 MongoDB 等非关系型数据库，应该是很多同学的需求了，现在 NOSQL 数据库越来越普遍了。本次亲测的数据同步工具是 Tapdata Cloud，一个永久免费的好东西。 第一步：配置...
使用 SpringBoot+JPA多数据源，动态数据源以及分库分表的实现
君悅黎心
12-08 5353
SpringBoot+JPA多数据源，动态数据源以及分库分表的实现 前言：本来想使用sharding-jdbc来实现这个，但是又不想不太熟悉新的框架而存在太多的坑而导致出现无法预测的问题或者及时的解决问题。因此按照实际开发习惯，使用原来简单项目，不引入新的框架，对JPA进行封装来实现。 jpa官网链接：jpa官网链接 1、使用前须知： 采用的数据库连接池：Druid 分库（多数据源实现...
使用Spring AOP结合自定义Java注解实现动态数据源设置
liupeng_qwert的专栏
11-29 1484
1、定义Java注解 @Retention(RetentionPolicy.RUNTIME) // 注解将要写到类型（Class/Interface）还是其它元素（Method等）上，支持package、type、method、field等，一般只会配置一个@Target({ElementType.TYPE}) public @interface DataSource { String va
基于自定义注解和Aop动态数据源配置
QiuRiMangCao
05-03 826
基于自定义注解和Aop动态数据源配置         在实际项目中，经常会因为需要增强数据库并发能力而设计分库分表或者读写分离等策略，每在旧项目中引进新技术的时候都会带来一系列的问题，我们的目的就是去解决问题，带着思考方式去重构系统，从中找到乐趣，对应引进自定义...
自定义注解并进行动态解析
gengqiquan的博客
04-18 5334
尊重他人的劳动成果，转载请标明出处：http://blog.csdn.net/gengqiquan/article/details/70230597， 本文出自:【gengqiquan的博客】前两篇博客我们唠了Java支持基本的注解以及Android Support Annotations库提供的静态检查类型的注解 今天我们来唠唠怎么自定义动态注解，并且实现一个控件自动绑定功能(老版本butter
被缠上了，小王问我怎么在 Spring Boot 中使用 JDBC 连接 MySQL
沉默王二
06-01 4710
上次帮小王入了 Spring Boot 的门后，他觉得我这个人和蔼可亲、平易近人，于是隔天小王又微信我说：“二哥，快教教我，怎么在 Spring Boot 项目中使用 JDBC 连接 MySQL 啊？” 收到问题的时候，我有点头大，难道以后就要被小王缠上了？ 没等我发牢骚，小王就紧接着说：“二哥，你先别生气，上次你帮了我的忙后，我在心里感激了你一晚上，想着第一次遇到这么亲切的大佬，一定要抱紧大腿。。。。。” 马屁拍到这份上，我的气自然也就消了。随后，我花了五分钟的时间帮他解决了苦恼，没成想，他又发给我了
spring boot 如何配置多个数据源，mysql和oracle
orton777的博客
06-09 1414
数据源
Springboot MongoDB 事务
深圳市多克创新科技有限公司
08-01 2096
Springboot MongoDB 事务
基于springboot+jpa 实现多租户在同一数据源种，动态添加where条件区分租户数据
04-24
您好，针对您的问题，可以通过使用拦截器或者过滤器，在每个请求处理前动态添加 where 条件来实现多租户在同一数据源中的区分。具体实现的核心是通过获取当前请求的租户信息，然后动态拼接 where 条件，根据不同租户...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值