Spring Data JPA --多数据源配置

MYSQL

yml文件配置信息

spring:
  datasource:
     test:
       continueOnError: true
       jdbcUrl: jdbc:mysql://XXX.XXX.XX.XX:XXX/test?useSSL=false&useUnicode=true&characterEncoding=utf-8
       username: username
       password: password
       driver-class-name: com.mysql.cj.jdbc.Driver
     test2:
       continueOnError: true
       jdbcUrl: jdbc:mysql://XXX.XXX.XX.XX:XXX/test2?useSSL=false&useUnicode=true&characterEncoding=utf-8
       username: username
       password: password
       driver-class-name: com.mysql.cj.jdbc.Driver

实体定义

package project.mysql.model.test;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

/**
* 定义test库中test_table 表实体TestEntityModel
*/
@Entity
@Table(name = "test_table ")
@Getter
@Setter
public class TestEntityModel{
    @Id
    Integer id;
    @Column
    String param1;
    @Column
    String param2;
    @Column
    Date param3;
}

接口定义

package project.mysql.repository.test;

import project.mysql.model.testdata.testEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
import java.util.Set;

public interface ITestEntityMysqlRepository extends JpaRepository<TestEntityModel, Integer> {

    @Query(value = "select * from test_table where param1 in ?1", nativeQuery = true)
    List<ArticleDetailModel> getItemContentByArticleId(Set<String> param1Set);
}

数据源配置

package project.mysql.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy;
import org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy;
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.orm.jpa.vendor.HibernateJpaVendorAdapter;
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;


@Configuration
@EnableTransactionManagement
@EntityScan(basePackages = { "project.mysql.model.test" })
@EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactoryTest", 
        transactionManagerRef = "transactionManagerTest", 
        basePackages = {"project.mysql.repository.test"})
public class TestDataBaseConfig {

    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.test")
    public DataSource testDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean
    public EntityManager entityManagerTest() {
        return entityManagerFactoryPrimary().getObject().createEntityManager();
    }

    @Primary
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryTest() {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(false);

        LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
        factoryBean.setDataSource(testDataSource());
        factoryBean.setJpaVendorAdapter(vendorAdapter);
        factoryBean.setPackagesToScan("project.mysql.repository.test",
                "project.mysql.model.test");

        Map<String, Object> props = new HashMap<>();
        props.put("hibernate.physical_naming_strategy", SpringPhysicalNamingStrategy.class.getName());
        props.put("hibernate.implicit_naming_strategy", SpringImplicitNamingStrategy.class.getName());
        factoryBean.setJpaPropertyMap(props);
        return factoryBean;
    }

    @Primary
    @Bean(name = "transactionManagerTest")
    public PlatformTransactionManager transactionManagerTest() {
        return new JpaTransactionManager(entityManagerFactoryPrimary().getObject());
    }

}

MongoDB

yml文件配置信息

spring:
  data:
    mongodb:
      test:
        uri: mongodb://username:password@XXX.XX.X.XX:xxxx/test
        dbName: test
      test1:
        uri: mongodb://username:password@XXX.XX.X.XX:xxxx/test1
        dbName: test1

实体定义

package project.mongo.model.test;

import lombok.Data;
import java.util.*;

@Data
public class TestModel {
    // _id mongo主键
    String _id;
    String param1;
    long param2;
    int param3;
    List<Integer> param4;
}

操作类定义

package project.mongo.repository.test.impl;

import project.mongo.model.test.TestModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class TestModelRepositoryImpl {

    @Autowired
    @Qualifier("testMongoOperations")
    protected MongoOperations testMongoOperations;
    
    final static String TEST_TABLE = "test_table";
    
    public void save(List<TestModel> testModels) {
        testMongoOperations.save(testModels, TEST_TABLE);
        log.info("update: dataSize - {}, tableName - {}", testModels.size(), TEST_TABLE);
    }

    public void modify(Map<String, Object> updateInfo, List<String> idList) {
        Query query = Query.query(Criteria.where("_id").in(idList));
        Update update = new Update();
        updateInfo.forEach(update::set);
        testMongoOperations.updateMulti(query, update, Map.class, TEST_TABLE);
    }
}

数据源配置

package project.mongo.config;

import org.springframework.boot.autoconfigure.mongo.MongoProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoClientDbFactory;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
import java.util.Collections;

@Configuration
public class TestMongoConfig {

    /**
    * 导入配置信息
    */
    @Bean
    @ConfigurationProperties(prefix = "spring.data.mongodb.test")
    public MongoProperties testMongoProperties() {
        return new MongoProperties();
    }

    @Bean
    public MongoDbFactory testMongoFactory() throws Exception {
        return new SimpleMongoClientDbFactory(testMongoProperties().getUri());
    }

    /**
     * 转换器
     **/
    @Bean
    public MappingMongoConverter mappingMongoConverter() throws Exception {
        DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(testMongoFactory(testMongoProperties()));
        MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, new MongoMappingContext());
        converter.setCustomConversions(new MongoCustomConversions(Collections.emptyList()));
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return converter;
    }

    /**
     * MongoTemplate 配置 依赖注入到ioc里面，指定mongoTemplateRef
     */
    @EnableMongoRepositories(
            basePackages = {"project.mongo.repository.test" }, 
            mongoTemplateRef = "testMongoTemplate")
    public class TestMongoTemplate {

        @Bean("testMongoTemplate")
        public MongoTemplate mongoTemplate() throws Exception {
            return new MongoTemplate(testMongoFactory(testMongoProperties()), mappingMongoConverter());
        }

        @Bean("testMongoOperations")
        public MongoOperations mongoOperations() throws Exception {
            return new MongoTemplate(testMongoFactory(testMongoProperties()), mappingMongoConverter());
        }
    }
}