001: /**
002: * Copyright 2004-2005 jManage.org
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */package org.jmanage.core.services;
016:
017: import org.jmanage.core.remote.client.HttpServiceProxy;
018:
019: import java.util.Map;
020: import java.util.Hashtable;
021: import java.lang.reflect.Proxy;
022:
023: /**
024: * ServiceFactory is used to create instance of Service interfaces. This
025: * factory needs to be initialized by calling the <code>init()</code> method.
026: * The factory runs in local or remote mode. When in local mode, local
027: * Service objects are created. When running in remote mode, an instance
028: * of HttpServiceProxy is returned, which uses java serialization over HTTP
029: * to talk to the jmanage web server.
030: * <p>
031: * When creating the local instance of Service interfaces, ServiceFactory
032: * determines the implementation class name by appending "Impl" to the
033: * Service interface name..
034: *
035: * @see org.jmanage.core.remote.client.HttpServiceProxy
036: * date: Jan 18, 2005
037: * @author Rakesh Kalra
038: */
039: public class ServiceFactory {
040:
041: private static Map serviceClassToObjectMap = new Hashtable();
042:
043: public static final Integer MODE_LOCAL = new Integer(0);
044: public static final Integer MODE_REMOTE = new Integer(1);
045:
046: private static Integer mode;
047:
048: /**
049: * Initializes the ServiceFactory. This method can only be called once.
050: * Initializing the factory in local mode, will result in local service
051: * method calls. Initializing the factory in remove mode, will result in
052: * remote service method calls.
053: *
054: * @param mode the mode this factory should run in: local or remote
055: */
056: public static void init(Integer mode) {
057: assert ServiceFactory.mode == null : "ServiceFactory already initialized";
058: assert mode.equals(MODE_LOCAL) || mode.equals(MODE_REMOTE) : "Invalid mode:"
059: + mode;
060: ServiceFactory.mode = mode;
061: }
062:
063: /**
064: * Gets the service object based on the factory mode.
065: *
066: * @param serviceInterface the Service interface.
067: * @return instance of service interface
068: */
069: public static Object getService(Class serviceInterface) {
070: Object service = serviceClassToObjectMap.get(serviceInterface);
071: if (service == null) {
072: if (mode.equals(MODE_LOCAL)) {
073: service = createService(serviceInterface);
074: } else {
075: service = createServiceProxy(serviceInterface);
076: }
077: serviceClassToObjectMap.put(serviceInterface, service);
078: }
079: return service;
080: }
081:
082: public static ConfigurationService getConfigurationService() {
083: return (ConfigurationService) getService(ConfigurationService.class);
084: }
085:
086: public static AuthService getAuthService() {
087: return (AuthService) getService(AuthService.class);
088: }
089:
090: public static MBeanService getMBeanService() {
091: return (MBeanService) getService(MBeanService.class);
092: }
093:
094: public static AlertService getAlertService() {
095: return (AlertService) getService(AlertService.class);
096: }
097:
098: private static Object createService(Class serviceClass) {
099: final String implClassName = serviceClass.getName() + "Impl";
100: try {
101: Class clazz = Class.forName(implClassName);
102: return clazz.newInstance();
103: } catch (ClassNotFoundException e) {
104: throw new RuntimeException("Service impl. not found:"
105: + implClassName, e);
106: } catch (InstantiationException e) {
107: throw new RuntimeException(
108: "Service impl.:" + implClassName, e);
109: } catch (IllegalAccessException e) {
110: throw new RuntimeException(
111: "Service impl.:" + implClassName, e);
112: }
113: }
114:
115: private static Object createServiceProxy(Class serviceClass) {
116: return Proxy.newProxyInstance(serviceClass.getClassLoader(),
117: new Class[] { serviceClass }, new HttpServiceProxy());
118: }
119: }
|