001: /*
002:
003: Derby - Class org.apache.derby.jdbc.ClientDataSource40
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to You under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.jdbc;
023:
024: import java.sql.SQLException;
025: import javax.sql.DataSource;
026: import org.apache.derby.client.am.ClientMessageId;
027: import org.apache.derby.client.am.SqlException;
028: import org.apache.derby.shared.common.reference.SQLState;
029:
030: /**
031: * ClientDataSource40 is a simple data source implementation
032: * that can be used for establishing connections in a
033: * non-pooling, non-distributed environment.
034: * The class ClientConnectionPoolDataSource40 can be used in a connection pooling environment,
035: * and the class ClientXADataSource40 can be used in a distributed, and pooling
036: * environment. Use these DataSources if your application runs under
037: * JDBC4.0. Use the corresponding ClientDataSource, ClientConnectionPoolDataSource, and
038: * ClientXADataSource classes if
039: * your application runs in the following environments:
040: * <p/>
041: * <UL>
042: * <LI> JDBC 3.0 - Java 2 - JDK 1.4, J2SE 5.0
043: * <LI> JDBC 2.0 - Java 2 - JDK 1.2,1.3
044: * </UL>
045: *
046: * <p>The example below registers a DNC data source object with a JNDI naming service.
047: * <pre>
048: * org.apache.derby.client.ClientDataSource40 dataSource = new org.apache.derby.client.ClientDataSource40 ();
049: * dataSource.setServerName ("my_derby_database_server");
050: * dataSource.setDatabaseName ("my_derby_database_name");
051: * javax.naming.Context context = new javax.naming.InitialContext();
052: * context.bind ("jdbc/my_datasource_name", dataSource);
053: * </pre>
054: * The first line of code in the example creates a data source object.
055: * The next two lines initialize the data source's
056: * properties. Then a Java object that references the initial JNDI naming
057: * context is created by calling the
058: * InitialContext() constructor, which is provided by JNDI.
059: * System properties (not shown) are used to tell JNDI the
060: * service provider to use. The JNDI name space is hierarchical,
061: * similar to the directory structure of many file
062: * systems. The data source object is bound to a logical JNDI name
063: * by calling Context.bind(). In this case the JNDI name
064: * identifies a subcontext, "jdbc", of the root naming context
065: * and a logical name, "my_datasource_name", within the jdbc
066: * subcontext. This is all of the code required to deploy
067: * a data source object within JNDI. This example is provided
068: * mainly for illustrative purposes. We expect that developers
069: * or system administrators will normally use a GUI tool to
070: * deploy a data source object.
071: * <p/>
072: * Once a data source has been registered with JNDI,
073: * it can then be used by a JDBC application, as is shown in the
074: * following example.
075: * <pre>
076: * javax.naming.Context context = new javax.naming.InitialContext ();
077: * javax.sql.DataSource dataSource = (javax.sql.DataSource) context.lookup ("jdbc/my_datasource_name");
078: * java.sql.Connection connection = dataSource.getConnection ("user", "password");
079: * </pre>
080: * The first line in the example creates a Java object
081: * that references the initial JNDI naming context. Next, the
082: * initial naming context is used to do a lookup operation
083: * using the logical name of the data source. The
084: * Context.lookup() method returns a reference to a Java Object,
085: * which is narrowed to a javax.sql.DataSource object. In
086: * the last line, the DataSource.getConnection() method
087: * is called to produce a database connection.
088: * <p/>
089: * This simple data source subclass of ClientBaseDataSource maintains
090: * it's own private <code>password</code> property.
091: * <p/>
092: * The specified password, along with the user, is validated by DERBY.
093: * This property can be overwritten by specifing
094: * the password parameter on the DataSource.getConnection() method call.
095: * <p/>
096: * This password property is not declared transient, and therefore
097: * may be serialized to a file in clear-text, or stored
098: * to a JNDI server in clear-text when the data source is saved.
099: * Care must taken by the user to prevent security
100: * breaches.
101: * <p/>
102: */
103: public class ClientDataSource40 extends ClientDataSource {
104:
105: public ClientDataSource40() {
106: super ();
107: }
108:
109: /**
110: * Returns false unless <code>interfaces</code> is implemented
111: *
112: * @param interfaces a Class defining an interface.
113: * @return true if this implements the interface or
114: * directly or indirectly wraps an object
115: * that does.
116: * @throws java.sql.SQLException if an error occurs while determining
117: * whether this is a wrapper for an object
118: * with the given interface.
119: */
120: public boolean isWrapperFor(Class<?> interfaces)
121: throws SQLException {
122: return interfaces.isInstance(this );
123: }
124:
125: /**
126: * Returns <code>this</code> if this class implements the interface
127: *
128: * @param interfaces a Class defining an interface
129: * @return an object that implements the interface
130: * @throws java.sql.SQLExption if no object if found that implements the
131: * interface
132: */
133: public <T> T unwrap(java.lang.Class<T> interfaces)
134: throws SQLException {
135: try {
136: return interfaces.cast(this );
137: } catch (ClassCastException cce) {
138: throw new SqlException(null, new ClientMessageId(
139: SQLState.UNABLE_TO_UNWRAP), interfaces)
140: .getSQLException();
141: }
142: }
143:
144: }
|