[hibernate-commits] Hibernate SVN: r12914 - in sandbox/trunk/jdbc-proxy/src: main/java/org/hibernate/jdbc/impl and 3 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Fri Aug 10 01:35:01 EDT 2007
Author: steve.ebersole at jboss.com
Date: 2007-08-10 01:35:01 -0400 (Fri, 10 Aug 2007)
New Revision: 12914
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/PreparedStatementProxy.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxy.java
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/JDBCContainer.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxy.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxy.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/StatementProxy.java
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java
sandbox/trunk/jdbc-proxy/src/test/resources/log4j.properties
Log:
more proxy-based jdbc interaction checkins
Modified: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/JDBCContainer.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/JDBCContainer.java 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/JDBCContainer.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -26,6 +26,7 @@
public interface JDBCContainer {
public void register(Statement statement);
public void release(Statement statement);
+
public void register(ResultSet resultSet);
public void release(ResultSet resultSet);
Modified: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -17,7 +17,6 @@
import java.sql.Statement;
import java.sql.ResultSet;
-import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashSet;
import java.util.Iterator;
@@ -80,10 +79,10 @@
registeredStatements.clear();
}
- protected final void close(Statement statement) {
+ protected void close(Statement statement) {
log.trace( "closing prepared statement [" + statement + "]" );
try {
- // if we are unable to "clean" the prepared statement,
+ // if we are unable to "clan" the prepared statement,
// we do not close it
try {
if ( statement.getMaxRows() != 0 ) {
@@ -105,7 +104,7 @@
}
}
- protected final void close(ResultSet resultSet) {
+ protected void close(ResultSet resultSet) {
log.trace( "closing result set [" + resultSet + "]" );
try {
resultSet.close();
Modified: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxy.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxy.java 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxy.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -16,34 +16,48 @@
package org.hibernate.jdbc.proxy;
import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Proxy;
+import java.sql.CallableStatement;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
import java.sql.Statement;
-import java.sql.SQLException;
import java.util.HashSet;
+import java.util.Iterator;
import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.HibernateException;
+import org.hibernate.jdbc.JDBCContainer;
+import org.hibernate.jdbc.JDBCServices;
+
/**
* AbstractStatementProxy implementation
*
* @author Steve Ebersole
*/
public abstract class AbstractStatementProxy implements InvocationHandler {
- private final String sql;
- private final Statement statement;
- private final ConnectionProxy connectionProxy;
- private Set resultSets;
+ public static final Class[] PROXY_INTERFACES = new Class[] { Statement.class };
+ public static final Class[] PS_PROXY_INTERFACES = new Class[] { PreparedStatement.class };
+ public static final Class[] CS_PROXY_INTERFACES = new Class[] { CallableStatement.class };
- protected AbstractStatementProxy(String sql, Statement statement, ConnectionProxy connectionProxy) {
- this.sql = sql;
+ private static final Logger log = LoggerFactory.getLogger( AbstractStatementProxy.class );
+
+ private boolean valid = true;
+ private Statement statement;
+ private ConnectionProxy connectionProxy;
+ private Set resultSetProxies;
+
+ protected AbstractStatementProxy(Statement statement, ConnectionProxy connectionProxy) {
this.statement = statement;
this.connectionProxy = connectionProxy;
+ getJdbcContainer().register( statement );
}
- protected String getSql() {
- return sql;
- }
-
protected Statement getStatement() {
return statement;
}
@@ -52,20 +66,56 @@
return connectionProxy;
}
- protected Set getResultSets() {
- return resultSets;
+ protected Set getResultSetProxies() {
+ return resultSetProxies;
}
- protected Set getOrCreateResultSets() {
- if ( resultSets == null ) {
- resultSets = new HashSet();
+ protected JDBCServices getJdbcServices() {
+ return getConnectionProxy().getJdbcServices();
+ }
+
+ protected JDBCContainer getJdbcContainer() {
+ return getConnectionProxy().getJdbcContainer();
+ }
+
+ protected Set getOrCreateResultSetProxies() {
+ if ( resultSetProxies == null ) {
+ resultSetProxies = new HashSet();
}
- return resultSets;
+ return resultSetProxies;
}
- protected Object invokeOnStatement(Method method, Object[] args) throws Throwable {
+ public final Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ String methodName = method.getName();
+ log.trace( "Handling invocation of statement method [{}]", methodName );
+
+ if ( !valid ) {
+ throw new HibernateException( "connection handle is invalid" );
+ }
+
+ if ( "close".equals( methodName ) ) {
+ explicitClose( ( Statement ) proxy );
+ return null;
+ }
+
+ beginningInvocationHandling( method, args );
+
try {
- return method.invoke( statement, args );
+ boolean exposingResultSet = doesMethodExposeResultSet( method );
+
+ Object result = method.invoke( statement, args );
+
+ if ( exposingResultSet ) {
+ ResultSetProxy handler = new ResultSetProxy( ( ResultSet ) result, this );
+ result = Proxy.newProxyInstance(
+ getClass().getClassLoader(),
+ ResultSetProxy.PROXY_INTERFACES,
+ handler
+ );
+ getOrCreateResultSetProxies().add( result );
+ }
+
+ return result;
}
catch ( InvocationTargetException e ) {
Throwable realException = e.getTargetException();
@@ -78,16 +128,39 @@
}
}
- void close(Statement statement) {
-
+ protected void beginningInvocationHandling(Method method, Object[] args) {
}
- /**
- * Release resources associated with this statement.
- *
- * NOTE : package-protected
- */
- void release() {
- // todo : eventually need to iterate results and release them
+ private void explicitClose(Statement proxy) {
+ if ( resultSetProxies != null ) {
+ Iterator itr = resultSetProxies.iterator();
+ while ( itr.hasNext() ) {
+ final ResultSet resultSetProxy = ( ResultSet ) itr.next();
+ try {
+ resultSetProxy.close();
+ }
+ catch ( SQLException e ) {
+ // should never ever happen...
+ log.warn( "unhandled SQLException escaped proxy handling!", e );
+ // but the underlying resources should still get cleaned up when the logical connection closes...
+ }
+ itr.remove();
+ }
+ }
+ connectionProxy.getJdbcContainer().release( statement );
+ connectionProxy.proxiedStatementExplicitlyClosed( proxy );
+ statement = null;
+ connectionProxy = null;
+ resultSetProxies = null;
+ valid = false;
}
+
+ protected boolean doesMethodExposeResultSet(Method method) {
+ return ResultSet.class.isAssignableFrom( method.getReturnType() )
+ && !method.getName().equals( "getGeneratedKeys" );
+ }
+
+ /*package-protected*/ void proxiedResultSetExplicitlyClosed(ResultSet proxy) {
+ resultSetProxies.remove( proxy );
+ }
}
Modified: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxy.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxy.java 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxy.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -18,13 +18,20 @@
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
import java.sql.Connection;
+import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.hibernate.HibernateException;
+import org.hibernate.jdbc.ConnectionWrapper;
import org.hibernate.jdbc.JDBCContainer;
import org.hibernate.jdbc.JDBCServices;
import org.hibernate.jdbc.Observer;
@@ -36,9 +43,13 @@
* @author Steve Ebersole
*/
public class ConnectionProxy implements InvocationHandler, Observer {
+ public static final Class[] PROXY_INTERFACES = new Class[] { Connection.class, ConnectionWrapper.class };
+
private static final Logger log = LoggerFactory.getLogger( ConnectionProxy.class );
+ private boolean valid = true;
private LogicalConnectionImplementor logicalConnection;
+ private HashSet statementProxies;
public ConnectionProxy(LogicalConnectionImplementor logicalConnection) {
this.logicalConnection = logicalConnection;
@@ -47,24 +58,50 @@
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
+ log.trace( "Handling invocation of Connection method [{}]", methodName );
+ if ( !valid ) {
+ throw new HibernateException( "connection handle is invalid" );
+ }
+
if ( "getWrappedConnection".equals( methodName ) ) {
return extractPhysicalConnection();
}
- // todo : close??? depends on whether we allow multiple connection proxies on the same logical connection
+ if ( "close".equals( methodName ) ) {
+ explicitClose();
+ return null;
+ }
try {
+ boolean creatingBasicStatement = "createStatement".equals( methodName );
+ boolean creatingPreparedStatement = "prepareStatement".equals( methodName );
+ boolean creatingCallableStatement = "prepareCall".equals( methodName );
+
Object result = method.invoke( extractPhysicalConnection(), args );
- if ( "prepareStatement".equals( methodName )
- || "prepareCall".equals( methodName )
- || "createStatement".equals( methodName ) ) {
- getJdbcContainer().register( ( Statement ) result ); // todo : this should eventually be the statemernt proxy
- if ( args != null && args.length > 0 ) {
- // there is a version of createStatement which does not take the SQL...
- logicalConnection.getJdbcServices().getSqlStatementLogger().logStatement( ( String ) args[0] );
+ if ( creatingBasicStatement || creatingPreparedStatement || creatingCallableStatement ) {
+ AbstractStatementProxy proxyHandler;
+ Class[] interfaces;
+ if ( creatingPreparedStatement ) {
+ proxyHandler = new PreparedStatementProxy( ( String ) args[0], ( PreparedStatement ) result, this );
+ interfaces = AbstractStatementProxy.PS_PROXY_INTERFACES;
}
+ else if ( creatingCallableStatement ) {
+ proxyHandler = new PreparedStatementProxy( ( String ) args[0], ( PreparedStatement ) result, this );
+ interfaces = AbstractStatementProxy.CS_PROXY_INTERFACES;
+ }
+ else {
+ proxyHandler = new StatementProxy( ( Statement ) result, this );
+ interfaces = AbstractStatementProxy.PROXY_INTERFACES;
+ }
+
+ result = Proxy.newProxyInstance(
+ getClass().getClassLoader(), // use our classloader
+ interfaces,
+ proxyHandler
+ );
+ getOrCreateStatementProxies().add( result );
}
return result;
@@ -80,10 +117,49 @@
}
}
+ private Set getOrCreateStatementProxies() {
+ if ( statementProxies == null ) {
+ statementProxies = new HashSet();
+ }
+ return statementProxies;
+ }
+
+ private void explicitClose() {
+ if ( statementProxies != null ) {
+ Iterator itr = statementProxies.iterator();
+ while ( itr.hasNext() ) {
+ final Statement proxy = ( Statement ) itr.next();
+ try {
+ proxy.close();
+ }
+ catch ( SQLException e ) {
+ // should never ever happen...
+ log.warn( "unhandled SQLException escaped proxy handling!", e );
+ // but the underlying resources should still get cleaned up when the logical connection closes...
+ }
+ }
+ }
+ invalidateHandle();
+ }
+
+ private void invalidateHandle() {
+ log.trace( "Invalidating connection handle" );
+ logicalConnection = null;
+ valid = false;
+ if ( statementProxies != null ) {
+ statementProxies.clear();
+ statementProxies = null;
+ }
+ }
+
private Connection extractPhysicalConnection() {
return logicalConnection.getConnection();
}
+ /*package-protected*/ void proxiedStatementExplicitlyClosed(Statement proxy) {
+ statementProxies.remove( proxy );
+ }
+
/*package-protected*/ JDBCServices getJdbcServices() {
return logicalConnection.getJdbcServices();
}
@@ -103,7 +179,7 @@
public void logicalConnectionClosed() {
log.info( "*** logical connection closed ***" );
+ invalidateHandle();
}
-
}
Added: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/PreparedStatementProxy.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/PreparedStatementProxy.java (rev 0)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/PreparedStatementProxy.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.sql.Statement;
+
+/**
+ * PreparedStatementProxy implementation
+ *
+ * @author Steve Ebersole
+ */
+public class PreparedStatementProxy extends AbstractStatementProxy {
+ private final String sql;
+
+ protected PreparedStatementProxy(String sql, Statement statement, ConnectionProxy connectionProxy) {
+ super( statement, connectionProxy );
+ connectionProxy.getJdbcServices().getSqlStatementLogger().logStatement( sql );
+ this.sql = sql;
+ }
+}
Added: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxy.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxy.java (rev 0)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxy.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.HibernateException;
+
+/**
+ * ResultSetProxy implementation
+ *
+ * @author Steve Ebersole
+ */
+public class ResultSetProxy implements InvocationHandler {
+ public static final Class[] PROXY_INTERFACES = new Class[] { ResultSet.class };
+
+ private static final Logger log = LoggerFactory.getLogger( ResultSetProxy.class );
+
+ private boolean valid = true;
+ private ResultSet physicalResultSet;
+ private AbstractStatementProxy associatedStatementProxy;
+
+ public ResultSetProxy(ResultSet physicalResultSet, AbstractStatementProxy associatedStatementProxy) {
+ this.physicalResultSet = physicalResultSet;
+ this.associatedStatementProxy = associatedStatementProxy;
+ associatedStatementProxy.getJdbcContainer().register( physicalResultSet );
+ }
+
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ String methodName = method.getName();
+ log.trace( "Handling invocation of resultset method [{}]", methodName );
+
+ if ( !valid ) {
+ throw new HibernateException( "connection handle is invalid" );
+ }
+
+ if ( "close".equals( methodName ) ) {
+ explicitClose( ( ResultSet ) proxy );
+ return null;
+ }
+
+ try {
+ return method.invoke( physicalResultSet, args );
+ }
+ catch ( InvocationTargetException e ) {
+ Throwable realException = e.getTargetException();
+ if ( SQLException.class.isInstance( realException ) ) {
+ throw associatedStatementProxy.getJdbcServices().getExceptionHelper().convert( ( SQLException ) realException, "???", "???" );
+ }
+ else {
+ throw realException;
+ }
+ }
+ }
+
+ private void explicitClose(ResultSet proxy) {
+ associatedStatementProxy.getJdbcContainer().release( physicalResultSet );
+ associatedStatementProxy.proxiedResultSetExplicitlyClosed( proxy );
+ physicalResultSet = null;
+ associatedStatementProxy = null;
+ valid = false;
+ }
+}
Modified: sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/StatementProxy.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/StatementProxy.java 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/StatementProxy.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -15,8 +15,8 @@
*/
package org.hibernate.jdbc.proxy;
+import java.sql.Statement;
import java.lang.reflect.Method;
-import java.sql.Statement;
/**
* StatementProxy implementation
@@ -24,11 +24,20 @@
* @author Steve Ebersole
*/
public class StatementProxy extends AbstractStatementProxy {
- protected StatementProxy(String sql, Statement statement, ConnectionProxy connectionProxy) {
- super( sql, statement, connectionProxy );
+ protected StatementProxy(Statement statement, ConnectionProxy connectionProxy) {
+ super( statement, connectionProxy );
}
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- return null;
+ protected void beginningInvocationHandling(Method method, Object[] args) {
+ if ( isExecution( method ) ) {
+ getJdbcServices().getSqlStatementLogger().logStatement( ( String ) args[0] );
+ }
}
+
+ private boolean isExecution(Method method) {
+ String methodName = method.getName();
+ return "execute".equals( methodName )
+ || "executeQuery".equals( methodName )
+ || "executeUpdate".equals( methodName );
+ }
}
Modified: sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java
===================================================================
--- sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java 2007-08-10 05:35:01 UTC (rev 12914)
@@ -87,9 +87,8 @@
ps.setString( 2, "name" );
ps.execute();
-// statement and resultset proxying not yet implemented
-// ps = proxiedConnection.prepareStatement( "select * from SANDBOX_JDBC_TST" );
-// ps.executeQuery();
+ ps = proxiedConnection.prepareStatement( "select * from SANDBOX_JDBC_TST" );
+ ps.executeQuery();
assertTrue( logicalConnection.getJdbcContainer().hasRegisteredResources() );
}
Modified: sandbox/trunk/jdbc-proxy/src/test/resources/log4j.properties
===================================================================
--- sandbox/trunk/jdbc-proxy/src/test/resources/log4j.properties 2007-08-09 20:10:00 UTC (rev 12913)
+++ sandbox/trunk/jdbc-proxy/src/test/resources/log4j.properties 2007-08-10 05:35:01 UTC (rev 12914)
@@ -18,7 +18,6 @@
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
-
log4j.rootLogger=info, stdout
log4j.logger.org.hibernate=trace
\ No newline at end of file
More information about the hibernate-commits
mailing list