我有一个非常重的Java Web应用程序，每秒服务于数千个请求，并使用主PostgreSQL数据库，该数据库使用流式（异步）复制将自身复制到一个辅助（只读）数据库中。
因此，我使用URL将请求从主数据库分离到辅助（只读）数据库，以避免考虑复制时间时对主数据库进行只读调用。
注意：我使用一个由Spring提供的RoutingDataSource的sessionFactory，在基于键查找要使用的数据库。我对多租户感兴趣，因为我使用支持它的Hibernate 4.3.4。
我的两个问题是:
我知道我可能无法在这里得到完美的答案，因为这确实很广泛，但我只是想听听您的意见。
我的团队中有：
请给与关注，提前致谢。
首先，我们将创建一个DataSourceType Java枚举，用于定义我们的事务路由选项：
public enum DataSourceType {
READ_WRITE,
READ_ONLY
}
ReadWriteDataSource和一个连接到副本节点的ReadOnlyDataSource。AbstractRoutingDataSource抽象实现的，该抽象由TransactionRoutingDatasource实现，如下图所示：
TransactionRoutingDataSource 很容易实现，如下所示：
public class TransactionRoutingDataSource
extends AbstractRoutingDataSource {
@Nullable
@Override
protected Object determineCurrentLookupKey() {
return TransactionSynchronizationManager
.isCurrentTransactionReadOnly() ?
DataSourceType.READ_ONLY :
DataSourceType.READ_WRITE;
}
}
@Configuration
@ComponentScan(
basePackages = "com.vladmihalcea.book.hpjp.util.spring.routing"
)
@PropertySource(
"/META-INF/jdbc-postgresql-replication.properties"
)
public class TransactionRoutingConfiguration
extends AbstractJPAConfiguration {
@Value("${jdbc.url.primary}")
private String primaryUrl;
@Value("${jdbc.url.replica}")
private String replicaUrl;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource readWriteDataSource() {
PGSimpleDataSource dataSource = new PGSimpleDataSource();
dataSource.setURL(primaryUrl);
dataSource.setUser(username);
dataSource.setPassword(password);
return connectionPoolDataSource(dataSource);
}
@Bean
public DataSource readOnlyDataSource() {
PGSimpleDataSource dataSource = new PGSimpleDataSource();
dataSource.setURL(replicaUrl);
dataSource.setUser(username);
dataSource.setPassword(password);
return connectionPoolDataSource(dataSource);
}
@Bean
public TransactionRoutingDataSource actualDataSource() {
TransactionRoutingDataSource routingDataSource =
new TransactionRoutingDataSource();
Map<Object, Object> dataSourceMap = new HashMap<>();
dataSourceMap.put(
DataSourceType.READ_WRITE,
readWriteDataSource()
);
dataSourceMap.put(
DataSourceType.READ_ONLY,
readOnlyDataSource()
);
routingDataSource.setTargetDataSources(dataSourceMap);
return routingDataSource;
}
@Override
protected Properties additionalProperties() {
Properties properties = super.additionalProperties();
properties.setProperty(
"hibernate.connection.provider_disables_autocommit",
Boolean.TRUE.toString()
);
return properties;
}
@Override
protected String[] packagesToScan() {
return new String[]{
"com.vladmihalcea.book.hpjp.hibernate.transaction.forum"
};
}
@Override
protected String databaseType() {
return Database.POSTGRESQL.name().toLowerCase();
}
protected HikariConfig hikariConfig(
DataSource dataSource) {
HikariConfig hikariConfig = new HikariConfig();
int cpuCores = Runtime.getRuntime().availableProcessors();
hikariConfig.setMaximumPoolSize(cpuCores * 4);
hikariConfig.setDataSource(dataSource);
hikariConfig.setAutoCommit(false);
return hikariConfig;
}
protected HikariDataSource connectionPoolDataSource(
DataSource dataSource) {
return new HikariDataSource(hikariConfig(dataSource));
}
}
/META-INF/jdbc-postgresql-replication.properties" 资源文件提供了读写和只读 JDBC DataSource 组件的配置信息。"hibernate.dialect=org.hibernate.dialect.PostgreSQL10Dialect
jdbc.url.primary=jdbc:postgresql://localhost:5432/high_performance_java_persistence
jdbc.url.replica=jdbc:postgresql://localhost:5432/high_performance_java_persistence_replica
jdbc.username=postgres
jdbc.password=admin
jdbc.url.primary属性定义了主节点的URL，而jdbc.url.replica定义了副本节点的URL。
readWriteDataSource Spring组件定义了读写JDBC DataSource，而readOnlyDataSource组件则定义了只读JDBC DataSource。
请注意，读写和只读数据源都使用HikariCP进行连接池。
actualDataSource作为读写和只读数据源的门面，并使用TransactionRoutingDataSource实用程序实现。
readWriteDataSource使用DataSourceType.READ_WRITE键进行注册，而readOnlyDataSource使用DataSourceType.READ_ONLY键进行注册。
因此，在执行读写@Transactional方法时，将使用readWriteDataSource，而在执行@Transactional(readOnly = true)方法时，将使用readOnlyDataSource。
additionalProperties 方法定义了 hibernate.connection.provider_disables_autocommit Hibernate 属性，我将其添加到 Hibernate 中，以推迟为 RESOURCE_LOCAL JPA 事务获取数据库。hibernate.connection.provider_disables_autocommit 允许您更好地利用数据库连接，而且这是我们使此示例工作的唯一方法，因为如果没有此配置，连接将在调用 determineCurrentLookupKey 方法 TransactionRoutingDataSource 之前获取。EntityManagerFactory 所需的其余 Spring 组件由 AbstractJPAConfiguration 基类定义。actualDataSource 被 DataSource-Proxy 进一步包装，并提供给 JPA 的 EntityManagerFactory。您可以查看 GitHub 上的源代码 以了解更多细节。
为了检查事务路由是否正常工作，我们将通过在 postgresql.conf 配置文件中设置以下属性来启用 PostgreSQL 查询日志：
log_min_duration_statement = 0
log_line_prefix = '[%d] '
Post post = forumService.newPost(
"High-Performance Java Persistence",
"JDBC", "JPA", "Hibernate"
);
List<Post> posts = forumService.findAllPostsByTitle(
"High-Performance Java Persistence"
);
[high_performance_java_persistence] LOG: execute <unnamed>:
BEGIN
[high_performance_java_persistence] DETAIL:
parameters: $1 = 'JDBC', $2 = 'JPA', $3 = 'Hibernate'
[high_performance_java_persistence] LOG: execute <unnamed>:
select tag0_.id as id1_4_, tag0_.name as name2_4_
from tag tag0_ where tag0_.name in ($1 , $2 , $3)
[high_performance_java_persistence] LOG: execute <unnamed>:
select nextval ('hibernate_sequence')
[high_performance_java_persistence] DETAIL:
parameters: $1 = 'High-Performance Java Persistence', $2 = '4'
[high_performance_java_persistence] LOG: execute <unnamed>:
insert into post (title, id) values ($1, $2)
[high_performance_java_persistence] DETAIL:
parameters: $1 = '4', $2 = '1'
[high_performance_java_persistence] LOG: execute <unnamed>:
insert into post_tag (post_id, tag_id) values ($1, $2)
[high_performance_java_persistence] DETAIL:
parameters: $1 = '4', $2 = '2'
[high_performance_java_persistence] LOG: execute <unnamed>:
insert into post_tag (post_id, tag_id) values ($1, $2)
[high_performance_java_persistence] DETAIL:
parameters: $1 = '4', $2 = '3'
[high_performance_java_persistence] LOG: execute <unnamed>:
insert into post_tag (post_id, tag_id) values ($1, $2)
[high_performance_java_persistence] LOG: execute S_3:
COMMIT
[high_performance_java_persistence_replica] LOG: execute <unnamed>:
BEGIN
[high_performance_java_persistence_replica] DETAIL:
parameters: $1 = 'High-Performance Java Persistence'
[high_performance_java_persistence_replica] LOG: execute <unnamed>:
select post0_.id as id1_0_, post0_.title as title2_0_
from post post0_ where post0_.title=$1
[high_performance_java_persistence_replica] LOG: execute S_1:
COMMIT
使用 high_performance_java_persistence 前缀的日志语句在主节点上执行，而使用 high_performance_java_persistence_replica 的则在副本节点上执行。
这不仅是理论。所有内容都在 GitHub 上，并且可以完美运行。可以使用 this test case 作为参考。
因此，您可以将其用作事务路由解决方案的起点，因为您拥有一个完全功能的示例。
一旦您使用复制功能，就会在分布式环境中运行，因此您需要使用分布式缓存解决方案，例如 Infinispan。
由于我们使用复制来将流量分发到更多的数据库节点，所以很明显我们还有多个应用程序节点需要连接到这些数据库节点。
因此，在这种环境中使用READ_WRITE CacheConcurrencyStrategy是一个可怕的反模式，因为每个分布式节点将保留其自己的缓存条目副本，即使您没有使用事务路由，也会导致一致性问题。NONSTRICT_READ_WRITE缓存并发策略，并使用可以将缓存数据存储在分布式节点系统中的二级缓存提供程序，即使您创建新的应用程序节点，缓存数据也是随时可用的。<property name="hibernate.order_updates" value="true"/>
<property name="hibernate.order_inserts" value="true"/>
<property name="hibernate.jdbc.batch_size" value="25"/>
DataSource，该数据源使用连接到主节点的不同连接池。”如果我理解正确，你的Web应用程序90%的HTTP请求涉及至少一次写操作并且需要在主数据库上操作。您可以将只读事务直接重定向到副本数据库，但这种改进只会影响全局数据库操作的10％，甚至那些只读操作也会击中数据库。
常见的架构是使用好的数据库缓存（Infinispan或Ehcache）。如果你能提供足够大的缓存，你可以希望很大一部分的数据库只读操作命中缓存并变成仅内存操作，无论是作为只读事务的一部分还是不是。缓存调优是一个微妙的操作，但我认为这是实现高性能收益所必需的。即使配置有点困难，这些缓存甚至允许分布式前端，如果您想使用Ehcache，则可能必须寻找Terracotta集群。
目前，数据库复制主要用于保护数据，并且仅在Information Systems的高部分仅读取数据时用作并发改进机制 - 这不是你所描述的情况。
我认为这个问题很普遍，不确定为什么首选答案引导它进入Spring内部？无论如何，您可能希望查看Apache ShardingSphere，该功能具备以下特点：
Read/write Splitting
---------------------
Read/write splitting can be used to cope with business access with high stress. ShardingSphere provides flexible read/write splitting capabilities and can achieve read access load balancing based on the understanding of SQL semantics and the ability to perceive the underlying database topology.
select myfunct(1) from dual。您还可以在数据库节点（可以是Galera集群设置）前运行proxySQL，并设置查询读写分离规则，代理将根据定义的规则分发流量。例如：SELECT查询路由到读取节点，而UPDATE查询或读写事务则转到写入节点。