001: /**
002: * EasyBeans
003: * Copyright (C) 2006 Bull S.A.S.
004: * Contact: easybeans@ow2.org
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation; either
009: * version 2.1 of the License, or any later version.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: *
016: * You should have received a copy of the GNU Lesser General Public
017: * License along with this library; if not, write to the Free Software
018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
019: * USA
020: *
021: * --------------------------------------------------------------------------
022: * $Id: LocalCallFactory.java 2010 2007-10-26 13:19:08Z benoitf $
023: * --------------------------------------------------------------------------
024: */package org.ow2.easybeans.proxy.factory;
025:
026: import java.lang.reflect.Proxy;
027: import java.util.Hashtable;
028:
029: import javax.naming.Context;
030: import javax.naming.Name;
031: import javax.naming.RefAddr;
032: import javax.naming.Reference;
033: import javax.naming.spi.ObjectFactory;
034:
035: import org.ow2.easybeans.api.EZBContainerException;
036: import org.ow2.easybeans.proxy.client.LocalCallInvocationHandler;
037: import org.ow2.easybeans.proxy.reference.AbsCallRef;
038: import org.ow2.easybeans.proxy.reference.LocalCallRef;
039:
040: /**
041: * Factory creating an EJB proxy for local calls.
042: * @author Florent Benoit.
043: */
044: public class LocalCallFactory implements ObjectFactory {
045:
046: /**
047: * @return an instance of a proxy (an EJB) that handle local calls.
048: * @param obj the reference containing data to build instance
049: * @param name Name of context, relative to ctx, or null.
050: * @param nameCtx Context relative to which 'name' is named.
051: * @param environment Environment to use when creating the context *
052: * @throws Exception if this object factory encountered an exception while
053: * attempting to create an object, and no other object factories are
054: * to be tried.
055: */
056: public Object getObjectInstance(final Object obj, final Name name,
057: final Context nameCtx, final Hashtable<?, ?> environment)
058: throws Exception {
059: if (obj instanceof Reference) {
060: Reference ref = (Reference) obj;
061:
062: // get the embeddedID, getContainerId(), getFactoryName()
063: RefAddr embeddedIDAddr = ref.get(LocalCallRef.EMBEDDED_ID);
064: RefAddr containerIDAddr = ref.get(AbsCallRef.CONTAINER_ID);
065: RefAddr factoryNameAddr = ref.get(AbsCallRef.FACTORY_NAME);
066: RefAddr itfClassNameAddr = ref
067: .get(AbsCallRef.INTERFACE_NAME);
068: RefAddr useIDAddr = ref.get(AbsCallRef.USE_ID);
069:
070: Integer embeddedID = Integer
071: .valueOf((String) embeddedIDAddr.getContent());
072: String containerID = (String) containerIDAddr.getContent();
073: String factoryName = (String) factoryNameAddr.getContent();
074: String itfClassName = (String) itfClassNameAddr
075: .getContent();
076: boolean useID = Boolean.valueOf(
077: (String) useIDAddr.getContent()).booleanValue();
078:
079: // Build new Handler
080: LocalCallInvocationHandler handler = buildLocalHandler(
081: embeddedID, containerID, factoryName, useID);
082:
083: // Get current classloader
084: ClassLoader classLoader = Thread.currentThread()
085: .getContextClassLoader();
086:
087: // load class
088: Class<?> clz = null;
089: try {
090: clz = classLoader.loadClass(itfClassName);
091: } catch (ClassNotFoundException e) {
092: throw new EZBContainerException(
093: "Cannot find the class '" + itfClassName
094: + "' in Classloader '" + classLoader
095: + "'.", e);
096: }
097:
098: // set the interface class
099: handler.setInterfaceClass(clz);
100:
101: return Proxy.newProxyInstance(classLoader,
102: new Class[] { clz }, handler);
103: }
104: throw new IllegalStateException(
105: "Can only build object with a reference");
106: }
107:
108: /**
109: * Build a new Invocation handler.
110: * @param embeddedID the Embedded server ID.
111: * @param containerId the id of the container that will be called on the
112: * remote side.
113: * @param factoryName the name of the remote factory.
114: * @param useID true if all instance build with this ref are unique
115: * (stateful), false if it references the same object (stateless)
116: * @return an instance of a local handler
117: */
118: protected LocalCallInvocationHandler buildLocalHandler(
119: final Integer embeddedID, final String containerId,
120: final String factoryName, final boolean useID) {
121: return new LocalCallInvocationHandler(embeddedID, containerId,
122: factoryName, useID);
123: }
124: }
|