Changeset 7527 for RevitalizationWS


Ignore:
Timestamp:
27/09/10 15:05:30 (9 years ago)
Author:
mnagni
Message:

Radically changed the ObjectFactory? discovery strategy.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • RevitalizationWS/common/core/trunk/src/main/java/ndg/common/jaxb/JAXBManager.java

    r7481 r7527  
    1 /* 
     1/** 
    22 * BSD Licence 
    3  * Copyright (c) 2009, Science & Technology Facilities Council (STFC) 
    4  * All rights reserved. 
    5  
    6  * See the LICENSE file in the source distribution of this software for 
    7  * the full license text.        
    8  * Copyright (C) 2007 STFC & NERC (Science and Technology Facilities Council). 
    9  * This software may be distributed under the terms of the 
    10  * Q Public License, version 1.0 or later. 
    11  * http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt 
     3 * Copyright (c) 2009, Science & Technology Facilities Council (STFC) All rights reserved. 
     4 * Redistribution and use in source and binary forms, with or without 
     5 * modification, are permitted provided that the following conditions are 
     6 * met: 
     7 * 
     8 *   - Redistributions of source code must retain the above copyright 
     9 *     notice, this list of conditions and the following disclaimer. 
     10 *   - Redistributions in binary form must reproduce the above 
     11 *     copyright notice, this list of conditions and the following disclaimer 
     12 *     in the documentation and/or other materials provided with the 
     13 *     distribution. 
     14 *   - Neither the name of the Science & Technology Facilities Council 
     15 *     (STFC) nor the names of its contributors may be used to endorse or 
     16 *     promote products derived from this software without specific prior 
     17 *     written permission. 
     18 * 
     19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
     20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
     21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
     22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
     23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
     24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
     25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
     26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
     27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
     28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
     29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     30 *  
    1231 */ 
    1332package ndg.common.jaxb; 
    1433 
    15 import java.io.File; 
    16 import java.io.IOException; 
    1734import java.io.InputStream; 
    1835import java.io.OutputStream; 
     36import java.lang.reflect.Field; 
    1937import java.lang.reflect.InvocationTargetException; 
    2038import java.lang.reflect.Method; 
    21 import java.net.MalformedURLException; 
    22 import java.net.URISyntaxException; 
    23 import java.net.URL; 
    24 import java.net.URLClassLoader; 
    25 import java.util.ArrayList; 
    26 import java.util.Enumeration; 
     39import java.lang.reflect.ParameterizedType; 
     40import java.lang.reflect.Type; 
     41import java.lang.reflect.WildcardType; 
    2742import java.util.HashSet; 
    2843import java.util.List; 
    2944import java.util.Set; 
    3045import java.util.WeakHashMap; 
    31 import java.util.jar.JarEntry; 
    32 import java.util.jar.JarFile; 
    3346 
    3447import javax.xml.bind.JAXBContext; 
     
    4356/** 
    4457 * Manages marshal and unmarshal for a set of JAXB generated classes. This class 
    45  * uses different strategies: 
    46  * <ul> 
    47  * <li> 
    48  * loads the jar in an internal <code>URLClassLoader</code> instance. In this 
    49  * way each JAXBManager instance manages a different subset of jars and at the same time could 
    50  * load dynamically load the jars (feature still not activated)</li> 
    51  * <li> 
    52  * Manages an internal cache, based on <code>WeakHashMap</code> instances, to 
    53  * minimize both the memory impact and the access to the classes underlying the 
    54  * marshaller/unmarshaller execution.</li> 
    55  * </ul> 
     58 * loads various ObjectFactories in an internal cache, based on <code>WeakHashMap</code> 
     59 * instances, to minimize both the memory impact and the access to the classes underlying the 
     60 * marshaller/unmarshaller execution. It automatically retrieve the necessary libraries as  
     61 * long thay belong to a unique ClassLoader. Such limitation could be removed in a 
     62 * future release.  
    5663 *  
    5764 * @author Maurizio Nagni <maurizio.nagni@stfc.ac.uk> 
     
    5966public class JAXBManager { 
    6067 
     68        /* 
    6169        private final List<URL> urls = new ArrayList<URL>(); 
    6270        private final Set<String> factories = new HashSet<String>(); 
    63  
    64         private URLClassLoader urlLoader = null; 
     71        */ 
     72 
     73        // private URLClassLoader urlLoader = null; 
     74        private ClassLoader loader = null; 
    6575        private JAXBContext jc = null; 
    6676        private WeakHashMap<String, Method> creator = new WeakHashMap<String, Method>(); 
    6777        private WeakHashMap<String, Object> objectFactory = new WeakHashMap<String, Object>(); 
     78        private final Set<String> knownPackage = new HashSet<String>(); 
    6879        private Marshaller marshaller = null; 
     80        private Object marshallerLock = new Object(); 
    6981        private Unmarshaller unmarshaller = null; 
    70  
    71         /** 
    72          * Creates an instance of the JAXBManager. The parameters cannot be both <code>null</code>  
    73          * at the same time. 
    74          *  
    75          * @param urls 
    76          *            a collection of <code>URL</code>s representing the path to the 
    77          *            jar files. If <code>null</code> retrieves the jars in the classpath 
    78          * @param factories a collections of the packages names used as filter to accept the JAXB 
    79          * ObjectFactories   
    80          * @throws ResourceNotAvailable both the parameters are null or other 
    81          * @throws JAXBException general JAXB exception            
    82          **/ 
    83         public JAXBManager(List<URL> urls, Set<String> factories) throws ResourceNotAvailable, JAXBException { 
    84                 super(); 
    85                 if ((urls == null || urls.size() == 0) && (factories == null || factories.size() == 0)) 
    86                         throw new ResourceNotAvailable("Both the constructor's parameters canno be null"); 
    87                 urls = urls == null ? useClasspath() : urls; 
    88                 this.urls.addAll(urls); 
    89                 this.factories.addAll(factories); 
    90                 jc = doJAXBContext(); 
    91                 marshaller = jc.createMarshaller(); 
    92                 unmarshaller = jc.createUnmarshaller(); 
    93         } 
    94  
     82        private Object unmarshallerLock = new Object(); 
     83         
     84        private static final JAXBManager instance = new JAXBManager();  
     85         
     86        public static JAXBManager getInstance(){ 
     87                return instance; 
     88        } 
     89         
    9590        /** 
    9691         * Transforms a JAXB created java object in its XML counterpart. 
    97          * @param obj the JAXB created instance 
    98          * @param os the OutputStrem where write the XML document 
    99          * @throws ResourceNotAvailable general Exception 
    100          * @throws JAXBException general JAXB exception             
     92         *  
     93         * @param obj 
     94         *            the JAXB created instance 
     95         * @param os 
     96         *            the OutputStrem where write the XML document 
     97         * @throws ResourceNotAvailable 
     98         *             general Exception 
     99         * @throws JAXBException 
     100         *             general JAXB exception 
    101101         **/ 
    102         public void marshall(Object obj, OutputStream os) throws ResourceNotAvailable, JAXBException { 
    103                 synchronized (marshaller) { 
    104                         marshaller.marshal(marshallerHelper(obj), System.out); 
    105                 } 
    106         } 
    107  
     102        public void marshall(Object obj, OutputStream os) 
     103                        throws ResourceNotAvailable, JAXBException { 
     104                synchronized (marshallerLock) { 
     105                        if (marshaller == null) { 
     106                                init(obj.getClass()); 
     107                        } 
     108                        marshaller.marshal(marshallerHelper(obj), os); 
     109                } 
     110        } 
    108111         
    109112        /** 
    110113         * Transforms an XML document in its JAXB created java object counterpart. 
    111          * @param is the XML document InputStream 
    112          * @param declaredType the (JAXB generated) Class expected to describe the XML document 
    113          * @return an object representing the XML document  
    114          * @throws ResourceNotAvailable general Exception 
    115          * @throws JAXBException general JAXB exception             
    116          **/     
    117         public <T> T unmarshall(InputStream is, Class<T> declaredType) throws ResourceNotAvailable, JAXBException { 
    118                 synchronized (unmarshaller) { 
    119                         return (T) unmarshaller.unmarshal(new StreamSource(is), declaredType).getValue(); 
    120                 } 
    121         } 
    122  
    123         private <T> JAXBElement<?> marshallerHelper(T res) throws ResourceNotAvailable { 
     114         *  
     115         * @param is 
     116         *            the XML document InputStream 
     117         * @param declaredType 
     118         *            the (JAXB generated) Class expected to describe the XML 
     119         *            document 
     120         * @return an object representing the XML document 
     121         * @throws ResourceNotAvailable 
     122         *             general Exception 
     123         * @throws JAXBException 
     124         *             general JAXB exception 
     125         **/ 
     126        public <T> T unmarshall(InputStream is, Class<T> declaredType) 
     127                        throws ResourceNotAvailable, JAXBException { 
     128                synchronized (unmarshallerLock) { 
     129                        if (unmarshaller == null) { 
     130                                init(declaredType); 
     131                        } 
     132                        return (T) unmarshaller.unmarshal(new StreamSource(is), 
     133                                        declaredType).getValue(); 
     134                } 
     135        } 
     136 
     137        @SuppressWarnings("unchecked") 
     138        private void init(Class clazz) throws ResourceNotAvailable, JAXBException{ 
     139                if (clazz == null) 
     140                        throw new ResourceNotAvailable("Clazz cannot be null"); 
     141                 
     142                if (this.loader == null) 
     143                        this.loader = clazz.getClassLoader(); 
     144                 
     145                if (!this.loader.equals(clazz.getClassLoader())) 
     146                        throw new ResourceNotAvailable("Multiple ClassLoader not supported"); 
     147                 
     148                if (!knownPackage.contains(clazz.getPackage().getName())) { 
     149                        jc = doJAXBContext_(clazz); 
     150                        marshaller = jc.createMarshaller(); 
     151                        unmarshaller = jc.createUnmarshaller(); 
     152                        knownPackage.add(clazz.getName()); 
     153                } 
     154        }        
     155 
     156        /** 
     157         * Creates an instance of the JAXBManager. 
     158         **/ 
     159        private JAXBManager() { 
     160                super(); 
     161        } 
     162         
     163         
     164        private <T> JAXBElement<?> marshallerHelper(T res) 
     165                        throws ResourceNotAvailable { 
    124166                try { 
    125                         return (JAXBElement<?>) getCreator(res).invoke(getObjectFactory(res), res); 
     167                        return (JAXBElement<?>) getCreator(res).invoke( 
     168                                        getObjectFactory(res.getClass()), res); 
    126169                } catch (IllegalArgumentException e) { 
    127170                        throw new ResourceNotAvailable(e); 
     
    132175                } 
    133176        } 
    134  
    135         private JAXBContext doJAXBContext() throws ResourceNotAvailable { 
    136                 Set<String> controller = new HashSet<String>(); 
     177         
     178        @SuppressWarnings("unchecked") 
     179        private JAXBContext doJAXBContext_(Class clazz) throws ResourceNotAvailable { 
    137180                // MarshallerHelper 
    138181                StringBuffer sb = new StringBuffer(); 
     182                Set<String> packages = new HashSet<String>(); 
     183                Set<String> done = new HashSet<String>(); 
     184 
    139185                try { 
    140                         List<JarFile> jarFiles = new ArrayList<JarFile>(); 
    141                         for (URL url : urls) { 
    142                                 jarFiles.add(new JarFile(new File(url.toURI()))); 
    143                         } 
    144                         urlLoader = new URLClassLoader(urls.toArray(new URL[0])); 
    145  
    146                         for (JarFile jar : jarFiles) { 
    147                                 Enumeration<JarEntry> iter = jar.entries(); 
    148                                 JarEntry entry = null; 
    149                                 while (iter.hasMoreElements()) { 
    150                                         entry = iter.nextElement(); 
    151  
    152                                         String name = entry.getName(); 
    153                                         name = name.substring(name.lastIndexOf('/') + 1, name.length()); 
    154                                         if (!name.equals("ObjectFactory.class")) 
    155                                                 continue; 
    156  
    157                                         name = entry.getName(); 
    158                                         name = name.substring(0, name.length() - "ObjectFactory.class".length() - 1); 
    159                                         name = name.replace('/', '.'); 
    160                                         // Skips already exists ObjectFactories and the ones related 
    161                                         // to the org.apache (probably others could be required) 
    162                                         if (controller.add(name)) { 
    163                                                 for (String factory : factories) { 
    164                                                         if (name.contains(factory)) { 
    165                                                                 if (sb.length() > 0) 
    166                                                                         sb.append(":"); 
    167                                                                 sb.append(name); 
    168                                                         } 
    169                                                 } 
    170                                         } 
     186                        loop(clazz, packages, done); 
     187 
     188                        for (String clazzName : packages) { 
     189                                if (sb.length() > 0) 
     190                                        sb.append(":"); 
     191                                sb.append(clazzName); 
     192                        } 
     193                        return JAXBContext.newInstance(sb.toString(), loader); 
     194                } catch (Exception e) { 
     195                        throw new ResourceNotAvailable(e); 
     196                } 
     197        } 
     198 
     199        @SuppressWarnings("unchecked") 
     200        private void loop(Class clazz, Set<String> packages, Set<String> done) { 
     201                Method[] methods = clazz.getDeclaredMethods(); 
     202                Field[] fields = clazz.getDeclaredFields(); 
     203 
     204                try { 
     205                        for (Field field : fields){ 
     206                                innerLoop(clazz, extractType(field), packages, done); 
     207                        } 
     208                         
     209                        for (Method item : methods) { 
     210                                innerLoop(clazz, loopExtractType(item.getGenericReturnType()), packages, done); 
     211                        } 
     212                } catch (Exception e) { 
     213                        e.printStackTrace(); 
     214                } 
     215        } 
     216 
     217        @SuppressWarnings("unchecked") 
     218        private Class extractType(Field field) { 
     219                if (field.getType().isAssignableFrom(List.class)) { 
     220                        Type type = field.getGenericType();              
     221                        return loopExtractType(type); 
     222                } 
     223                return field.getType();  
     224        } 
     225         
     226        @SuppressWarnings("unchecked") 
     227        private Class loopExtractType(Type type){ 
     228                Class ret = null; 
     229                if (type instanceof WildcardType) {  
     230                        return loopExtractType(((WildcardType) type).getUpperBounds()[0]); 
     231                } else if (type instanceof ParameterizedType) {   
     232                        ParameterizedType pt = (ParameterizedType) type;  
     233                        Type[] types = pt.getActualTypeArguments(); 
     234                        for (Type item : types){ 
     235                                return loopExtractType(item); 
     236                        } 
     237                } else if (type instanceof Class){ 
     238                        ret = (Class)type; 
     239                } 
     240                return ret; 
     241        } 
     242         
     243        @SuppressWarnings("unchecked") 
     244        private void innerLoop(Class parent, Class type, Set<String> packages, Set<String> done){ 
     245                 
     246                if (type.isPrimitive()) 
     247                        return; 
     248                 
     249                Package pkgTmp = null; 
     250                Object objFactory = null;        
     251                String pkgName = null;           
     252                 
     253                if (type.isArray()) { 
     254                        pkgTmp = type.getComponentType().getPackage(); 
     255                } else { 
     256                        pkgTmp = type.getPackage(); 
     257                } 
     258                 
     259                if(pkgTmp == null) 
     260                        return; 
     261                 
     262                try { 
     263                        pkgName = pkgTmp.getName();      
     264                } catch (Exception e) { 
     265                        e.printStackTrace(); 
     266                } 
     267                                                 
     268                if ((pkgName.contains(".sun.")  
     269                                || pkgName.startsWith("java"))) 
     270                        return; 
     271                 
     272                if (pkgTmp == null) 
     273                        return; 
     274 
     275                if (pkgTmp.getName().equals(parent.getPackage().getName())) { 
     276                        if (!done.contains(type.getName())) { 
     277                                done.add(type.getName()); 
     278                                loop(type, packages, done); 
     279                        } 
     280                } 
     281                 
     282                if (!packages.contains(pkgTmp.getName())) { 
     283                        try { 
     284                                objFactory = loader.loadClass(pkgTmp.getName() 
     285                                                + ".ObjectFactory"); 
     286                                if (objFactory != null) { 
     287                                        packages.add(pkgTmp.getName()); 
     288                                        knownPackage.add(pkgTmp.getName()); 
     289                                        loop((Class)objFactory, packages, done); 
    171290                                } 
    172                         } 
    173                         return JAXBContext.newInstance(sb.toString(), urlLoader); 
    174                 } catch (IOException e) { 
    175                         throw new ResourceNotAvailable(e); 
    176                 } catch (JAXBException e) { 
    177                         throw new ResourceNotAvailable(e); 
    178                 } catch (URISyntaxException e) { 
    179                         throw new ResourceNotAvailable(e); 
     291                        } catch (Exception e) { 
     292                                return; 
     293                        } 
    180294                } 
    181295        } 
     
    189303        } 
    190304 
    191         private <T> Object getObjectFactory(T res) throws ResourceNotAvailable { 
    192                 String factoryName = res.getClass().getPackage().getName() + ".ObjectFactory"; 
     305        @SuppressWarnings({ "unchecked"}) 
     306        private Object getObjectFactory(Class res) 
     307                        throws ResourceNotAvailable { 
     308                String factoryName = res.getPackage().getName() + ".ObjectFactory"; 
    193309                if (objectFactory.containsKey(factoryName)) { 
    194310                        return objectFactory.get(factoryName); 
     
    198314        } 
    199315 
    200         private <T> Object scanLoaderForObjectFactory(String factoryName) throws ResourceNotAvailable { 
     316        private <T> Object scanLoaderForObjectFactory(String factoryName) 
     317                        throws ResourceNotAvailable { 
    201318                try { 
    202319                        Object obj = null; 
    203                         Class<?> clazz = urlLoader.loadClass(factoryName); 
     320                        Class<?> clazz = loader.loadClass(factoryName); 
    204321                        if (clazz != null) 
    205322                                obj = clazz.newInstance(); 
     
    222339                Method ret = null; 
    223340                try { 
    224                         clazz = urlLoader.loadClass(res.getClass().getPackage().getName() + ".ObjectFactory"); 
     341                        clazz = loader.loadClass(res.getClass().getPackage().getName() 
     342                                        + ".ObjectFactory"); 
    225343                        obj = clazz.newInstance(); 
    226344                } catch (ClassNotFoundException e) { 
     
    232350                } 
    233351                for (Method item : obj.getClass().getDeclaredMethods()) { 
    234                         if (!item.getReturnType().isAssignableFrom(JAXBElement.class)) 
    235                                 continue; 
    236  
    237                         if (item.getParameterTypes().length != 1) 
    238                                 continue; 
    239  
    240                         if (!item.getParameterTypes()[0].isAssignableFrom(res.getClass())) 
    241                                 continue; 
     352 
     353                        if (item.getParameterTypes().length == 1) { 
     354                                if (!item.getParameterTypes()[0].isAssignableFrom(res 
     355                                                .getClass())) 
     356                                        continue; 
     357 
     358                                if (!item.getReturnType().isAssignableFrom(JAXBElement.class)) 
     359                                        continue; 
     360                        } else if (item.getParameterTypes().length == 0) { 
     361                                if (!item.getReturnType().isAssignableFrom(res.getClass())) 
     362                                        continue; 
     363                        } 
    242364 
    243365                        creator.put(res.getClass().getName(), item); 
     
    247369        } 
    248370 
     371        /* 
     372         * public <T> T createInstance(T res) throws ResourceNotAvailable { try { 
     373         * return (T)getCreator(res).invoke(getObjectFactory(res)); } catch 
     374         * (IllegalArgumentException e) { throw new ResourceNotAvailable(e); } catch 
     375         * (IllegalAccessException e) { throw new ResourceNotAvailable(e); } catch 
     376         * (InvocationTargetException e) { throw new ResourceNotAvailable(e); } } 
     377         */      
     378         
     379        /* 
     380         * private JAXBContext doJAXBContext() throws ResourceNotAvailable { 
     381         * Set<String> controller = new HashSet<String>(); // MarshallerHelper 
     382         * StringBuffer sb = new StringBuffer(); try { List<JarFile> jarFiles = new 
     383         * ArrayList<JarFile>(); for (URL url : urls) { jarFiles.add(new JarFile(new 
     384         * File(url.toURI()))); } urlLoader = new URLClassLoader(urls.toArray(new 
     385         * URL[0])); 
     386         *  
     387         * for (JarFile jar : jarFiles) { Enumeration<JarEntry> iter = 
     388         * jar.entries(); JarEntry entry = null; while (iter.hasMoreElements()) { 
     389         * entry = iter.nextElement(); 
     390         *  
     391         * String name = entry.getName(); name = 
     392         * name.substring(name.lastIndexOf('/') + 1, name.length()); if 
     393         * (!name.equals("ObjectFactory.class")) continue; 
     394         *  
     395         * name = entry.getName(); name = name.substring(0, name.length() - 
     396         * "ObjectFactory.class".length() - 1); name = name.replace('/', '.'); // 
     397         * Skips already exists ObjectFactories and the ones related // to the 
     398         * org.apache (probably others could be required) if (controller.add(name)) 
     399         * { for (String factory : factories) { if (name.contains(factory)) { if 
     400         * (sb.length() > 0) sb.append(":"); sb.append(name); } } } } } return 
     401         * JAXBContext.newInstance(sb.toString(), urlLoader); } catch (IOException 
     402         * e) { throw new ResourceNotAvailable(e); } catch (JAXBException e) { throw 
     403         * new ResourceNotAvailable(e); } catch (URISyntaxException e) { throw new 
     404         * ResourceNotAvailable(e); } } 
     405         */      
     406         
     407        /* 
     408        private Class<?>[] extractAllClassesFromJVM() throws IOException { 
     409                ClassLoader appLoader = ClassLoader.getSystemClassLoader(); 
     410 
     411                ClassLoader[] loaders = new ClassLoader[] { appLoader, loader }; 
     412                return ClassScope.getLoadedClasses(loaders); 
     413        } 
     414         */ 
     415 
     416        /** 
     417         * Recursive method used to find all classes in a given directory and 
     418         * subdirs. 
     419         *  
     420         * @param directory 
     421         *            The base directory 
     422         * @param packageName 
     423         *            The package name for classes found inside the base directory 
     424         * @return The classes 
     425         * @throws ClassNotFoundException 
     426         */ 
     427        /* 
     428        private List<Class> findClasses(File directory, String packageName) 
     429                        throws ClassNotFoundException { 
     430                List<Class> classes = new ArrayList<Class>(); 
     431                if (!directory.exists()) { 
     432                        return classes; 
     433                } 
     434                File[] files = directory.listFiles(); 
     435                for (File file : files) { 
     436                        if (file.isDirectory()) { 
     437                                assert !file.getName().contains("."); 
     438                                classes.addAll(findClasses(file, packageName + "." 
     439                                                + file.getName())); 
     440                        } else if (file.getName().endsWith(".class")) { 
     441                                classes.add(Class.forName(packageName 
     442                                                + '.' 
     443                                                + file.getName().substring(0, 
     444                                                                file.getName().length() - 6))); 
     445                        } 
     446                } 
     447                return classes; 
     448        } 
     449        */ 
     450         
     451        /** 
     452         * Creates an instance of the JAXBManager. The parameters cannot be both 
     453         * <code>null</code> at the same time. 
     454         *  
     455         * @param urls 
     456         *            a collection of <code>URL</code>s representing the path to the 
     457         *            jar files. If <code>null</code> retrieves the jars in the 
     458         *            classpath 
     459         * @param factories 
     460         *            a collections of the packages names used as filter to accept 
     461         *            the JAXB ObjectFactories 
     462         * @throws ResourceNotAvailable 
     463         *             both the parameters are null or other 
     464         * @throws JAXBException 
     465         *             general JAXB exception 
     466         **/ 
     467        /* 
     468         * public JAXBManager(List<URL> urls, Set<String> factories) throws 
     469         * ResourceNotAvailable, JAXBException { super(); if ((urls == null || 
     470         * urls.size() == 0) && (factories == null || factories.size() == 0)) throw 
     471         * new 
     472         * ResourceNotAvailable("Both the constructor's parameters canno be null"); 
     473         * urls = urls == null ? useClasspath() : urls; this.urls.addAll(urls); 
     474         * this.factories.addAll(factories); jc = doJAXBContext(); marshaller = 
     475         * jc.createMarshaller(); unmarshaller = jc.createUnmarshaller(); } 
     476         */              
     477         
     478        /* 
    249479        private static List<URL> useClasspath() { 
    250480                List<URL> urls = new ArrayList<URL>(); 
    251481                final String pathSep = System.getProperty("path.separator"); 
    252                 final String list = System.getProperty("java.class.path"); 
     482                // System Classpath 
     483                final String systemList = System.getProperty("java.class.path"); 
     484                // JBoss SERVER_HOME/lib classpath 
     485                final String jbossList = System.getProperty("jboss.server.lib.url") 
     486                                .replace("file:", ""); 
     487 
     488                final String list = systemList + pathSep + jbossList; 
     489 
    253490                for (final String path : list.split(pathSep)) { 
    254491                        final File object = new java.io.File(path); 
     
    262499                return urls; 
    263500        } 
     501        */ 
    264502 
    265503        /** 
     
    268506         * @throws MalformedURLException 
    269507         */ 
     508        /* 
    270509        private static List<URL> ls(File f) throws MalformedURLException { 
    271510                List<URL> urls = new ArrayList<URL>(); 
     
    288527                return urls; 
    289528        } 
     529        */ 
    290530} 
Note: See TracChangeset for help on using the changeset viewer.