JonasSQLWrapper.java

/*
 *
 * JOnAS: Java(TM) Open Application Server
 * Copyright (C) 1999 Bull S.A.
 * Contact: jonas-team@objectweb.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 * --------------------------------------------------------------------------
 * $Id: JonasSQLWrapper.java,v 1.6 2004/10/29 23:33:37 ehardesty Exp $
 * --------------------------------------------------------------------------
 */

package org.objectweb.jonas.resource;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class JonasSQLWrapper implements InvocationHandler {

    private static final int PROXY_FIXED_ARGS = 3;
    private Object connection = null;
    private SQLManager conman = null;
    private MCInfo mci = null;
    private String user = null;
    private Logger trace = null;

    private boolean invalid = false;
    private boolean supportsPreparedCache = true;

    public JonasSQLWrapper(Object pConn, MCInfo pMci, SQLManager pConman, Logger pTrace)
              throws Exception {
        connection = pConn;
        mci = pMci;
        conman = pConman;
        trace = pTrace;
        user = mci.mc.getMetaData().getUserName();
    }

    public static Object createSQLWrapper(Object pConn, MCInfo pMci,
                                           SQLManager pConman, Logger pTrace)
                 throws Exception {
        Class class1 = pConn.getClass();
        Class [] aclass = buildInterfaces(class1);
        return Proxy.newProxyInstance(class1.getClassLoader(), aclass,
                                       new JonasSQLWrapper(pConn, pMci, pConman, pTrace));
    }

    public Object invoke(Object obj, Method method, Object [] aobj)
        throws Throwable {

        Object retObj = null;
        if (method.getName().compareTo("prepareStatement") == 0) {
            retObj = prepareStatement(method.getParameterTypes(), aobj);
            if (retObj == null) {
                retObj = method.invoke(connection, aobj);
            }
        } else {
            if (method.getName().compareTo("close") == 0) {
                invalid = true;
            } else if (method.getName().compareTo("toString") == 0) {
                return connection.toString();
            } else if (method.getName().compareTo("commit") == 0) {
                trace.log(BasicLevel.DEBUG, "" + this);
            } else {
                checkIfValid();
            }
            retObj = method.invoke(connection, aobj);
        }
        return retObj;
    }

    public Object prepareStatement(Class [] pTypes, Object [] pValues)
        throws Exception {

        checkIfValid();

        if (supportsPreparedCache) {
            try {
                Class [] mTypes = new Class[PROXY_FIXED_ARGS + pTypes.length];
                Object [] mValues = new Object[PROXY_FIXED_ARGS + pValues.length];

                mTypes[0] = MCInfo.class;
                mTypes[1] = Object.class;
                mTypes[2] = String.class;

                mValues[0] = mci;
                mValues[1] = connection;
                mValues[2] = user;

                // Loop should be faster than System.arraycopy for small
                // number of parameters
                for (int i = 0; i < pTypes.length; i++) {
                    mTypes[PROXY_FIXED_ARGS + i] = pTypes[i];
                    mValues[PROXY_FIXED_ARGS + i] = pValues[i];
                }

                Method meth1 = conman.getClass().getMethod("getPStatement", mTypes);
                return meth1.invoke(conman, mValues);
            } catch (Exception ex) {
                ex.printStackTrace();
                return null;
            }
        } else {
            return null;
        }

    }
/*
// JDK 1.4
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
        throws SQLException {
        checkIfValid();
        if (supportsPreparedCache) {
            return conman.getStatement(user, connection, sql, autoGeneratedKeys);
        } else {
            return con.prepareStatement(sql, autoGeneratedKeys);
        }
    }

// JDK 1.4
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
        throws SQLException {
        checkIfValid();
        if (supportsPreparedCache) {
            return conman.getStatement(user, connection, sql, columnIndexes);
        } else {
            return con.prepareStatement(sql, columnIndexes);
        }
    }

// JDK 1.4
    public PreparedStatement prepareStatement(String sql, int resultSetType,
                                               int resultSetConcurrency,
                                               int resultSetHoldability)
        throws SQLException {
        checkIfValid();
        if (supportsPreparedCache) {
            return conman.getStatement(user, connection, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
        } else {
            return con.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
        }
    }

// JDK 1.4
    public PreparedStatement prepareStatement(String sql, String[] columnNames)
        throws SQLException {
        checkIfValid();
        if (supportsPreparedCache) {
            return conman.getStatement(user, connection, sql, columnNames);
        } else {
            return con.prepareStatement(sql, columnNames);
        }
    }
*/

    public String toString() {
        return connection.toString();
    }

    private void checkIfValid() throws SQLException {
        if (invalid) {
            throw new SQLException("Connection is closed");
        }
    }

    /* Utility methods to build interfaces*/
    private static Class[] buildInterfaces(Class class1) {
        ArrayList arlist = new ArrayList();
        addToList(class1, arlist);
        Class [] aclass = new Class[arlist.size()];
        return (Class []) arlist.toArray(aclass);
    }

    private static void addToList(Class cls, List lst) {
        Class [] aclass = cls.getInterfaces();
        for (int i = 0; i < aclass.length; i++) {
            if (!lst.contains(aclass[i])) {
                lst.add(aclass[i]);
            }
            addToList(aclass[i], lst);
        }

        Class class2 = cls.getSuperclass();
        if (class2 != null) {
            addToList(class2, lst);
        }
    }
}

---