Weak reference concept in Connection

[siva saran]

Hi all,

I have the folowing code snippet

 

private void updateTransaction(){

Connection conn = null;
 try
    {
      conn = getConnection();
    //Do some update transactions

}


    } catch (Exception ex)
    {
      failUpdate = true;
    } finally
    {
	
/*	try
      {
        if (conn != null)
        {
          returnConnection(conn, isConnectionOk);
          conn = null;
        }
      } catch (Exception dp)
      {
    
      }
*/	  
  if(failUpdate){
      
      try
      {
        conn = getConnection();//Again get a new connection
       Do some failed update transactions


      } catch (SQLException e)
      {
        log.warning("updateTransaction():SQL Exception updating the TRANID=" + tranId, e);
        
      }
	  }else{
		log.debug("updateTransaction():NO FAIL UPDATE=" + tranId);
	  }

//Close the connection .
	  
      try
      {
        if (conn != null)
        {
          returnConnection(conn, isConnectionOk);
          conn = null;
        }
      } catch (Exception dp)
      {

      }
    }

    
  }
//Return Connecction method code

private void returnConnection(java.sql.Connection con, boolean connectionOk) {
    if (confactory != null)
      confactory.checkInConnection(con, connectionOk);
    
  }
//Get Connecction method code

private java.sql.Connection getConnection() throws java.sql.SQLException {

    try
    {
      java.sql.Connection con = null;
      con = confactory.checkOutConnection();
      return con;
    } catch (java.sql.SQLException e)
    {
    
    }
  }
   

My doubt is
1) I do a getConnection two times but should I close two times using returnConnection or one returnConnection is enough.
2) I read about a concept called "Weak reference".Does this example point to that.Any more simplified explanation availabe
for the concept somewhere.
3) As of now , I have used two return connection (i have uncommented the code in the finally to avoid problems)but I feel its redundant.Please correct me if am wrong.

[Leandro Coutinho]

next time post a clean and idented code

Googling you'll find nice texts about weak references. But I don't think you need to use it.
Search for connection pool to enhance the performance.

yes, it's redundant. other thing I noticed, you are throwing and catching the exception in the same
method.

I changed the code a little:

private boolean updateTransaction(){  
   
	Connection conn = null;  
	try  {  
		conn = getConnection();  
	}  catch (Exception ex) {  
		return false;  
	}
	try  {  
		//Do some update transactions  
	}  catch (Exception ex)       {  
		failUpdate = true;  
	}
	
	if(failUpdate){  
	   try {  
			//Do some failed update transactions  
		} catch (SQLException e) {  
			log.warning("updateTransaction():SQL Exception updating the TRANID=" + tranId, e);  
		}  
	} else{  
		log.debug("updateTransaction():NO FAIL UPDATE=" + tranId);  
	}  
   
	//Close the connection. If reached here, than conn is not null!!
	returnConnection(conn, isConnectionOk);  
	conn = null;
	
	return true;
}  
  
//Return Connection method code  
private void returnConnection(java.sql.Connection con, boolean connectionOk) {  
	if (confactory != null)  
		confactory.checkInConnection(con, connectionOk);  
}  

//Get Connection method code  
private java.sql.Connection getConnection() {  
	java.sql.Connection con = null;
	try {  
		con = confactory.checkOutConnection();  
	} catch (java.sql.SQLException e) { }  
	return con;  
}

[siva saran]

Thanks Leandro. I will keep your instruction in mind.