Question

将Hibernate与Struts2一起使用，整个流程如下：

hibernate.cfg.xml as：

<hibernate-configuration>

    <session-factory>
    <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
    <property name="connection.url">jdbc:oracle:thin:@xx.xx.xxx.xx:1521:TEST</property>
    <property name="connection.username">xxxx</property>
    <property name="connection.password">xxxxyyy</property>
    <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

   <mapping class="test.models.administration.Menus" />

   <mapping resource="Dual.hbm.xml" />
 </session-factory>

 </hibernate-configuration>

DAO延长AbstractSimpleGenericDao：

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.googlecode.s2hibernate.struts2.plugin.annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.annotations.TransactionTarget;

@SuppressWarnings("unchecked")
public abstract class AbstractSimpleGenericDao<C, I extends Serializable> {

Class<C>                 entityClass;

@SessionTarget
protected Session        hSession;

@TransactionTarget
protected Transaction    hTransaction;

{
entityClass = (Class<C>) ((ParameterizedType)           
getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}

public List<C> getAll()
{
 try
{
  return hSession.createCriteria(entityClass).list();
}
catch (HibernateException e)
{
  throw e;
}
}

  public C get(I id)
   {
    try
    {
     return (C) hSession.get(entityClass, id);
     }
   catch (HibernateException e)
    {
    throw e;
     }
       }

    public void save(C object)
    {
     try
     {
        hSession.save(object);
     }
        catch (HibernateException e)
        {
          hTransaction.rollback();
          throw e;
        }
        }

         public void update(C object)
           {
             try
              {
                hSession.update(object);
               }
        catch (HibernateException e)
          {
           hTransaction.rollback();
           throw e;
           }
            }

      public void delete(I id)
        {
         try
        {
          C actual = get(id);
          hSession.delete(actual);
         }
         catch (HibernateException e)
         {
         hTransaction.rollback();
          throw e;
          }
          }
          }

然后在我的DAO类中扩展 DAO，如：

       public class UserRoleDAO extends AbstractSimpleGenericDao<UserRole, UserRoleId> {

          public List L() {
    try {
        String queryString = "from UserRole";
        Query queryObject = hSession.createQuery(queryString);
        return queryObject.list();
    } catch (RuntimeException re) {
        throw re;
    }
      }

然后在我的struts Action类中，实例化DAO并检索列表：

          public class abc extends ActionSupport{
          private UserRoleDAO userRoleDao = new UserRoleDAO();
          private List ls=new ArrayList();
          public String execute()
        {
             List ls=userRoleDao.L()
     return "success";
        }
            }

如果我正在调用此abc Action类，通过重复单击指定的菜单链接，它会导致连接泄漏，计为我能够使用jProfiler看到的打开的连接，并且永远不会关闭。与此同时，它正在泄漏连接。

所有使用jProfiler打开泄露连接的

StackTrace ：

org.hibernate.transaction.JDBCTransaction.begin()

com.googlecode.s2hibernate.struts2.plugin.interceptors.SessionTransactionInjectorInter
ceptor.injectHibernateTransactionByAnnotation(java.lang.Object, org.hibernate.Session, boolean)

com.googlecode.s2hibernate.struts2.plugin.interceptors.SessionTransactionInjectorInter
ceptor.injectHibernateTransactionByAnnotation(java.lang.Object, org.hibernate.Session, boolean)

com.googlecode.s2hibernate.struts2.plugin.interceptors.SessionTransactionInjectorInter
ceptor.intercept(com.opensymphony.xwork2.ActionInvocation)

java.lang.Thread.run()
URL: /project/action-name

为什么Hibernate会泄漏这些连接？

是不是，Hibernate在会话中保持连接并重用相同的连接，因此，如果我同时进行并发请求，如果会话连接被占用，则会泄漏连接。这只是我假设的。我什么都不知道。

Answer 1

在你的hibernate配置中隐式使用DriverManagerConfigurationProvider。默认情况下使用此提供程序，除非您使用属性connection.provider_class对其进行了配置。

此提供程序还实现了一个非常基本的连接池。

它是什么意思“基本连接池”。如果您运行应用程序，则可以在日志中看到

[DriverManagerConnectionProvider] Using Hibernate built-in connection pool (not for production use!)
[DriverManagerConnectionProvider] Hibernate connection pool size: 20

您还可以通过hibernate配置属性connection.pool_size设置此值。但是它不会限制您达到最大打开的连接数。当池为空时，您可以打开任意数量的连接。除非当前池大小未超过属性closeConnection中的值，否则提供程序将保持打开状态，因为它将连接返回到connection.pool_size上的池。一旦当前池大小不为空，您就无法打开任何新连接，因为连接提供程序从池返回连接。

正如您现在所看到的，很难说默认情况下使用此连接提供程序的hibernate可能会泄漏连接，我只是说这是不可能的。但是，它不受打开连接数量的限制。

要确保连接受限，请使用其他连接提供程序。例如您可以使用C3P0ConnectionProvider并设置属性hibernate.c3p0.max_size以限制已打开的连接。

Java Hibernate连接泄漏

1 个答案: