KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > dbutils > ProxyFactory


1 /*
2  * $Header: /home/cvs/jakarta-commons/dbutils/src/java/org/apache/commons/dbutils/ProxyFactory.java,v 1.3 2003/11/09 04:54:32 dgraham Exp $
3  * $Revision: 1.3 $
4  * $Date: 2003/11/09 04:54:32 $
5  *
6  * ====================================================================
7  *
8  * The Apache Software License, Version 1.1
9  *
10  * Copyright (c) 2003 The Apache Software Foundation. All rights
11  * reserved.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  *
17  * 1. Redistributions of source code must retain the above copyright
18  * notice, this list of conditions and the following disclaimer.
19  *
20  * 2. Redistributions in binary form must reproduce the above copyright
21  * notice, this list of conditions and the following disclaimer in
22  * the documentation and/or other materials provided with the
23  * distribution.
24  *
25  * 3. The end-user documentation included with the redistribution, if
26  * any, must include the following acknowledgement:
27  * "This product includes software developed by the
28  * Apache Software Foundation (http://www.apache.org/)."
29  * Alternately, this acknowledgement may appear in the software itself,
30  * if and wherever such third-party acknowledgements normally appear.
31  *
32  * 4. The names "The Jakarta Project", "Commons", and "Apache Software
33  * Foundation" must not be used to endorse or promote products derived
34  * from this software without prior written permission. For written
35  * permission, please contact apache@apache.org.
36  *
37  * 5. Products derived from this software may not be called "Apache"
38  * nor may "Apache" appear in their names without prior written
39  * permission of the Apache Software Foundation.
40  *
41  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
42  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
43  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
44  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
45  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
46  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
47  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
48  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
49  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
51  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52  * SUCH DAMAGE.
53  * ====================================================================
54  *
55  * This software consists of voluntary contributions made by many
56  * individuals on behalf of the Apache Software Foundation. For more
57  * information on the Apache Software Foundation, please see
58  * <http://www.apache.org/>.
59  *
60  */
61
62 package org.apache.commons.dbutils;
63
64 import java.lang.reflect.InvocationHandler JavaDoc;
65 import java.lang.reflect.Proxy JavaDoc;
66 import java.sql.CallableStatement JavaDoc;
67 import java.sql.Connection JavaDoc;
68 import java.sql.Driver JavaDoc;
69 import java.sql.PreparedStatement JavaDoc;
70 import java.sql.ResultSet JavaDoc;
71 import java.sql.ResultSetMetaData JavaDoc;
72 import java.sql.Statement JavaDoc;
73
74 /**
75  * Creates proxy implementations of JDBC interfaces. This avoids
76  * incompatibilities between the JDBC 2 and JDBC 3 interfaces. This class is
77  * thread safe.
78  *
79  * @see java.lang.reflect.Proxy
80  * @see java.lang.reflect.InvocationHandler
81  *
82  * @author David Graham
83  */
84 public class ProxyFactory {
85
86     /**
87      * Class[] for CallableStatement interface.
88      */
89     private static final Class JavaDoc[] callableStatementClass =
90         new Class JavaDoc[] { CallableStatement JavaDoc.class };
91
92     /**
93      * Class[] for Connection interface.
94      */
95     private static final Class JavaDoc[] connectionClass =
96         new Class JavaDoc[] { Connection JavaDoc.class };
97
98     /**
99      * Class[] for Driver interface.
100      */
101     private static final Class JavaDoc[] driverClass = new Class JavaDoc[] { Driver JavaDoc.class };
102
103     /**
104      * The Singleton instance of this class.
105      */
106     private static final ProxyFactory instance = new ProxyFactory();
107
108     /**
109      * Class[] for ResultSetMetaData interface.
110      */
111     private static final Class JavaDoc[] metaClass =
112         new Class JavaDoc[] { ResultSetMetaData JavaDoc.class };
113
114     /**
115      * Class[] for PreparedStatement interface.
116      */
117     private static final Class JavaDoc[] preparedStatementClass =
118         new Class JavaDoc[] { PreparedStatement JavaDoc.class };
119
120     /**
121      * Class[] for ResultSet interface.
122      */
123     private static final Class JavaDoc[] resultSetClass =
124         new Class JavaDoc[] { ResultSet JavaDoc.class };
125
126     /**
127      * Class[] for Statement interface.
128      */
129     private static final Class JavaDoc[] statementClass =
130         new Class JavaDoc[] { Statement JavaDoc.class };
131
132     /**
133      * Returns the Singleton instance of this class.
134      */
135     public static ProxyFactory instance() {
136         return instance;
137     }
138
139     /**
140      * Protected constructor for ProxyFactory subclasses to use.
141      */
142     protected ProxyFactory() {
143         super();
144     }
145
146     /**
147      * Creates a new proxy <code>CallableStatement</code> object.
148      * @param handler The handler that intercepts/overrides method calls.
149      */
150     public CallableStatement JavaDoc createCallableStatement(InvocationHandler JavaDoc handler) {
151         return (CallableStatement JavaDoc) Proxy.newProxyInstance(
152             handler.getClass().getClassLoader(),
153             callableStatementClass,
154             handler);
155     }
156
157     /**
158      * Creates a new proxy <code>Connection</code> object.
159      * @param handler The handler that intercepts/overrides method calls.
160      */
161     public Connection JavaDoc createConnection(InvocationHandler JavaDoc handler) {
162         return (Connection JavaDoc) Proxy.newProxyInstance(
163             handler.getClass().getClassLoader(),
164             connectionClass,
165             handler);
166     }
167
168     /**
169      * Creates a new proxy <code>Driver</code> object.
170      * @param handler The handler that intercepts/overrides method calls.
171      */
172     public Driver JavaDoc createDriver(InvocationHandler JavaDoc handler) {
173         return (Driver JavaDoc) Proxy.newProxyInstance(
174             handler.getClass().getClassLoader(),
175             driverClass,
176             handler);
177     }
178
179     /**
180      * Creates a new proxy <code>PreparedStatement</code> object.
181      * @param handler The handler that intercepts/overrides method calls.
182      */
183     public PreparedStatement JavaDoc createPreparedStatement(InvocationHandler JavaDoc handler) {
184         return (PreparedStatement JavaDoc) Proxy.newProxyInstance(
185             handler.getClass().getClassLoader(),
186             preparedStatementClass,
187             handler);
188     }
189
190     /**
191      * Creates a new proxy <code>ResultSet</code> object.
192      * @param handler The handler that intercepts/overrides method calls.
193      */
194     public ResultSet JavaDoc createResultSet(InvocationHandler JavaDoc handler) {
195         return (ResultSet JavaDoc) Proxy.newProxyInstance(
196             handler.getClass().getClassLoader(),
197             resultSetClass,
198             handler);
199     }
200
201     /**
202      * Creates a new proxy <code>ResultSetMetaData</code> object.
203      * @param handler The handler that intercepts/overrides method calls.
204      */
205     public ResultSetMetaData JavaDoc createResultSetMetaData(InvocationHandler JavaDoc handler) {
206         return (ResultSetMetaData JavaDoc) Proxy.newProxyInstance(
207             handler.getClass().getClassLoader(),
208             metaClass,
209             handler);
210     }
211
212     /**
213      * Creates a new proxy <code>Statement</code> object.
214      * @param handler The handler that intercepts/overrides method calls.
215      */
216     public Statement JavaDoc createStatement(InvocationHandler JavaDoc handler) {
217         return (Statement JavaDoc) Proxy.newProxyInstance(
218             handler.getClass().getClassLoader(),
219             statementClass,
220             handler);
221     }
222
223 }
224
Popular Tags