Question

我需要能够以每秒超过5,000次写入的速率写入我的数据库。目前，我无法管理超过该数字的10％。

我使用Spring将我的数据源（HSQL）和Hibernate配置为我的Jpa提供程序。

我的实体都是扁平的（没有复杂的对象树），我使用了Hibernate二级缓存（EhCache），其并发策略设置为ConcurrencyStrategy.READ-WRITE。

这是我的数据源bean的Spring-Context：

 <bean id="commandsTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
p:entityManagerFactory-ref="commandEmf"/>

<tx:annotation-driven transaction-manager="commandsTransactionManager" />

<!-- Commmands Data Source Configuration -->
<bean id="commandsDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc-commands.driverClassName}"/>
    <property name="url" value="${jdbc-commands.url}"/>
    <property name="username" value="${jdbc-commands.username}"/>
    <property name="password" value="${jdbc-commands.password}"/>
    <property name="initialSize" value="10"/>
    <property name="maxActive" value="100"/>
    <property name="maxWait" value="-1"/>
</bean>

 <bean name="lazyConnectionDataSourceProxy" class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy">
    <property name="targetDataSource" ref="commandsDataSource" />
</bean>

<!-- Commands Container Managed JPA Entity Manager Factory -->
<bean id="commandEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="commandsDataSource"/>
    <property name="persistenceUnitName" value="commands"/>
    <property name="jpaPropertyMap" ref="jpaPropertyMap"/>
    <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
                    p:showSql="false"  p:generateDdl="true" p:database="HSQL" p:databasePlatform="org.hibernate.dialect.HSQLDialect">
            </bean>
    </property>
</bean>

<util:map id="jpaPropertyMap" key-type="java.lang.String" value-type="java.lang.Object">
     <entry key="hibernate.hbm2ddl.auto" value="${jdbc-commands.ddlmode}" />
      <entry key="hibernate.cache.use_second_level_cache" value="true" />
      <entry key="hibernate.cache.region.factory_class" value="net.sf.ehcache.hibernate.SingletonEhCacheRegionFactory"/>
</util:map>

这是我的一个实体类的示例。 'AbstractAnnotatedAggregateRoot'是来自Axon Framework的抽象实体类，它提供了聚合和存储库实现框架。聚合本质上是必须实现自己的Jpa以实现持久性的实体。

@Entity
@Table(name = "users")
@Cache(region="usersCache", usage= CacheConcurrencyStrategy.READ_WRITE)
public class User extends AbstractAnnotatedAggregateRoot {

    private static final long serialVersionUID = -6536766172448063298L;

    private String username;

    private String password;

    private Integer subscription;

    private String firstName;

    private String lastName;

    private Calendar subscriptionDate;

    private Date lastAccessTime;

    public User(){}

    public User(StringAggregateIdentifier email){
        super(email);
        registerEvent(new UserCreatedEvent(email.asString()));
    }

    @Column(unique = true)
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
        registerEvent(new UserNameUpdatedEvent(this.username));
    }

    @Column(nullable = false)
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
        registerEvent(new UserPasswordUpdatedEvent(this.password));
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
        registerEvent(new UserFirstNameUpdatedEvent(this.firstName));
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
        registerEvent(new UserLastNameUpdatedEvent(this.lastName));
    }

    public String getEmail() {
        return getIdentifier().asString();
    }

    @Temporal(TemporalType.DATE)
    public Calendar getSubscriptionDate() {
        return subscriptionDate;
    }

    public void setSubscriptionDate(Calendar subscriptionDate) {
        this.subscriptionDate = subscriptionDate;
        registerEvent(new UserSubscriptionDateUpdatedEvent(this.subscriptionDate));
    }

    @Temporal(TemporalType.TIMESTAMP)
    public Date getLastAccessTime() {
        return lastAccessTime;
    }

    public void setLastAccessTime(Date lastAccessTime) {
        this.lastAccessTime = lastAccessTime;
        registerEvent(new UserLastAccessTimeUpdatedEvent(this.lastAccessTime));

    }

    public Integer getSubscription() {
        return subscription;
    }

    public void setSubscription(Integer subscription) {
        this.subscription = subscription;
        registerEvent(new UserSubscriptionUpdatedEvent(this.subscription));
    }

}

为完整起见，这是我的EhCache.xml文件中的缓存区配置：

  <cache name="usersCache" maxElementsInMemory="10000"
  maxElementsOnDisk="10000" eternal="false" overflowToDisk="false"
  diskSpoolBufferSizeMB="20" timeToIdleSeconds="300"
  timeToLiveSeconds="600" memoryStoreEvictionPolicy="LFU"
  statistics = "true">
  </cache>

在Axon框架中，我调度命令以尝试更改聚合的状态。这些命令位于由Spring的PlatformTransactionManager管理的Transaction的范围内。

Command Dispatch同步发生，我需要每秒处理5,000个命令。每个命令都将从缓存中获取聚合，更改其上的值，然后在调度下一个Command之前保留更改。问题在于获取/更新/插入行所花费的时间，考虑到HYSQL和H2之类的INSERT速率，我认为会快得多。

任何提高速度的想法我都会受到赞赏。

由于

Answer 1

我认为您可以使用数据库和JDBC以及单个插入语句完成限制。 Hibernate既不是缓存也不是问题。但是你的数据库可能无法通过JDBC处理更多的插入。

但是如果你设法使用bulk insert operations，你可以更快地获得更多。对于批量，我的意思是样式insert into your_table select ... from ...。您从表中读取数据，修改一下然后插入结果。可能有批量插入。

Answer 2

如果此实体是您的数据的典型（即没有长字符串的少数列），并且数据库操作是UPDATE，那么数据库性能应该与此处描述的相当，每秒执行5000次事务（多个使用基于磁盘的表进行更新，每次选择一次选择和一次插入。

http://hsqldb.org/web/hsqlPerformanceTests.html

数据库在一个表中有4000000条记录。对于较大的表，性能会下降，尤其是在数据库大小超过使用Java nio内存映射文件的预设限制时。

您还应该检查.script文件中的数据库模式，看看是否创建了不必要的索引，这可能会减慢速度。

使用Hibernate二级缓存和HSQL令人失望的插入/更新速率

2 个答案: