001: /*
002: * CoadunationUtil: The coadunation util library.
003: * Copyright (C) 2007 Rift IT Contracting
004: *
005: * This library is free software; you can redistribute it and/or
006: * modify it under the terms of the GNU Lesser General Public
007: * License as published by the Free Software Foundation; either
008: * version 2.1 of the License, or (at your option) any later version.
009: *
010: * This library is distributed in the hope that it will be useful,
011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013: * Lesser General Public License for more details.
014: *
015: * You should have received a copy of the GNU Lesser General Public
016: * License along with this library; if not, write to the Free Software
017: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
018: *
019: * ConnectionManager.java
020: */
021:
022: // package
023: package com.rift.coad.util.connection;
024:
025: // java imports
026: import java.util.Map;
027: import java.util.HashMap;
028: import java.util.concurrent.ConcurrentHashMap;
029: import javax.naming.Context;
030: import javax.naming.InitialContext;
031:
032: // logging import
033: import org.apache.log4j.Logger;
034:
035: /**
036: * This object is responsible for managing the connections to various JNDI bound
037: * objects. This object assumes it is using a Coadunation based JNDI name
038: * service.
039: *
040: * @author Brett Chaldecott
041: */
042: public class ConnectionManager {
043:
044: // class singleton methods
045: private static ConnectionManager singleton = null;
046: private static Map singletonMap = new ConcurrentHashMap();
047:
048: // the logger reference
049: protected static Logger log = Logger
050: .getLogger(ConnectionManager.class.getName());
051:
052: // private member variables
053: private Context context = null;
054: private Map lookupCache = new ConcurrentHashMap();
055: private Map synchKeyCache = new HashMap();
056:
057: /**
058: * Creates a new instance of ConnectionManager
059: */
060: private ConnectionManager() throws ConnectionException {
061: try {
062: context = new InitialContext();
063: } catch (Exception ex) {
064: log.error("Failed init the connection manager : "
065: + ex.getMessage(), ex);
066: }
067: }
068:
069: /**
070: * The contructor of the context manager.
071: *
072: * @param context The context that will be used to lookup names.
073: */
074: private ConnectionManager(Context context) {
075: this .context = context;
076: }
077:
078: /**
079: * This method is responsible for returning a reference to the connection
080: * manager singleton instance.
081: *
082: * @return The reference to the connection manager.
083: * @exception ConnectionException
084: */
085: public synchronized static ConnectionManager getInstance()
086: throws ConnectionException {
087: if (singleton == null) {
088: singleton = new ConnectionManager();
089: }
090: return singleton;
091: }
092:
093: /**
094: * This method returns the connection manager instance for the context.
095: *
096: * @return The reference to the connection manager.
097: * @param context The reference to the context object.
098: * @exception ConnectionException
099: */
100: public static ConnectionManager getInstance(Context context)
101: throws ConnectionException {
102: synchronized (context) {
103: if (!singletonMap.containsKey(context)) {
104: singletonMap.put(context, new ConnectionManager());
105: }
106: return (ConnectionManager) singletonMap.get(context);
107: }
108: }
109:
110: /**
111: * This method returns a connection to the the requested object.
112: *
113: * @param type The class type for the return result.
114: * @param jndiURL The jndi url of the object.
115: * @exception ConnectionException
116: * @exception java.lang.ClassCastException
117: */
118: public Object getConnection(Class type, String jndiURL)
119: throws ConnectionException, java.lang.ClassCastException {
120: Object syncEntry = getSyncKey(jndiURL);
121: synchronized (syncEntry) {
122: Connection connection = (Connection) lookupCache
123: .get(jndiURL);
124: if (connection == null) {
125: if (RMIConnection.isRMIConnection(jndiURL)) {
126: connection = new RMIConnection(context, jndiURL);
127: } else {
128: connection = new ProxyConnection(context, jndiURL);
129: }
130: lookupCache.put(jndiURL, connection);
131: }
132: return connection.getConnection(type);
133: }
134: }
135:
136: /**
137: * This method returns the object to synchronize the connection on.
138: *
139: * @return The object to synchronize the connection on.
140: * @param name The name of the object to synchronize the object on.
141: */
142: private synchronized Object getSyncKey(String name) {
143: Object entry = synchKeyCache.get(name);
144: if (entry != null) {
145: return entry;
146: }
147: entry = new String(name);
148: synchKeyCache.put(name, entry);
149: return entry;
150: }
151: }
|