2012-10-07 152 views
0

当我尝试在JSF页面做一个以上的交易,我得到以下错误:Glassfish的“连接已关闭”的错误使用连接池,JDBC和SQL Server 2008

A potential connection leak detected for connection pool MSSQL. The stack trace of the thread is provided below : 
com.sun.enterprise.resource.pool.ConnectionPool.setResourceStateToBusy(ConnectionPool.java:324) 
com.sun.enterprise.resource.pool.ConnectionPool.getResourceFromPool(ConnectionPool.java:758) 
com.sun.enterprise.resource.pool.ConnectionPool.getUnenlistedResource(ConnectionPool.java:632) 
com.sun.enterprise.resource.pool.AssocWithThreadResourcePool.getUnenlistedResource(AssocWithThreadResourcePool.java:196) 
com.sun.enterprise.resource.pool.ConnectionPool.internalGetResource(ConnectionPool.java:526) 
com.sun.enterprise.resource.pool.ConnectionPool.getResource(ConnectionPool.java:381) 
com.sun.enterprise.resource.pool.PoolManagerImpl.getResourceFromPool(PoolManagerImpl.java:245) 
com.sun.enterprise.resource.pool.PoolManagerImpl.getResource(PoolManagerImpl.java:170) 
com.sun.enterprise.connectors.ConnectionManagerImpl.getResource(ConnectionManagerImpl.java:338) 
com.sun.enterprise.connectors.ConnectionManagerImpl.internalGetConnection(ConnectionManagerImpl.java:301) 
com.sun.enterprise.connectors.ConnectionManagerImpl.allocateConnection(ConnectionManagerImpl.java:190) 
com.sun.enterprise.connectors.ConnectionManagerImpl.allocateConnection(ConnectionManagerImpl.java:165) 
com.sun.enterprise.connectors.ConnectionManagerImpl.allocateConnection(ConnectionManagerImpl.java:160) 
com.sun.gjc.spi.base.DataSource.getConnection(DataSource.java:113) 
cl.codesin.colegios.util.persistencia.DAOManejador.abrir(DAOManejador.java:126) 

请注意最后一行我粘贴:

cl.codesin.colegios.util.persistencia.DAOManejador.abrir(DAOManejador.java:126) 

abrir执行以下操作:

public void abrir() throws SQLException { 
    try 
    { 
     if(this.con==null || this.con.isClosed()) 
      this.con = fuenteDatos.getConnection(); 
    } 
    catch(SQLException e) 
    { 
     throw e; 
    } 
} 

它工作在一个单独的DAO管理器:DAO管理器拥有每个DAO的一个实例并管理每个DAO共享的单个连接。当请求DAO,它具有以下功能:

public DAORegion getDAOregion() throws SQLException { 
     try 
     { 
      if(con == null) //con is the connection the DAO manager uses 
      { 
       this.abrir(); 
      } 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
     if(this.DAOregion==null) 
     { 
      this.DAOregion = new DAORegion(this.con); 
     } 
     return DAOregion; 
    } 

当关闭连接,管理者只是调用con.close()没有别的。

顺便说一句,我没有persistence.xml,因为我正在使用JDBC。

我在做什么错?事先谢谢你。

编辑:通过停用从Glassfish服务器泄漏检测我可以避免例外,但我仍然收到“连接关闭”错误。最糟糕的是,现在我不清楚错误发生的位置。

编辑2:我再次改变了我的DAO管理器。这是实现。

public class DAOManejador { 

    public static DAOManejador getInstancia() { 
     return DAOManejadorSingleton.INSTANCIA; 
    } 

    //This is just a sample, every getDAOXXX works the same. 
    public DAOUsuario getDAOusuario() throws SQLException { 
     try 
     { 
      if(con == null) 
      { 
       this.abrir(); 
      } 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
     if(this.DAOusuario==null) 
     { 
      this.DAOusuario = new DAOUsuario(this.con, this.stmt, this.res); 
     } 
     return DAOusuario; 
    } 

    public void abrir() throws SQLException { 
     try 
     { 
      if(this.con==null || this.con.isClosed()) 
       this.con = fuenteDatos.getConnection(); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void iniciaTransaccion() throws SQLException { 
     try 
     { 
      con.setAutoCommit(false); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void cierraTransaccion() throws SQLException { 
     try 
     { 
      con.setAutoCommit(true); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void comprometer() throws SQLException { 
     try 
     { 
      con.commit(); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void deshacer() throws SQLException { 
     try 
     { 
      con.rollback(); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void cerrar() throws SQLException { 
     try 
     { 
      if(this.stmt!=null && !this.stmt.isClosed()) 
       stmt.close(); 

      if(this.res!=null && !this.res.isClosed()) 
       this.res.close(); 

      if(this.con!=null && !this.con.isClosed()) 
       con.close(); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void comprometerYTerminarTransaccion() throws SQLException { 
     try 
     { 
      this.comprometer(); 
      this.cierraTransaccion(); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    public void comprometerYCerrarConexion() throws SQLException { 
     try 
     { 
      this.comprometer(); 
      this.cierraTransaccion(); 
      this.cerrar(); 
     } 
     catch(SQLException e) 
     { 
      throw e; 
     } 
    } 

    //Protegidos 
    @Override 
    protected void finalize() throws SQLException, Throwable 
    { 
     try 
     { 
      this.cerrar(); 
     } 
     finally 
     { 
      super.finalize(); 
     } 
    } 

    //Private 
    private DataSource fuenteDatos; 
    private Connection con = null; 
    private PreparedStatement stmt = null; 
    private ResultSet res = null; 

    private DAOUsuario DAOusuario = null; 
    private DAORegion DAOregion = null; 
    private DAOProvincia DAOprovincia = null; 
    private DAOComuna DAOcomuna = null; 
    private DAOColegio DAOcolegio = null; 

    private DAOManejador() throws Exception { 
     try 
     { 
      InitialContext ctx = new InitialContext(); 
      this.fuenteDatos = (DataSource)ctx.lookup("jndi/MSSQL"); 
     } 
     catch(Exception e){ throw e; } 
    } 

    private static class DAOManejadorSingleton { 
     public static final DAOManejador INSTANCIA; 
     static 
     { 
      DAOManejador dm; 
      try 
      { 
       dm = new DAOManejador(); 
      } 
      catch(Exception e) 
      { dm=null; } 
      INSTANCIA = dm; 
     } 
    } 

} 

我现在所做的是为每个DAO提供一个接入点。当DAO想要使用语句或资源时,它们将全部使用相同的语言或资源。当他们需要再次打开,系统将执行以下操作:

public abstract class DAOGenerico<T> { 

    //Protected 
    protected final String nombreTabla; 
    protected Connection con; 
    protected PreparedStatement stmt; 
    protected ResultSet res; 

    protected DAOGenerico(Connection con, PreparedStatement stmt, ResultSet res, String nombreTabla) { 
     this.nombreTabla = nombreTabla; 
     this.con = con; 
     this.stmt = stmt; 
     this.res = res; 
    } 

    //Prepares a query 
    protected final void prepararConsulta(String query) throws SQLException 
    {    
     try 
     { 
      if(this.stmt!=null && !this.stmt.isClosed()) 
       this.stmt.close(); 
      this.stmt = this.con.prepareStatement(query); 
     } 
     catch(SQLException e){ throw e; } 
    } 

    //Gets a ResultSet 
    protected final void obtenerResultados() throws SQLException { 
     try 
     { 
      if(this.res!=null && !this.res.isClosed()) 
       this.res.close(); 
      this.res = this.stmt.executeQuery(); 
     } 
     catch(SQLException e){ throw e; } 
    } 

} 

仍然不起作用。

回答

1

我在关闭连接时没有做任何事情。我评论了 cerrar方法中的代码,出于某种原因,它的工作原理!即使这是一种不好的做法!保持这种状态是否可以,或者我应该找到一种方法来关闭连接?

无视这一点,我发现有什么不对。我希望有人能够在未来充分利用这一点。

问题

if(this.con==null || this.con.isClosed()) 
    this.con = fuenteDatos.getConnection(); 

每次我试图打开一个连接,我得到一个完全崭新的连接。这有什么问题?

public DAOUsuario getDAOusuario() throws SQLException { 
    try 
    { 
     if(con == null) 
     { 
      this.abrir(); 
     } 
    } 
    catch(SQLException e) 
    { 
     throw e; 
    } 
    if(this.DAOusuario==null) 
    { 
     this.DAOusuario = new DAOUsuario(this.con, this.stmt, this.res); 
    } 
    return DAOusuario; 
} 

只有当我创建一个新的DAO实例时,我为它分配一个新的连接。接下来的情况会发生什么?

DAOManejador daoManager = DAOManejador.getInstancia(); //Get an instance of the DAO manager 
daoManager.abrir(); //Open the connection 
DAOUsuario daoUser = daoManager.getDAOusuario(); //Get a DAOUsuario, a type of DAO. It'll have the same connection as the DAOManager, and it'll be stored in the instance of the DAO manager 
... //Do database stuff 
daoManager.cerrar(); //Close the connection 
daoManager.abrir(); //Open the connection again. Note that this will be a new instance of the conection rather than the old one 

如果,从这里,你尝试做数据库的东西,你会得到一个连接关闭错误,因为daoUser将仍持有旧的连接。

我做了什么

我修改了DAO管理器类。它不再拥有getDAOXXX()每DAO,而是如下:

public DAOGenerico getDAO(Tabla t) throws SQLException { 
    try 
    { 
     if(con == null || this.con.isClosed()) 
     { 
      this.abrir(); 
     } 
    } 
    catch(SQLException e) 
    { 
     throw e; 
    } 
    switch(t) 
    { 
     case REGION: 
      return new DAORegion(this.con, this.stmt, this.res); 
     case PROVINCIA: 
      return new DAOProvincia(this.con, this.stmt, this.res); 
     case COMUNA: 
      return new DAOComuna(this.con, this.stmt, this.res); 
     case USUARIO: 
      return new DAOUsuario(this.con, this.stmt, this.res); 
     case COLEGIO: 
      return new DAOColegio(this.con, this.stmt, this.res); 
     default: 
      throw new SQLException("Se intentó vincular a una tabla que no existe."); 
    } 
} 

每一个用户请求一个DAO的时候,它会请经理返回正确类型的DAO。但不是存储每个实例,管理器将根据当前连接创建新实例(con是连接,stmt是PreparedStatement,而res是ResultSet - 它们将用于在管理器关闭连接时关闭它们没有泄漏)。 Tabla是保存数据库中当前表名的enum,以便它可以返回正确的DAO。这工作没有任何问题。 其余的课程都是一样的,所以如果你想使用它,只需将DAOUsuario方法替换为上面的方法,它应该工作正常