JFox Service-Oriented Application Framework

Clover coverage report - JFox Service-Oriented Application Framework - 1.0-M3

Coverage timestamp: 星期日五月 22 2005 15:41:44 CST

FRAMES NO FRAMES

file stats:	LOC:	257		Methods:	9
	NCLOC:	149		Classes:	1

30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover

Source file

Conditionals

Statements

Methods

TOTAL

ServiceLoader.java

68.2%

79.4%

88.9%

77.7%

 /**
  * @(#)ServiceLoader.java
  * 
  * JFoxSOAF, Service-Oriented Application Framework
  * 
  * Copyright(c) JFoxSOAF Team
  * 
  * Licensed under the GNU LGPL, Version 2.1 (the "License"); 
  * you may not use this file except in compliance with the License. 
  * You may obtain a copy of the License at  
  * 
  * http://www.gnu.org/copyleft/lesser.html
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  * See the License for the specific language governing permissions and 
  * limitations under the License. 
  * 
  * For more information, please visit:
  * http://www.jfox.cn/confluence/display/JFoxSOAF/Home
  * http://www.huihoo.org/jfox/jfoxsoaf
  */
 
 package org.huihoo.jfox.soaf.container;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.LinkedList;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.exolab.castor.xml.MarshalException;
 import org.exolab.castor.xml.ValidationException;
 import org.huihoo.jfox.soaf.exception.ServiceConfigurationException;
 import org.huihoo.jfox.soaf.schema.config.Configuration;
 import org.huihoo.jfox.soaf.schema.config.ConfigurationEntry;
 import org.huihoo.jfox.soaf.schema.config.Interceptor;
 import org.huihoo.jfox.soaf.schema.service.Service;
 import org.huihoo.jfox.soaf.schema.service.ServiceEntry;
 import org.huihoo.jfox.soaf.util.resource.ResourceHelper;
 
 /**
  * <p>
  * Service Configration load proxy.
  * </p>
  * 
  * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
  * @version $Revision: 1.3 $ $Date: 2005/05/22 06:46:48 $
  * @version Revision: 1.0
  */
 
 public class ServiceLoader {
     
     private static ServiceLoader serviceLoader;
 
     private boolean serviceLoaded = false;
 
     private Collection serviceSchemaColl = new LinkedList();
 
     private Collection interceptorColl = new ArrayList();
 
     private Collection serviceEntryColl = new ArrayList();
 
     private InterceptorManager interceptorManager = new InterceptorManagerImpl();
 
     private final Log logger = LogFactory.getLog(getClass());
 
     /**
      * Singleton instance
      * @return
      */
     public static ServiceLoader getInstance() {
         if (serviceLoader == null) {
             serviceLoader = new ServiceLoader();
         }
         return serviceLoader;
     }
 
     /**
      * Init services.
      * 
      * @param configFile
      * @throws ServiceConfigurationException
      */
     public synchronized void initService(String configFile)
             throws ServiceConfigurationException {
         if (!isServiceLoaded()) {
             try {
                 InputStream is = ResourceHelper.getResourceAsStream(configFile);
                 loadConfig(loadServiceConfigration(is));
             } catch (Throwable e) {
                 throw new ServiceConfigurationException(
                         "Init serivce config file jfoxsoaf-config.xml failed "
                                 + e.getMessage());
             }
             serviceLoaded = true;
         }
     }
 
     /**
      * Init services from input stream.
      * 
      * @param is
      * @throws ServiceConfigurationException
      */
     public synchronized void initService(InputStream is)
             throws ServiceConfigurationException {
         if (!isServiceLoaded()) {
             try {
                 loadConfig(loadServiceConfigration(is));
             } catch (Throwable e) {
                 throw new ServiceConfigurationException(
                         "Init serivce config file jfoxsoaf-config.xml failed "
                                 + e.getMessage());
             }
             serviceLoaded = true;
         }
     }
 
     /**
      * Load service configration file.
      * 
      * @return Service
      * @throws Throwable
      */
     private Configuration loadServiceConfigration(InputStream is)
             throws ServiceConfigurationException {
         InputStreamReader isr = null;
         Configuration config = null;
         try {
             isr = new InputStreamReader(is);
             config = Configuration.unmarshal(isr);
         } catch (MarshalException e) {
             throw new ServiceConfigurationException(e);
         } catch (ValidationException e) {
             throw new ServiceConfigurationException(e);
         } finally {
             if (is != null) {
                 try {
                     is.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
 
             if (isr != null) {
                 try {
                     isr.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return config;
     }
 
     /**
      * Load all configuration service.
      * 
      * @param service
      */
     public void loadConfig(Configuration config) throws Throwable {
         processConfig(config);
         loadService(serviceSchemaColl);
         interceptorManager
                 .processInterceptor(interceptorColl, serviceEntryColl);
     }
 
     /**
      * Load service schema.
      * 
      * @param serviceSchemaColl
      * @throws ServiceConfigurationException
      */
     private void loadService(Collection serviceSchemaColl)
             throws ServiceConfigurationException {
         InputStream is = null;
         InputStreamReader isr = null;
         Iterator iter = serviceSchemaColl.iterator();
         Service service;
         try {
             while (iter.hasNext()) {
                 is = ResourceHelper.getResourceAsStream((String) iter.next());
                 isr = new InputStreamReader(is);
                 service = Service.unmarshal(isr);
                 processService(service);
             }
         } catch (Exception e) {
             throw new ServiceConfigurationException(e);
         } finally {
             if (is != null) {
                 try {
                     is.close();
                 } catch (IOException e1) {
                     e1.printStackTrace();
                 }
 
             }
 
             if (isr != null) {
                 try {
                     isr.close();
                 } catch (IOException e1) {
                     e1.printStackTrace();
                 }
             }
 
         }
 
     }
 
     /**
      * Add service to service entry collection.
      * 
      * @param service
      */
     private void processService(Service service) {
         ServiceEntry[] serviceEntry = service.getServiceEntry();
         for (int i = 0; i < serviceEntry.length; i++) {
             serviceEntryColl.add(serviceEntry[i]);
         }
     }
 
     /**
      * Is service loaded?
      * 
      * @return boolean
      */
     public boolean isServiceLoaded() {
         return this.serviceLoaded;
     }
 
     /**
      * Add service schema and interceptor to collection.
      * 
      * @param config
      */
     private void processConfig(Configuration config) {
         ConfigurationEntry[] configEntry = config.getServiceConfiguration()
                 .getConfigurationEntry();
         Interceptor[] interceptor = config.getSystemInterceptor()
                 .getInterceptor();
         for (int i = 0; i < configEntry.length; i++) {
             logger.info("Load service schema : " + configEntry[i].getValue());
             serviceSchemaColl.add(configEntry[i].getValue());
         }
 
         for (int i = 0; i < interceptor.length; i++) {
             interceptorColl.add(interceptor[i].getValue());
         }
     }
 }

1		/**
2		* @(#)ServiceLoader.java
3		*
4		* JFoxSOAF, Service-Oriented Application Framework
5		*
6		* Copyright(c) JFoxSOAF Team
7		*
8		* Licensed under the GNU LGPL, Version 2.1 (the "License");
9		* you may not use this file except in compliance with the License.
10		* You may obtain a copy of the License at
11		*
12		* http://www.gnu.org/copyleft/lesser.html
13		*
14		* Unless required by applicable law or agreed to in writing, software
15		* distributed under the License is distributed on an "AS IS" BASIS,
16		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17		* See the License for the specific language governing permissions and
18		* limitations under the License.
19		*
20		* For more information, please visit:
21		* http://www.jfox.cn/confluence/display/JFoxSOAF/Home
22		* http://www.huihoo.org/jfox/jfoxsoaf
23		*/
24
25		package org.huihoo.jfox.soaf.container;
26
27		import java.io.IOException;
28		import java.io.InputStream;
29		import java.io.InputStreamReader;
30		import java.util.ArrayList;
31		import java.util.Collection;
32		import java.util.Iterator;
33		import java.util.LinkedList;
34
35		import org.apache.commons.logging.Log;
36		import org.apache.commons.logging.LogFactory;
37		import org.exolab.castor.xml.MarshalException;
38		import org.exolab.castor.xml.ValidationException;
39		import org.huihoo.jfox.soaf.exception.ServiceConfigurationException;
40		import org.huihoo.jfox.soaf.schema.config.Configuration;
41		import org.huihoo.jfox.soaf.schema.config.ConfigurationEntry;
42		import org.huihoo.jfox.soaf.schema.config.Interceptor;
43		import org.huihoo.jfox.soaf.schema.service.Service;
44		import org.huihoo.jfox.soaf.schema.service.ServiceEntry;
45		import org.huihoo.jfox.soaf.util.resource.ResourceHelper;
46
47		/**
48		* <p>
49		* Service Configration load proxy.
50		* </p>
51		*
52		* @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
53		* @version $Revision: 1.3 $ $Date: 2005/05/22 06:46:48 $
54		* @version Revision: 1.0
55		*/
56
57		public class ServiceLoader {
58
59		private static ServiceLoader serviceLoader;
60
61		private boolean serviceLoaded = false;
62
63		private Collection serviceSchemaColl = new LinkedList();
64
65		private Collection interceptorColl = new ArrayList();
66
67		private Collection serviceEntryColl = new ArrayList();
68
69		private InterceptorManager interceptorManager = new InterceptorManagerImpl();
70
71		private final Log logger = LogFactory.getLog(getClass());
72
73		/**
74		* Singleton instance
75		* @return
76		*/
77	4	public static ServiceLoader getInstance() {
78	4	if (serviceLoader == null) {
79	1	serviceLoader = new ServiceLoader();
80		}
81	4	return serviceLoader;
82		}
83
84		/**
85		* Init services.
86		*
87		* @param configFile
88		* @throws ServiceConfigurationException
89		*/
90	1	public synchronized void initService(String configFile)
91		throws ServiceConfigurationException {
92	1	if (!isServiceLoaded()) {
93	1	try {
94	1	InputStream is = ResourceHelper.getResourceAsStream(configFile);
95	1	loadConfig(loadServiceConfigration(is));
96		} catch (Throwable e) {
97	0	throw new ServiceConfigurationException(
98		"Init serivce config file jfoxsoaf-config.xml failed "
99		+ e.getMessage());
100		}
101	1	serviceLoaded = true;
102		}
103		}
104
105		/**
106		* Init services from input stream.
107		*
108		* @param is
109		* @throws ServiceConfigurationException
110		*/
111	0	public synchronized void initService(InputStream is)
112		throws ServiceConfigurationException {
113	0	if (!isServiceLoaded()) {
114	0	try {
115	0	loadConfig(loadServiceConfigration(is));
116		} catch (Throwable e) {
117	0	throw new ServiceConfigurationException(
118		"Init serivce config file jfoxsoaf-config.xml failed "
119		+ e.getMessage());
120		}
121	0	serviceLoaded = true;
122		}
123		}
124
125		/**
126		* Load service configration file.
127		*
128		* @return Service
129		* @throws Throwable
130		*/
131	1	private Configuration loadServiceConfigration(InputStream is)
132		throws ServiceConfigurationException {
133	1	InputStreamReader isr = null;
134	1	Configuration config = null;
135	1	try {
136	1	isr = new InputStreamReader(is);
137	1	config = Configuration.unmarshal(isr);
138		} catch (MarshalException e) {
139	0	throw new ServiceConfigurationException(e);
140		} catch (ValidationException e) {
141	0	throw new ServiceConfigurationException(e);
142		} finally {
143	1	if (is != null) {
144	1	try {
145	1	is.close();
146		} catch (IOException e) {
147	0	e.printStackTrace();
148		}
149		}
150
151	1	if (isr != null) {
152	1	try {
153	1	isr.close();
154		} catch (IOException e) {
155	0	e.printStackTrace();
156		}
157		}
158		}
159	1	return config;
160		}
161
162		/**
163		* Load all configuration service.
164		*
165		* @param service
166		*/
167	1	public void loadConfig(Configuration config) throws Throwable {
168	1	processConfig(config);
169	1	loadService(serviceSchemaColl);
170	1	interceptorManager
171		.processInterceptor(interceptorColl, serviceEntryColl);
172		}
173
174		/**
175		* Load service schema.
176		*
177		* @param serviceSchemaColl
178		* @throws ServiceConfigurationException
179		*/
180	1	private void loadService(Collection serviceSchemaColl)
181		throws ServiceConfigurationException {
182	1	InputStream is = null;
183	1	InputStreamReader isr = null;
184	1	Iterator iter = serviceSchemaColl.iterator();
185	1	Service service;
186	1	try {
187	1	while (iter.hasNext()) {
188	4	is = ResourceHelper.getResourceAsStream((String) iter.next());
189	4	isr = new InputStreamReader(is);
190	4	service = Service.unmarshal(isr);
191	4	processService(service);
192		}
193		} catch (Exception e) {
194	0	throw new ServiceConfigurationException(e);
195		} finally {
196	1	if (is != null) {
197	1	try {
198	1	is.close();
199		} catch (IOException e1) {
200	0	e1.printStackTrace();
201		}
202
203		}
204
205	1	if (isr != null) {
206	1	try {
207	1	isr.close();
208		} catch (IOException e1) {
209	0	e1.printStackTrace();
210		}
211		}
212
213		}
214
215		}
216
217		/**
218		* Add service to service entry collection.
219		*
220		* @param service
221		*/
222	4	private void processService(Service service) {
223	4	ServiceEntry[] serviceEntry = service.getServiceEntry();
224	4	for (int i = 0; i < serviceEntry.length; i++) {
225	6	serviceEntryColl.add(serviceEntry[i]);
226		}
227		}
228
229		/**
230		* Is service loaded?
231		*
232		* @return boolean
233		*/
234	5	public boolean isServiceLoaded() {
235	5	return this.serviceLoaded;
236		}
237
238		/**
239		* Add service schema and interceptor to collection.
240		*
241		* @param config
242		*/
243	1	private void processConfig(Configuration config) {
244	1	ConfigurationEntry[] configEntry = config.getServiceConfiguration()
245		.getConfigurationEntry();
246	1	Interceptor[] interceptor = config.getSystemInterceptor()
247		.getInterceptor();
248	1	for (int i = 0; i < configEntry.length; i++) {
249	4	logger.info("Load service schema : " + configEntry[i].getValue());
250	4	serviceSchemaColl.add(configEntry[i].getValue());
251		}
252
253	1	for (int i = 0; i < interceptor.length; i++) {
254	2	interceptorColl.add(interceptor[i].getValue());
255		}
256		}
257		}