/*
* File : ConnectionBean.java
* Created : 21-oct-2003 18:11
* By : fbusquets
*
* JClic - Authoring and playing system for educational activities
*
* Copyright (C) 2000 - 2005 Francesc Busquets & Departament
* d'Educacio de la Generalitat de Catalunya
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details (see the LICENSE file).
*/
package edu.xtec.util.db;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
/**
* This class stores an SQL {@link java.sql.Connection} and provides methods to
* obtain {@link java.sql.PreparedStatement} objects from it.
* ConnectionBean
can also store a collection containing all the
* PreparedStatement
objects, allowing client applications to reuse them.
* @author Francesc Busquets
*/
public class ConnectionBean {
private Connection con;
private HashMap statements;
private Date born;
private Date lastUsed;
private String lastStatement;
private Date closed;
/**
* This field is used by {@link edu.xtec.util.db.ConnectionBeanProvider} to count
* the number of times a ConectionBean has been used.
*/
public int usageCount;
/**
* Creates a new instance of ConnectionBean
* @param con {@link java.sql.Connection} object in wich this ConnectionBean will be based.
* @param mapStatements When set to true, PreparedStatement objects will be stored and reused.
*/
public ConnectionBean(Connection con, boolean mapStatements) {
this.con=con;
if(mapStatements)
statements=new HashMap();
born=new Date();
}
/**
* Provides information about the current state of the ConnectionBean.
* @return Information string, formatted in HTML.
*/
public String getInfo(){
StringBuffer sb=new StringBuffer();
sb.append("ConnectionBean ").append(hashCode());
if(statements!=null){
sb.append(" (").append(statements.size()).append(" statements)");
}
sb.append("
\n");
sb.append("Created: ").append(born).append("
\n");
sb.append("Usage count: ").append(usageCount).append("
\n");
if(lastUsed==null)
sb.append("Not yet used!
\n");
else{
sb.append("Last used: ").append(lastUsed).append("
\n");
sb.append("Last statement: ").append(lastStatement).append("
\n");
}
if(closed!=null){
sb.append("Closed: ").append(closed).append("
\n");
}
return sb.toString();
}
/**
* Provides direct access to the {@link java.sql.Connection} object.
* @return The {@link java.sql.Connection} object used in this ConnectionBean.
*/
public Connection getConnection(){
lastUsed=new Date();
return con;
}
/**
* Creates a PreparedStatement based on the current connection and the provided SQL expression.
* Important: Never call the close() method on Prepared statements obtained
* from ConnectionBean
objects created with the mapStatements
option.
* @param sql The SQL statement.
* @throws SQLException If something goes wrong
* @return The {@link java.sql.PreparedStatement} object.
*/
public PreparedStatement getPreparedStatement(String sql) throws SQLException{
if(closed!=null)
throw new SQLException("Connection closed!");
lastUsed=new Date();
lastStatement=sql;
PreparedStatement stmt=(statements==null) ? null : (PreparedStatement)statements.get(sql);
if(stmt==null){
stmt=con.prepareStatement(sql);
if(statements!=null)
statements.put(sql, stmt);
}
else{
try{
// try - catch because
// odbc.jdbc driver throws NullPoiterException on
// PreparedStatement.clearParameters
//
stmt.clearParameters();
} catch(Exception ex){
// eat exception
}
}
return stmt;
}
/**
* Creates a PreparedStatement based on the current connection and the provided SQL expression.
* Important: Never call the close() method on Prepared statements obtained
* from ConnectionBean
objects created with the mapStatements
option.
* @return The {@link java.sql.PreparedStatement} object.
* @param resultSetType A resultSet type. See {@link java.sql.ResultSet}.
* @param resultSetConcurrency A concurrency type. See {@link java.sql.ResultSet}.
* @param sql The SQL sentence of the PreparedStatemnt.
* @throws SQLException If something goes wrong
*/
public PreparedStatement getPreparedStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException{
if(closed!=null)
throw new SQLException("Connection closed!");
lastUsed=new Date();
lastStatement=sql;
PreparedStatement stmt=(statements==null) ? null : (PreparedStatement)statements.get(sql);
if(stmt==null){
stmt=con.prepareStatement(sql, resultSetType, resultSetConcurrency);
if(statements!=null)
statements.put(sql, stmt);
}
else{
try{
// try - catch because
// odbc.jdbc driver throws NullPoiterException on PreparedStatement.clearParameters
//
stmt.clearParameters();
} catch(Exception ex){
// eat exception
}
}
return stmt;
}
/**
* Closes a {@link java.sql.PreparedStatement} object supplied by a previous call
* to getPreparedStatement()
. Applications should always call this method
* when the PreparedStatement
is no longer needed, and never directly
* call close()
in the PreparedStatement
.
* @param stmt The PreparedStatement
to be closed.
*/
public void closeStatement(PreparedStatement stmt){
closeStatement(stmt, false);
}
/**
* ConnectionBeans
created with the mapStatements
tag set
* to true can reuse {@link java.sql.PreparedStatement} objects between calls.
* This method is functionally identical to closeStatement(PreparedStatement)
, but
* has a param that allows to specify if the statement must be really closed.
* @param stmt The PreparedStatement
to be closed.
* @param forceClose When true, the statement will be effectively closed.
*/
public void closeStatement(PreparedStatement stmt, boolean forceClose){
if(stmt!=null){
if(forceClose || statements==null){
try{
stmt.close();
} catch(Exception ex){
System.err.println("Error closing statement: "+stmt);
}
}
if(statements!=null && forceClose){
Iterator it=statements.keySet().iterator();
while(it.hasNext()){
Object o=it.next();
if(statements.get(o)==stmt){
statements.remove(o);
break;
}
}
}
}
}
/**
* Clears all the stored {@link java.sql.PreparedStatement} objects (if any) and closes
* the {@link java.sql.Connection}.
* @throws SQLException If something goes wrong.
*/
public void closeConnection() throws SQLException{
if(closed==null){
closed=new Date();
if(statements!=null){
Iterator it=statements.keySet().iterator();
while(it.hasNext()){
PreparedStatement stmt=(PreparedStatement)statements.get(it.next());
try{
stmt.close();
} catch(Exception ex){
// Eat Exception
}
}
statements.clear();
}
con.close();
}
}
/**
* Getter for property lastStatement.
* @return Value of property lastStatement.
*/
public java.lang.String getLastStatement() {
return lastStatement;
}
/**
* Returns the number of {@link java.sql.PreparedStatement} objects stored by this
* ConnectionBean
. Used only in connection beans created with the mapStatements
* param set to true
.
* @return The number of stored statements.
*/
public int getNumStatements(){
return statements==null ? 0 : statements.size();
}
}