objectfactoryimpl.java

来自「主要是对串口驱动的的一些控制源码！！！ 在下载javacomm20-win32」· Java 代码 · 共 379 行

/**
 * $Log: ObjectFactoryImpl.java,v $
 * Revision 1.3  2003/02/03 14:16:03  mwulff
 * changed ExceptionHandling; differentiation between local and remote errors
 *
 * Revision 1.2  2003/02/02 13:20:35  mwulff
 * the method name for FindByPrimaryKey-Requests is now explicitly set
 *
 * Revision 1.1  2003/01/16 13:12:40  mwulff
 * initial version
 *
 * Revision 1.3  2002/12/20 18:52:25  mwulff
 * no message
 *
 * Revision 1.2  2002/12/15 16:55:07  mwulff
 * adjusted to reorganisation of the client logging system
 *
 * Revision 1.1  2002/12/13 20:08:22  mwulff
 * no message
 *
 * Revision 1.7  2002/12/09 18:08:05  mwulff
 * no message
 *
 * Revision 1.6  2002/12/08 11:23:00  mwulff
 * no message
 *
 * Revision 1.5  2002/12/05 21:33:50  mwulff
 * reengineering of the complete communication component
 *
 * Revision 1.4  2002/12/01 21:40:16  mwulff
 * adapted to changes in ResourceManager
 *
 * Revision 1.3  2002/12/01 13:02:14  mwulff
 * accomodated to ClientResourceManager and ClientLoggingManager,
 * that are now implemented as singleton
 *
 * Revision 1.2  2002/11/30 11:53:07  mwulff
 * no message
 *
 * Revision 1.1  2002/11/22 16:42:45  mwulff
 * moved
 *
 * Revision 1.8  2002/11/21 11:07:43  mwulff
 * removed bug: method createObject(Class, String) called itself, instead of
 * createObject(Class, String, Object[])
 *
 * Revision 1.7  2002/11/17 17:58:28  mwulff
 * -in all methods, the class name of the inferface implemented by the proxy is
 * nolonger given as String. A class object is given, from wich the name of the
 * interface can be retrieved by class.getName();
 *
 * -added no parameter methods:
 * createObject(Class, String)
 * createEJB(Class, String)
 *
 * -added method findByPrimaryKey(Class, Object[], String)
 *
 * Revision 1.6  2002/11/15 18:23:55  mwulff
 * - addes support for ejb creation
 *
 * Revision 1.5  2002/11/08 19:23:41  mwulff
 * is now responsible for compression check
 * of the DeflaterByteArrayOutputStream
 *
 * Revision 1.4  2002/11/07 16:30:29  mwulff
 * rearranged logging statements
 *
 * Revision 1.3  2002/11/05 19:49:14  mwulff
 * class is now inherited from CommunicationHandler and therefore supports
 * transfering local LoggingEvents to the server
 *
 * Revision 1.2  2002/11/03 21:06:20  mwulff
 * added support for handling compressed and uncompressed stream
 *
 * Revision 1.1.1.1  2002/10/23 14:13:23  mwulff
 * initial checkin
 *
 */
package de.fhm.jkf.comm.cl;

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import de.fhm.jkf.comm.clsv.CreationRequest;
import de.fhm.jkf.comm.clsv.EJBCreationRequest;
import de.fhm.jkf.comm.clsv.EJBFindByPrimKeyRequest;
import de.fhm.jkf.comm.clsv.EJBFindByXXXRequest;
import de.fhm.jkf.comm.clsv.EJBFindByXXXResponse;
import de.fhm.jkf.comm.clsv.RemoteObjectCreationException;
import de.fhm.jkf.comm.clsv.RemoteObjectID;
import de.fhm.jkf.comm.clsv.Response;
import de.fhm.jkf.resource.cl.JKFClientLogger;
/**
 * @author marten wulff
 * 
 * <br><br><center><table border="1" width="80%"><hr>
 * <strong><a href="http://jkf.sourceforge.net">The JKF Project</a></strong>
 * <p>
 * Copyright (C) 2002 by Marten Wulff
 * <p>
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * <p>
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * <p>
 * You should have received a copy of the <a href="http://www.gnu.org/copyleft/lesser.html">
 * GNU Lesser General Public License</a> along with this library; if not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA  02111-1307  USA
 * <hr></table></center>
 * 
 * 
 * ObjectFactoryImpl is the entrypoint for all applications, that 
 * wants to make use off the jkf communication framework.<p>
 * 
 * ObjectFactoryImpl provides methods for creation of remote java objects.<br>
 * The create-methods return a Proxy, that manages the communication<br>
 * between client and the remote object, the Proxy is responsible for.<p>
 * 
 * The remote object can be a simple java class or an ejb, running <br>
 * running on a different or the same application server on which <br>
 * the JKF Framework is installed.<p>
 * 
 * @see ProxyStub
 * @stereotype implementationClass
 */
final class ObjectFactoryImpl extends CommunicationHandler implements ObjectFactory {
	
	ObjectFactoryImpl() {
		super();
	}
	
	/**
	 * Method for creating a simple remote java object<br>
	 * without constructor parameters.
	 * 
	 * @param interfaceClass  
	 * @param remoteClassName
	 * 
	 * @return Object  a Proxy instance that must be casted <br>
	 * 					to the desired Interface
	 */
	public Object createObject(
		Class interfaceClass,
		String remoteClassName)
		throws RemoteObjectCreationException {
		return createObject(
			interfaceClass,
			remoteClassName,
			null);
	}

	public Object createObject(
		Class interfaceClass,
		String remoteClassName,
		Object[] params)
		throws RemoteObjectCreationException {

		if (JKFClientLogger.isDebugEnabled()) {
		JKFClientLogger.debug(
			"trying to create new remote object [ "
				+ remoteClassName
				+ " ] ...");
		}

		Object generatedObject = null;
		Response response = null;

		CreationRequest request = new CreationRequest();
		request.setClassName(remoteClassName);
		request.setParams(params);

		try {
			prepareConnection(request);				
			this.compressionHandler.sendObject(request);
			response = (Response) this.compressionHandler.receiveObject();

			followUpConnection(response);			
			
			generatedObject =
				Proxy.newProxyInstance(
					Class.forName(interfaceClass.getName()).getClassLoader(),
					new Class[] { Class.forName(interfaceClass.getName())},
					new ProxyStub(response.getRemoteObjectId()));

			if (JKFClientLogger.isDebugEnabled()) {
				JKFClientLogger.debug(
					"remote object " + remoteClassName + " created... !");
			}

		} catch (Exception ex) {
			throw new RemoteObjectCreationException(
				"[LocalError] creating Object", ex);
		}

		// check if any exceptions on server side occured
		if (response.errorOccured()) {
			Exception ex = response.getRemoteException();
			throw new RemoteObjectCreationException(
				"[RemoteError] creating Object", ex);
		}

		return generatedObject;
	}

	public Object createEJB(Class interfaceClass, String jndiName)
		throws RemoteObjectCreationException {

		return createEJB(interfaceClass, null, jndiName);
	}

	public Object createEJB(
		Class interfaceClass,
		Object[] params,
		String jndiName)
		throws RemoteObjectCreationException {

		Object generatedObject = null;
		Response response = null;

		EJBCreationRequest request = new EJBCreationRequest();
		request.setJndiName(jndiName);
		request.setParams(params);
		request.setMethodName("create");

		try {	
			prepareConnection(request);				
			this.compressionHandler.sendObject(request);
			response = (Response) this.compressionHandler.receiveObject();

			followUpConnection(response);


			generatedObject =
				Proxy.newProxyInstance(
					Class.forName(interfaceClass.getName()).getClassLoader(),
					new Class[] { Class.forName(interfaceClass.getName())},
					new ProxyStub(response.getRemoteObjectId()));

			if (JKFClientLogger.isDebugEnabled()) {
				JKFClientLogger.debug(
					"remote object "
						+ interfaceClass.getName()
						+ " created... !");
			}

		} catch (Exception ex) {
			throw new RemoteObjectCreationException(
				"[LocalError] creating EJB", ex);
		}
		
		// check if any exceptions on server side occured
		if (response.errorOccured()) {
			Exception ex = response.getRemoteException();
			throw new RemoteObjectCreationException(
				"[RemoteError] creating EJB", ex);
		}


		return generatedObject;
	}

	/**
	 * Method for finding an EJB by its primary key.
	 */
	public Object findByPrimaryKey(
		Class interfaceClass,
		Object[] params,
		String jndiName)
		throws RemoteObjectCreationException {

		Object generatedObject = null;
		Response response = null;

		EJBFindByPrimKeyRequest request = new EJBFindByPrimKeyRequest();
		request.setJndiName(jndiName);
		request.setMethodName("findByPrimaryKey");
		request.setParams(params);

		try {	
			prepareConnection(request);				
			this.compressionHandler.sendObject(request);
			response = (Response) this.compressionHandler.receiveObject();

			followUpConnection(response);
											
			generatedObject =
				Proxy.newProxyInstance(
					Class.forName(interfaceClass.getName()).getClassLoader(),
					new Class[] { Class.forName(interfaceClass.getName())},
					new ProxyStub(response.getRemoteObjectId()));

			if (JKFClientLogger.isDebugEnabled()) {
				JKFClientLogger.debug(
					"remote object "
						+ interfaceClass.getName()
						+ " found ... !");
			}

		} catch (Exception ex) {
			throw new RemoteObjectCreationException(
				"[LocalError] finding EJB by PK", ex);
		}
		
		// check if any exceptions on server side occured
		if (response.errorOccured()) {
			Exception ex = response.getRemoteException();
			throw new RemoteObjectCreationException(
				"[RemoteError] finding EJB by PK", ex);
		}


		return generatedObject;
	}	
	
	public Collection findByXXX(
		Class interfaceClass,
		Object[] params,
		String jndiName,
		String method) 
		throws RemoteObjectCreationException {

		ArrayList generatedObjects = new ArrayList();
		EJBFindByXXXResponse response = null;

		EJBFindByXXXRequest request = new EJBFindByXXXRequest();
		request.setJndiName(jndiName);
		request.setParams(params);
		request.setMethodName(method);

		try {	
			prepareConnection(request);				
			this.compressionHandler.sendObject(request);
			response = (EJBFindByXXXResponse) this.compressionHandler.receiveObject();

			followUpConnection(response);
								
			Collection allRemoteIds= (Collection)response.getRemoteObjectIds();
			
			Iterator it = allRemoteIds.iterator();
			while(it.hasNext()) {
				generatedObjects.add(
					Proxy.newProxyInstance(
						Class.forName(interfaceClass.getName()).getClassLoader(),
						new Class[] { Class.forName(interfaceClass.getName())},
						new ProxyStub((RemoteObjectID)it.next())));
			}

			if (JKFClientLogger.isDebugEnabled()) {
				JKFClientLogger.debug(
					"remote object "
						+ interfaceClass.getName()
						+ " found ... !");
			}

		} catch (Exception ex) {
			throw new RemoteObjectCreationException(
				"[LocalError] finding EJB by: " + request.getMethodName(), ex);
		}

		// check if any exceptions on server side occured
		if (response.errorOccured()) {
			Exception ex = response.getRemoteException();
			throw new RemoteObjectCreationException(
				"[RemoteError] finding EJB by: " + request.getMethodName(), ex);
		}

		return generatedObjects;
		
	}
}