Question

我对Hibernate和PostgreSQL相当新，但到目前为止它还很顺利，尽管我现在遇到了一个无法解决的问题。我在第一次操作（即在数据库中插入或更新1000行的一个事务）填充数据库时收到错误。错误是：

SQL Error: 0, SQLState: 53300
FATAL: sorry, too many clients already
Exception in thread "main" org.hibernate.exception.GenericJDBCException: Cannot open connection

这是重要的代码：

@Repository
public class PDBFinderDAO extends GenericDAO<PDBEntry> implements IPDBFinderDAO {
    @Override
    @Transactional
    public void updatePDBEntry(Set<PDBEntry> pdbEntrySet) {
        for (PDBEntry pdbEntry : pdbEntrySet) {
            getCurrentSession().saveOrUpdate(pdbEntry);
        }
    }
}

getCurrentSession（）从GenericDAO扩展并调用sessionFactory.getCurrentSession（）。

这是我的Hibernate配置：

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
        <property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
        <property name="hibernate.connection.url">jdbc:postgresql://localhost/PDBeter</property>
        <property name="hibernate.connection.username">xxxx</property>
        <property name="hibernate.connection.password">xxxx</property>

        <!-- Create or update the database schema on startup -->
        <property name="hbm2ddl.auto">create</property>

        <!-- Use the C3P0 connection pool provider -->
        <property name="hibernate.c3p0.min_size">5</property>
        <property name="hibernate.c3p0.max_size">20</property>
        <property name="hibernate.c3p0.timeout">300</property>
        <property name="hibernate.c3p0.max_statements">50</property>
        <property name="hibernate.c3p0.idle_test_period">300</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Batch size -->
        <property name="hibernate.jdbc.batch_size">50</property>

        <!-- this makes sure the more efficient new id generators are being used,
        though these are not backwards compatible with some older databases -->
        <property name="hibernate.id.new_generator_mappings">true</property>

        <!-- Echo all executed SQL to stdout -->
        <!--
        <property name="hibernate.show_sql">true</property>
        -->
        <property name="format_sql">true</property>
        <property name="use_sql_comments">true</property>
    </session-factory>
</hibernate-configuration>

这是我的Spring配置：

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">


    <context:component-scan base-package="nl.ru.cmbi.pdbeter" />

    <!-- Transaction Manager -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <tx:annotation-driven />

    <!-- Session Factory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="configLocation" value="hibernate.cfg.xml" />
        <property name="packagesToScan" value="nl.ru.cmbi.pdbeter.core.model.domain" />
    </bean>

    <!-- Task Executor -->
    <task:annotation-driven />
</beans>

我不确定出了什么问题，这应该每次只打开一个连接，然后关闭它，这不是@Transactional应该做的吗？此外，是否有一种简单的方法可以检查在特定时间打开了多少个连接，以便我可以在错误之前和之后检查打开了多少个连接？

编辑：当我检查数据库时没有添加任何内容，因此它甚至无法建立一个连接，这里出了什么问题？

编辑：对不起，我已经解决了。这是一个非常愚蠢的错误，有一个非常小的查询使用了执行1000次的标准，但是一个在事务之前执行，导致它在1000个单独的事务/会话/连接中执行（我想，正确我，如果我错了！）

编辑：好的，事实证明根本没有解决它，因为我需要那个小查询来查看数据库中是否已存在某些内容，如果是，请从数据库中获取该对象以便我可以更新它的字段/ columns /无论你想叫什么。

这是GenericDAO中的方法：

@Override
public PDBEntry findByAccessionCode(String accessionCode) {
    return (PDBEntry) createCriteria(Restrictions.eq("accessionCode", accessionCode)).uniqueResult();
}

有一个函数可以构建不在DAO中的映射对象，因为它将原始数据文件转换为数据库对象，因此我希望将其保留在数据库操作之外，并且只将saveOrUpdate（）放在数据库模块。我现在遇到的问题是，在将原始数据文件转换为数据库对象期间，findByAccessionCode（）被调用了1000次，因为我需要检查数据库中是否已存在某个数据，如果是，，从数据库中获取对象，而不是创建一个新对象。

现在，如何在此上下文中的一个连接中执行该查询1000次？我尝试制作转换方法来转换1000个文件@transactional，但这不起作用。

以下是转换方法：

private void updatePDBSet(Set<RawPDBEntry> RawPDBEntrySet) {
    Set<PDBEntry> pdbEntrySet = new LinkedHashSet<PDBEntry>();

    for (RawPDBEntry pdb : RawPDBEntrySet) {
        PDBEntry pdbEntry = pdbEntryDAO.findByAccessionCode(pdb.id);
        if (pdbEntry == null) {
            pdbEntry = new PDBEntry(pdb.id, pdb.header.date);
        }

        pdbEntry.setHeader(pdb.header.header);

        ExpMethod expMethod = new ExpMethod.Builder(pdbEntry, pdb.expMethod.expMethod.toString()).build();
        if (pdb.expMethod.resolution != null) {
            expMethod.setResolution(pdb.expMethod.resolution);
        }
        if (pdb.expMethod.rFactor != null) {
            expMethod.setRFactor(pdb.expMethod.rFactor.rFactor);

            if (pdb.expMethod.rFactor.freeR != null) {
                expMethod.setFreeR(pdb.expMethod.rFactor.freeR);
            }
        }

        if (pdb.hetGroups != null) {
            for (PFHetId hetId : pdb.hetGroups.hetIdList) {
                HetGroup hetGroup = new HetGroup(pdbEntry, hetId.hetId);

                if (hetId.nAtom != null) {
                    hetGroup.setNAtom(hetId.nAtom);
                }

                if (hetId.name != null) {
                    hetGroup.setName(hetId.name);
                }
            }
        }

        for (PFChain chain : pdb.chainList) {
            new Chain(pdbEntry, chain.chain);
        }

        pdbEntrySet.add(pdbEntry);
    }

    pdbFinderDAO.updatePDBEntry(pdbEntrySet);
}

（pdbFinderDAO.updatePDBEntry（pdbEntrySet）是我最初认为问题起源的地方）

编辑：首先抱歉我创建了这个新帖子，我真的以为我找到了答案，但我会继续在这篇文章中进行进一步的编辑。

好的，现在我将所有1000个findAccessionCode标准放入DAO中，方法是将一组原始数据文件发送到DAO，这样它就可以检索那里的id，然后在数据库中找到它们，得到它可以找到的那些将它添加到HashMap中，其中数据库对象被映射，并将原始数据文件的引用作为键（因此我知道原始数据属于哪个数据库条目）。这个函数我像@Transactional一样：

@Override
@Transactional
public Map<RawPDBEntry, PDBEntry> getRawPDBEntryToPDBEntryMap(Set<RawPDBEntry> rawPDBEntrySet) {
    Map<RawPDBEntry, PDBEntry> RawPDBEntryToPDBEntryMap = new HashMap<RawPDBEntry, PDBEntry>();

    for (RawPDBEntry pdb : rawPDBEntrySet) {
        RawPDBEntryToPDBEntryMap.put(pdb, (PDBEntry) createCriteria(Restrictions.eq("accessionCode", pdb.id)).uniqueResult());
    }

    return RawPDBEntryToPDBEntryMap;
}

仍然没有成功......我得到完全相同的错误，但它确实告诉我它是导致它的标准。为什么我不能在同一个连接中执行所有这1000个查询？

编辑：还有另一个更新：我尝试逐个添加所有查询，这很慢，但是很有效。我在一个空数据库上做了这个。接下来我尝试了同样的事情，但现在数据库已经包含了第一次尝试的东西，我得到了以下错误：

Exception in thread "main" org.hibernate.HibernateException: Illegal attempt to associate a collection with two open sessions

我猜这与我在DAO中获取对象（已经在数据库中并因此必须更新）这一事实有关，然后将引用发送回转换方法，然后更改他们的字段，然后将它们发送回DAO以使其持久化。虽然在谷歌上搜索了一下后，我发现人们在他们的POJO中遇到了带有注释的集合问题：

@OneToMany（mappedBy =“pdbEntry”，cascade = CascadeType.ALL，fetch = FetchType.LAZY）

级联导致问题的地方。我是否必须删除所有这些级联并对所有不同的映射对象进行saveOrUpdate（）操作的硬编码？或者这与这个错误无关？

最后：我仍然没有找到如何一次为1000个物体做这件事。

Answer 1

解决了这个问题，它与Spring的错误设置有关，导致@Transactional无法被识别。我解决了这个问题，然后错误就消失了。

Hibernate使用@Transactional创建了太多连接，如何防止这种情况？

1 个答案: