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: SessionFactory.java 1970 2007-10-16 11:49:25Z benoitf $
023: * --------------------------------------------------------------------------
024: */package org.ow2.easybeans.container.session;
025:
026: import org.ow2.easybeans.api.EZBContainer;
027: import org.ow2.easybeans.api.FactoryException;
028: import org.ow2.easybeans.api.bean.EasyBeansSB;
029: import org.ow2.easybeans.api.bean.info.IBeanInfo;
030: import org.ow2.easybeans.api.container.EZBSessionContext;
031: import org.ow2.easybeans.api.pool.PoolException;
032: import org.ow2.easybeans.container.AbsFactory;
033: import org.ow2.easybeans.container.info.SessionBeanInfo;
034: import org.ow2.easybeans.rpc.api.EJBRequest;
035: import org.ow2.easybeans.rpc.api.EJBResponse;
036: import org.ow2.util.log.Log;
037: import org.ow2.util.log.LogFactory;
038:
039: /**
040: * This class manages the session bean and its creation/lifecycle.
041: * @param <PoolType> the type of bean instance.
042: * @author Florent Benoit
043: */
044: public abstract class SessionFactory<PoolType extends EasyBeansSB<PoolType>>
045: extends AbsFactory<PoolType> {
046:
047: /**
048: * Logger.
049: */
050: private static Log logger = LogFactory.getLog(SessionFactory.class);
051:
052: /**
053: * Session Desc (deployment info).
054: */
055: private SessionBeanInfo sessionBeanInfo = null;
056:
057: /**
058: * Builds a new factory with a given name and its container.
059: * @param className name of this factory (name of class that is managed)
060: * @param container the root component of this factory.
061: * @throws FactoryException if class can't be loaded.
062: */
063: public SessionFactory(final String className,
064: final EZBContainer container) throws FactoryException {
065: super (className, container);
066: }
067:
068: /**
069: * Stops the factory.
070: */
071: @Override
072: public void stop() {
073: super .stop();
074:
075: // remove pool
076: try {
077: getPool().stop();
078: } catch (PoolException e) {
079: logger.error("Problem when stopping the factory", e);
080: }
081:
082: }
083:
084: /**
085: * @return information of the current bean.
086: */
087: public IBeanInfo getBeanInfo() {
088: return sessionBeanInfo;
089: }
090:
091: /**
092: * @return information of the current bean.
093: */
094: public SessionBeanInfo getSessionBeanInfo() {
095: return sessionBeanInfo;
096: }
097:
098: /**
099: * Sets the information object for a session bean.
100: * @param sessionBeanInfo information on the bean.
101: */
102: public void setSessionBeanInfo(final SessionBeanInfo sessionBeanInfo) {
103: this .sessionBeanInfo = sessionBeanInfo;
104: }
105:
106: /**
107: * Gets a new ID or a null value.
108: * @param beanId given id.
109: * @return new id
110: */
111: protected abstract Long getId(final Long beanId);
112:
113: /**
114: * Creates an instance with the given hint.
115: * @param clue a clue given by the Pool. Could be null.
116: * @throws PoolException if instance cannot be created.
117: * @return the created instance.
118: */
119: public PoolType create(final Long clue) throws PoolException {
120: PoolType instance = null;
121: ClassLoader oldClassLoader = Thread.currentThread()
122: .getContextClassLoader();
123: Thread.currentThread().setContextClassLoader(
124: getContainer().getClassLoader());
125: try {
126: try {
127: instance = getBeanClass().newInstance();
128: } catch (InstantiationException e) {
129: throw new PoolException("Cannot create a new instance",
130: e);
131: } catch (IllegalAccessException e) {
132: throw new PoolException("Cannot create a new instance",
133: e);
134: } catch (Exception e) {
135: throw new PoolException("Cannot create a new instance",
136: e);
137: }
138: } finally {
139: Thread.currentThread()
140: .setContextClassLoader(oldClassLoader);
141: }
142:
143: // Set the factory
144: instance.setEasyBeansFactory(this );
145:
146: // Init the session Context
147: EZBSessionContext<PoolType> sessionContext = new EasyBeansSessionContext<PoolType>(
148: instance);
149: instance.setEasyBeansContext(sessionContext);
150:
151: oldClassLoader = Thread.currentThread().getContextClassLoader();
152: Thread.currentThread().setContextClassLoader(
153: getContainer().getClassLoader());
154: try {
155: // Call injection
156: injectResources(instance);
157:
158: // post construct callback
159: instance.postConstructEasyBeansLifeCycle();
160: } finally {
161: Thread.currentThread()
162: .setContextClassLoader(oldClassLoader);
163: }
164:
165: return instance;
166: }
167:
168: /**
169: * A request comes to the bean factory and needs to be handled.<br>
170: * A response is done which contains the answer.
171: * @param request the EJB request.
172: * @return a response that have been processed by the factory.
173: */
174: @Override
175: public EJBResponse rpcInvoke(final EJBRequest request) {
176: // get hash of the request
177: long hash = request.getMethodHash();
178:
179: // Get Args (use context classloader for the Serialization)
180: Object[] args = null;
181: ClassLoader oldClassLoader = Thread.currentThread()
182: .getContextClassLoader();
183: Thread.currentThread().setContextClassLoader(
184: getContainer().getClassLoader());
185: try {
186: args = request.getMethodArgs();
187: } finally {
188: Thread.currentThread()
189: .setContextClassLoader(oldClassLoader);
190: }
191:
192: // call the method
193: return localCall(hash, args, request.getBeanId());
194:
195: }
196:
197: /**
198: * Gets a bean for the given id.
199: * @param beanId id of the expected bean.
200: * @return a Stateless bean.
201: * @throws IllegalArgumentException if bean is not found.
202: */
203: protected abstract PoolType getBean(final Long beanId)
204: throws IllegalArgumentException;
205:
206: /**
207: * Do a local call on a method of this factory.
208: * @param hash the hash of the method to execute.
209: * @param methodArgs the arguments of the method
210: * @param beanId the id of the bean that we want (stateful).
211: * @return response container new id (if any) and value.
212: */
213: public abstract EJBResponse localCall(final long hash,
214: final Object[] methodArgs, final Long beanId);
215:
216: }
|