application.yml 配置
com.seliote.twowaysync:
datasource:
zg:
url: jdbc:mysql://192.168.0.1:3306/jd4?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8&autoReconnect=true
username: root
password: 6125@hdynhjs
driver: com.mysql.cj.jdbc.Driver
hikari:
maximum-pool-size: 200
connection-timeout: 5000
max-lifetime: 1800000
minimum-idle: 5
idle-timeout: 300000
connection-test-query: SELECT 1
dialect: org.hibernate.dialect.MySQLInnoDBDialect
jd:
url: jdbc:mysql://192.168.0.1:3306/jd3?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8&autoReconnect=true
username: root
password: 6125@hdynhjs
driver: com.mysql.cj.jdbc.Driver
hikari:
maximum-pool-size: 200
connection-timeout: 5000
max-lifetime: 1800000
minimum-idle: 5
idle-timeout: 300000
connection-test-query: SELECT 1
dialect: org.hibernate.dialect.MySQLInnoDBDialect
tws:
url: jdbc:mysql://192.168.0.1:3306/tws?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8&autoReconnect=true
username: root
password: 6125@hdynhjs
driver: com.mysql.cj.jdbc.Driver
hikari:
maximum-pool-size: 200
connection-timeout: 5000
max-lifetime: 1800000
minimum-idle: 5
idle-timeout: 300000
connection-test-query: SELECT 1
dialect: org.hibernate.dialect.MySQLInnoDBDialect
对应的配置注入类:
package com.seliote.twowaysync.config;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* Yaml 配置
*
* @author Li Yangdi
* @since 2022-04-16
*/
@Slf4j
@Getter
@Setter
@Component
@ConfigurationProperties(prefix = "com.seliote.twowaysync")
public class YmlConfig {
private DatasourceConfig datasource = new DatasourceConfig();
private ThreadPoolConfig threadPool = new ThreadPoolConfig();
@Getter
@Setter
public static class DatasourceConfig {
private DatasourceItemConfig zg = new DatasourceItemConfig();
private DatasourceItemConfig jd = new DatasourceItemConfig();
private DatasourceItemConfig tws = new DatasourceItemConfig();
@Getter
@Setter
public static class DatasourceItemConfig {
private String url;
private String username;
private String password;
private String driver;
private HikariConfig hikari;
}
@Getter
@Setter
public static class HikariConfig {
private Integer maximumPoolSize;
private Long connectionTimeout;
private Long maxLifetime;
private Integer minimumIdle;
private Long idleTimeout;
private String connectionTestQuery;
private String dialect;
}
}
@Getter
@Setter
public static class ThreadPoolConfig {
private Integer poolSize;
}
}
数据源相关工具类
package com.seliote.twowaysync.util;
import com.seliote.twowaysync.config.YmlConfig;
import com.zaxxer.hikari.HikariDataSource;
import lombok.extern.slf4j.Slf4j;
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 javax.persistence.EntityManagerFactory;
import javax.persistence.SharedCacheMode;
import javax.persistence.ValidationMode;
import javax.sql.DataSource;
import java.util.HashMap;
/**
* 数据源工具
*
* @author Li Yangdi
* @since 2022-04-16
*/
@Slf4j
public class DatasourceUtils {
/**
* 创建 HikariDataSource
*
* @param dataName 数据名
* @param config 配置
* @return HikariDataSource 对象
*/
public static HikariDataSource getDataSource(String dataName,
YmlConfig.DatasourceConfig.DatasourceItemConfig config) {
var hikariConfig = new com.zaxxer.hikari.HikariConfig();
hikariConfig.setPoolName("[" + dataName.toUpperCase() + "-HIKARI-POOL]");
hikariConfig.setJdbcUrl(config.getUrl());
hikariConfig.setUsername(config.getUsername());
hikariConfig.setPassword(config.getPassword());
hikariConfig.setDriverClassName(config.getDriver());
hikariConfig.setMaximumPoolSize(config.getHikari().getMaximumPoolSize());
hikariConfig.setConnectionTimeout(config.getHikari().getConnectionTimeout());
hikariConfig.setMaxLifetime(config.getHikari().getMaxLifetime());
hikariConfig.setMinimumIdle(config.getHikari().getMinimumIdle());
hikariConfig.setIdleTimeout(config.getHikari().getIdleTimeout());
hikariConfig.setConnectionTestQuery(config.getHikari().getConnectionTestQuery());
var hikariDatasource = new HikariDataSource(hikariConfig);
log.debug("Create {} datasource", dataName);
return hikariDatasource;
}
/**
* 创建 EntityManagerFactory
*
* @param dataSource 数据源 Datasource
* @param dialect Hibernate 方言
* @param scanPackages 扫描的包
* @return LocalContainerEntityManagerFactoryBean 对象
*/
public static LocalContainerEntityManagerFactoryBean getEntityManagerFactory(DataSource dataSource,
String dialect,
String... scanPackages) {
var props = new HashMap<String, Object>();
props.put("javax.persistence.schema-generation.database.action", "none");
var jpaVendorAdapter = new HibernateJpaVendorAdapter();
jpaVendorAdapter.setDatabasePlatform(dialect);
var entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
entityManagerFactory.setJpaVendorAdapter(jpaVendorAdapter);
entityManagerFactory.setDataSource(dataSource);
entityManagerFactory.setPackagesToScan(scanPackages);
entityManagerFactory.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
entityManagerFactory.setValidationMode(ValidationMode.NONE);
entityManagerFactory.setJpaPropertyMap(props);
log.debug("Create EntityManagerFactory for '{}' by dialect {}",
String.join(", ", scanPackages), dialect);
return entityManagerFactory;
}
/**
* 创建 PlatformTransactionManager
*
* @param entityManagerFactory EntityManagerFactory 对象
* @return PlatformTransactionManager 对象
*/
public static PlatformTransactionManager getTransactionManager(EntityManagerFactory entityManagerFactory) {
log.debug("Create TransactionManager");
return new JpaTransactionManager(entityManagerFactory);
}
}
数据源 1
package com.seliote.twowaysync.config;
import com.seliote.twowaysync.util.DatasourceUtils;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AdviceMode;
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.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* 机电数据源
*
* @author Li Yangdi
* @since 2022-04-16
*/
@Configuration
@EnableTransactionManagement(mode = AdviceMode.PROXY)
@EnableJpaRepositories(
basePackages = {"com.seliote.twowaysync.repo.jd"},
entityManagerFactoryRef = "jdEntityManagerFactory",
transactionManagerRef = "jdTransactionManager"
)
public class JdDataSourceConfig {
private YmlConfig.DatasourceConfig.DatasourceItemConfig jdDatasourceConfig;
@Autowired
public void setDatasourceItemConfig(YmlConfig ymlConfig) {
this.jdDatasourceConfig = ymlConfig.getDatasource().getJd();
}
/**
* 综管 Datasource Bean
*
* @return HikariDataSource 对象
*/
@Primary
@Bean(name = "jdDataSource")
public HikariDataSource jdDataSource() {
return DatasourceUtils.getDataSource("jd", jdDatasourceConfig);
}
/**
* 综管 EntityManagerFactory Bean
*
* @return LocalContainerEntityManagerFactoryBean 对象
*/
@Primary
@Bean(name = "jdEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean jdEntityManagerFactory() {
return DatasourceUtils.getEntityManagerFactory(jdDataSource(),
jdDatasourceConfig.getHikari().getDialect(),
"com.seliote.twowaysync.entity.jd");
}
/**
* 综管 PlatformTransactionManager Bean
*
* @return PlatformTransactionManager 对象
*/
@Primary
@Bean("jdTransactionManager")
public PlatformTransactionManager jdTransactionManager() {
return DatasourceUtils.getTransactionManager(jdEntityManagerFactory().getObject());
}
}
数据源 2
package com.seliote.twowaysync.config;
import com.seliote.twowaysync.util.DatasourceUtils;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AdviceMode;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* 综管数据源
*
* @author Li Yangdi
* @since 2022-04-16
*/
@Configuration
@EnableTransactionManagement(mode = AdviceMode.PROXY)
@EnableJpaRepositories(
basePackages = {"com.seliote.twowaysync.repo.zg"},
entityManagerFactoryRef = "zgEntityManagerFactory",
transactionManagerRef = "zgTransactionManager"
)
public class ZgDataSourceConfig {
private YmlConfig.DatasourceConfig.DatasourceItemConfig zgDatasourceConfig;
@Autowired
public void setDatasourceItemConfig(YmlConfig ymlConfig) {
this.zgDatasourceConfig = ymlConfig.getDatasource().getZg();
}
/**
* 综管 Datasource Bean
*
* @return HikariDataSource 对象
*/
@Bean(name = "zgDataSource")
public HikariDataSource zgDataSource() {
return DatasourceUtils.getDataSource("zg", zgDatasourceConfig);
}
/**
* 综管 EntityManagerFactory Bean
*
* @return LocalContainerEntityManagerFactoryBean 对象
*/
@Bean(name = "zgEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean zgEntityManagerFactory() {
return DatasourceUtils.getEntityManagerFactory(zgDataSource(),
zgDatasourceConfig.getHikari().getDialect(),
"com.seliote.twowaysync.entity.zg");
}
/**
* 综管 PlatformTransactionManager Bean
*
* @return PlatformTransactionManager 对象
*/
@Bean("zgTransactionManager")
public PlatformTransactionManager zgTransactionManager() {
return DatasourceUtils.getTransactionManager(zgEntityManagerFactory().getObject());
}
}
数据源 3:
package com.seliote.twowaysync.config;
import com.seliote.twowaysync.util.DatasourceUtils;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AdviceMode;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* 双向同步数据源
*
* @author Li Yangdi
* @since 2022-04-18
*/
@Configuration
@EnableTransactionManagement(mode = AdviceMode.PROXY)
@EnableJpaRepositories(
basePackages = {"com.seliote.twowaysync.repo.tws"},
entityManagerFactoryRef = "twsEntityManagerFactory",
transactionManagerRef = "twsTransactionManager"
)
public class TwsDataSourceConfig {
private YmlConfig.DatasourceConfig.DatasourceItemConfig twsDatasourceConfig;
@Autowired
public void setDatasourceItemConfig(YmlConfig ymlConfig) {
this.twsDatasourceConfig = ymlConfig.getDatasource().getTws();
}
/**
* 综管 Datasource Bean
*
* @return HikariDataSource 对象
*/
@Bean(name = "twsDataSource")
public HikariDataSource twsDataSource() {
return DatasourceUtils.getDataSource("tws", twsDatasourceConfig);
}
/**
* 综管 EntityManagerFactory Bean
*
* @return LocalContainerEntityManagerFactoryBean 对象
*/
@Bean(name = "twsEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean twsEntityManagerFactory() {
return DatasourceUtils.getEntityManagerFactory(twsDataSource(),
twsDatasourceConfig.getHikari().getDialect(),
"com.seliote.twowaysync.entity.tws");
}
/**
* 综管 PlatformTransactionManager Bean
*
* @return PlatformTransactionManager 对象
*/
@Bean("twsTransactionManager")
public PlatformTransactionManager twsTransactionManager() {
return DatasourceUtils.getTransactionManager(twsEntityManagerFactory().getObject());
}
}
不同包下的不同实体不同仓库,自动使用不同数据源