1 /***
2 * JFoxSOAF, Service-Oriented Application Framework
3 *
4 * Copyright (C) www.huihoo.org
5 *
6 * Distributable under GNU LGPL For more information, please visit:
7 * http://www.huihoo.org/jfox/jfoxsoaf
8 */
9
10 package org.huihoo.jfox.soaf.container;
11
12 import java.io.IOException;
13 import java.io.InputStream;
14 import java.io.InputStreamReader;
15
16 import javax.management.MBeanServer;
17
18 import org.huihoo.jfox.soaf.exception.ServiceConfigurationException;
19 import org.huihoo.jfox.soaf.schema.config.Configuration;
20 import org.huihoo.jfox.soaf.util.Globals;
21 import org.huihoo.jfox.soaf.util.resource.ResourceHelper;
22 import org.picocontainer.PicoException;
23 import org.picocontainer.PicoRegistrationException;
24
25 /***
26 * <p>
27 * The ServiceFactory is a singleton wrapper on the service container instance.
28 * </p>
29 *
30 * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
31 * @version $Revision: 1.8 $ $Date: 2004/10/28 05:12:04 $
32 * @version Revision: 1.0
33 */
34
35 public class ServiceFactory {
36
37 private static ServiceFactory serviceFactory;
38
39 private ClassLoader cl = Thread.currentThread().getContextClassLoader();
40
41 private InputStream is = null;
42
43 private InputStreamReader isr = null;
44
45 private ServiceLoadProxy serviceLoadProxy;
46
47 private ServiceContainer serviceContainer = ServiceContainer.getInstance();
48
49 private ManageableServiceContainer manageableServiceContainer = ManageableServiceContainer
50 .getInstance();
51
52 /***
53 * Singleton instance.
54 */
55 public static synchronized ServiceFactory getInstance() {
56 if (serviceFactory == null) {
57 serviceFactory = new ServiceFactory();
58 }
59
60 if (!serviceFactory.serviceLoadProxy.isServiceLoaded()) {
61 serviceFactory.constructServices();
62 }
63 return serviceFactory;
64 }
65
66 /***
67 * Default Constructor.
68 */
69 public ServiceFactory() {
70
71 serviceLoadProxy = new ServiceLoadProxy();
72 }
73
74 /***
75 * Lookup service by serviceKey
76 *
77 * @param componentKey
78 * @return Service Object
79 */
80 public synchronized Object getService(Object serviceKey)
81 throws PicoException, ServiceConfigurationException {
82 return serviceContainer.getService(serviceKey);
83 }
84
85 /***
86 * Lookup service by serviceType
87 *
88 * @param componentKey
89 * @return Service Object
90 */
91 public synchronized Object getService(Class serviceType)
92 throws PicoException {
93 return serviceContainer.getServiceOfType(serviceType);
94 }
95
96 /***
97 * Construct all default services from service configration files.
98 *
99 * @throws org.huihoo.jfox.soaf.exception.ServiceConfigurationException
100 */
101 private void constructServices() throws ServiceConfigurationException {
102 try {
103 serviceLoadProxy.loadConfig(loadServiceConfigration());
104 } catch (Throwable e) {
105 e.printStackTrace();
106 throw new ServiceConfigurationException(e);
107 }
108 }
109
110 /***
111 * Load service configration file.
112 *
113 * @return Service
114 * @throws Throwable
115 */
116 private Configuration loadServiceConfigration()
117 throws ServiceConfigurationException {
118 Configuration config = null;
119 try {
120 is = ResourceHelper.getResourceAsStream(Globals.JFOXSOAF_CONFIG);
121 isr = new InputStreamReader(is);
122 config = Configuration.unmarshal(isr);
123 } catch (Exception e) {
124 e.printStackTrace();
125 throw new ServiceConfigurationException(e);
126 } finally {
127 if (is != null) {
128 try {
129 is.close();
130 } catch (IOException e) {
131 e.printStackTrace();
132 }
133 }
134
135 if (isr != null) {
136 try {
137 isr.close();
138 } catch (IOException e) {
139 e.printStackTrace();
140 }
141 }
142
143 }
144
145 return config;
146 }
147
148 /***
149 * Unregister service.
150 *
151 * @param service
152 */
153 public void unRegisterService(Object service) {
154 serviceContainer.unregisterComponent(service);
155 }
156
157 /***
158 * Unregister service instance.
159 *
160 * @param serviceInstance
161 */
162 public void unRegisterServiceInstance(Object serviceInstance) {
163 serviceContainer.unregisterComponentByInstance(serviceInstance);
164 }
165
166 /***
167 * Register service implementation.
168 *
169 * @param service
170 */
171 public void registerService(Class serviceImpl)
172 throws PicoRegistrationException {
173 serviceContainer.registerServiceImplementation(serviceImpl);
174 }
175
176 /***
177 * Register service with service key.
178 *
179 * @param serviceKey
180 * @param serviceImpl
181 */
182 public void registerService(Object serviceKey, Class serviceImpl)
183 throws PicoRegistrationException {
184 serviceContainer.registerServiceImplementation(serviceKey, serviceImpl);
185 }
186
187 /***
188 * Register service instance.
189 *
190 * @param serviceInstance
191 */
192 public void registerServiceInstance(Object serviceInstance)
193 throws PicoRegistrationException {
194 serviceContainer.registerServiceInstance(serviceInstance);
195 }
196
197 /***
198 * Return MBeanServer
199 *
200 * @return
201 */
202 public MBeanServer getMBeanServer() {
203 return manageableServiceContainer.getMBeanServer();
204 }
205
206 }