java - 如何使用 JPA 和 Hibernate 拆分只读和读写事务

Question

我有一个非常重的 java webapp，它可以处理数千个请求/秒，它使用一个主 Postgresql db，它使用流式(异步)复制将自身复制到一个辅助(只读)数据库。

因此，考虑到复制时间最短，我使用 URL 将请求从主要请求分离到次要(只读)以避免对错误主数据库的只读调用。

注意 :我使用一个 sessionFactory 和一个由 spring 提供的 RoutingDataSource，它根据一个键查找要使用的数据库。我对 Multi-Tenancy 感兴趣，因为我使用的是支持它的 hibernate 4.3.4。

我有两个问题:

我不认为基于 URL 的拆分是有效的
只移动 10% 的流量意味着没有多少只读
网址。我应该考虑什么方法？

可能是，不知何故，在 URL 的基础上，我达到了某种程度
两个节点之间的分布，但我会用我的 quartz 做什么
工作(甚至有单独的 JVM)？我应该采取什么务实的方法
拿？

我知道我可能不会在这里得到完美的答案，因为这确实很广泛，但我只是想了解您对上下文的看法。

我的团队中的伙计们:

Spring4

Hibernate4

Quartz2.2

Java7/Tomcat7

请感兴趣。提前致谢。

Answer 1

Spring事务路由
首先，我们将创建一个 DataSourceType定义我们的事务路由选项的 Java 枚举:

public enum  DataSourceType {
    READ_WRITE,
    READ_ONLY
}

要将读写事务路由到主节点并将只读事务路由到副本节点，我们可以定义一个 ReadWriteDataSource连接到主节点和 ReadOnlyDataSource连接到副本节点。
读写和只读事务路由由 Spring AbstractRoutingDataSource 完成抽象，由 TransactionRoutingDatasource 实现，如下图所示:
TransactionRoutingDataSource很容易实现，如下所示:

public class TransactionRoutingDataSource 
        extends AbstractRoutingDataSource {

    @Nullable
    @Override
    protected Object determineCurrentLookupKey() {
        return TransactionSynchronizationManager
            .isCurrentTransactionReadOnly() ?
            DataSourceType.READ_ONLY :
            DataSourceType.READ_WRITE;
    }
}

基本上，我们检查 Spring TransactionSynchronizationManager存储当前事务上下文以检查当前运行的 Spring 事务是否为只读的类。 determineCurrentLookupKey方法返回将用于选择读写或只读 JDBC DataSource 的鉴别器值.
Spring读写只读的JDBC DataSource配置 DataSource配置如下:

@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 .

Note that both the read-write and read-only data sources use HikariCP for connection pooling.

actualDataSource充当读写和只读数据源的外观，并使用 TransactionRoutingDataSource 实现公用事业。 readWriteDataSource使用 DataSourceType.READ_WRITE 注册键和 readOnlyDataSource使用 DataSourceType.READ_ONLY key 。
所以，当执行读写时 @Transactional方法， readWriteDataSource将在执行 @Transactional(readOnly = true) 时使用方法， readOnlyDataSource将被使用。

Note that the additionalProperties method defines the hibernate.connection.provider_disables_autocommit Hibernate property, which I added to Hibernate to postpone the database acquisition for RESOURCE_LOCAL JPA transactions.

Not only that the hibernate.connection.provider_disables_autocommit allows you to make better use of database connections, but it's the only way we can make this example work since, without this configuration, the connection is acquired prior to calling the determineCurrentLookupKey method TransactionRoutingDataSource.

构建 JPA 所需的其余 Spring 组件 EntityManagerFactory由 AbstractJPAConfiguration 定义基类。
基本上， actualDataSource由 DataSource-Proxy 进一步包装并提供给 JPA EntityManagerFactory .您可以查看 source code on GitHub更多细节。
测试时间
为了检查事务路由是否有效，我们将通过在 postgresql.conf 中设置以下属性来启用 PostgreSQL 查询日志。配置文件:

log_min_duration_statement = 0
log_line_prefix = '[%d] '

log_min_duration_statement属性设置用于记录所有 PostgreSQL 语句，而第二个将数据库名称添加到 SQL 日志中。
因此，在拨打 newPost 时和 findAllPostsByTitle方法，像这样:

Post post = forumService.newPost(
    "High-Performance Java Persistence",
    "JDBC", "JPA", "Hibernate"
);

List<Post> posts = forumService.findAllPostsByTitle(
    "High-Performance Java Persistence"
);

我们可以看到 PostgreSQL 记录了以下消息:

[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 的那些在副本节点上。
所以，一切都像魅力一样!
所有源代码都可以在我的 High-Performance Java Persistence 中找到GitHub 存储库，因此您也可以尝试一下。
结论
您需要确保为连接池设置正确的大小，因为这会产生巨大的差异。为此，我建议使用 Flexy Pool .
您需要非常勤奋，并确保相应地标记所有只读事务。只有 10% 的交易是只读的，这是不寻常的。可能是您有这样一个最多写入的应用程序，或者您正在使用只发出查询语句的写入事务？
对于批处理，您肯定需要读写事务，因此请确保启用 JDBC 批处理，如下所示:

<property name="hibernate.order_updates" value="true"/>
<property name="hibernate.order_inserts" value="true"/>
<property name="hibernate.jdbc.batch_size" value="25"/>

对于批处理，您还可以使用单独的 DataSource使用不同的连接池连接到主节点。
只需确保所有连接池的总连接大小小于 PostgreSQL 配置的连接数。
每个批处理作业都必须使用专用事务，因此请确保使用合理的批处理大小。
更重要的是，您希望持有锁并尽快完成事务。如果批处理器正在使用并发处理 worker，请确保关联的连接池大小等于 worker 的数量，这样它们就不会等待其他人释放连接。