Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 * * 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. */ package org.atricore.idbus.kernel.main.databinding; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.atricore.idbus.kernel.main.util.AccessController; import org.atricore.idbus.kernel.main.util.ClassFinderFactory; import org.atricore.idbus.kernel.main.util.ClassUtils; import org.atricore.idbus.kernel.main.util.JavaUtils; import javax.xml.bind.*; import javax.xml.bind.annotation.XmlType; import javax.xml.ws.Holder; import javax.xml.ws.wsaddressing.W3CEndpointReference; import java.io.File; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.lang.annotation.Annotation; import java.lang.ref.SoftReference; import java.lang.reflect.AnnotatedElement; import java.net.URL; import java.net.URLDecoder; import java.security.PrivilegedAction; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.util.*; import java.util.concurrent.ConcurrentHashMap; /** * JAXB Utilites to pool JAXBContext and related objects. */ public class JAXBUtils { private static final Log log = LogFactory.getLog(JAXBUtils.class); // Create a concurrent map to get the JAXBObject: // key is the String (sorted packages) // value is a SoftReference to a ConcurrentHashMap of Classloader keys and JAXBContextValue objects // It is a soft map to encourage GC in low memory situations private static Map<String, SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>>> jaxbMap = new ConcurrentHashMap<String, SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>>>(); private static Pool<JAXBContext, Marshaller> mpool = new Pool<JAXBContext, Marshaller>(); private static Pool<JAXBContext, Unmarshaller> upool = new Pool<JAXBContext, Unmarshaller>(); private static Pool<JAXBContext, JAXBIntrospector> ipool = new Pool<JAXBContext, JAXBIntrospector>(); // From Lizet Ernand: // If you really care about the performance, // and/or your application is going to read a lot of small documents, // then creating Unmarshaller could be relatively an expensive operation. // In that case, consider pooling Unmarshaller objects. // Different threads may reuse one Unmarshaller instance, // as long as you don't use one instance from two threads at the same time. // ENABLE_ADV_POOLING is false...which means they are obtained from the JAXBContext instead of // from the pool. private static boolean ENABLE_MARSHALL_POOLING = true; private static boolean ENABLE_UNMARSHALL_POOLING = true; private static boolean ENABLE_INTROSPECTION_POOLING = false; private static int MAX_LOAD_FACTOR = 32; // Maximum number of JAXBContext to store // Construction Type public enum CONSTRUCTION_TYPE { BY_CLASS_ARRAY, // New Instance with Class[] BY_CONTEXT_PATH, // New Instance with context path string (preferred) BY_CLASS_ARRAY_PLUS_ARRAYS, // New Instance with Class[] plus arrays of each class are added UNKNOWN } ; // Some packages have a known set of classes. // This map is immutable after its static creation. private static final Map<String, List<Class>> specialMap = new HashMap<String, List<Class>>(); static { // The javax.xml.ws.wsaddressing package has a single class (W3CEndpointReference) List<Class> classes = new ArrayList<Class>(); classes.add(W3CEndpointReference.class); specialMap.put("javax.xml.ws.wsaddressing", classes); } public static final String DEFAULT_NAMESPACE_REMAP = getDefaultNamespaceRemapProperty(); /** * Get a JAXBContext for the class * * @param contextPackage Set<Package> * @return JAXBContext * @throws javax.xml.bind.JAXBException * @deprecated */ public static JAXBContext getJAXBContext(TreeSet<String> contextPackages) throws JAXBException { return getJAXBContext(contextPackages, new Holder<CONSTRUCTION_TYPE>(), contextPackages.toString(), null, null); } /** * Get a JAXBContext for the class * * Note: The contextPackage object is used by multiple threads. It should be considered immutable * and not altered by this method. * * @param contextPackage Set<Package> * @param cacheKey ClassLoader * @return JAXBContext * @throws javax.xml.bind.JAXBException * @deprecated */ public static JAXBContext getJAXBContext(TreeSet<String> contextPackages, ClassLoader cacheKey) throws JAXBException { return getJAXBContext(contextPackages, new Holder<CONSTRUCTION_TYPE>(), contextPackages.toString(), cacheKey, null); } public static JAXBContext getJAXBContext(TreeSet<String> contextPackages, Holder<CONSTRUCTION_TYPE> constructionType, String key) throws JAXBException { return getJAXBContext(contextPackages, constructionType, key, null, null); } /** * Get a JAXBContext for the class * * Note: The contextPackage object is used by multiple threads. It should be considered immutable * and not altered by this method. * * @param contextPackage Set<Package> * @param contructionType (output value that indicates how the context was constructed) * @param cacheKey ClassLoader * @return JAXBContext * @throws javax.xml.bind.JAXBException */ public static JAXBContext getJAXBContext(TreeSet<String> contextPackages, Holder<CONSTRUCTION_TYPE> constructionType, String key, ClassLoader cacheKey, Map<String, ?> properties) throws JAXBException { return getJAXBContext(contextPackages, constructionType, false, key, cacheKey, properties); } /** * Get a JAXBContext for the class * * Note: The contextPackage object is used by multiple threads. It should be considered immutable * and not altered by this method. * * @param contextPackage Set<Package> * @param contructionType (output value that indicates how the context was constructed) * @param forceArrays (forces the returned JAXBContext to include the array types) * @param cacheKey ClassLoader * @return JAXBContext * @throws javax.xml.bind.JAXBException */ public static JAXBContext getJAXBContext(TreeSet<String> contextPackages, Holder<CONSTRUCTION_TYPE> constructionType, boolean forceArrays, String key, ClassLoader cacheKey, Map<String, ?> properties) throws JAXBException { // JAXBContexts for the same class can be reused and are supposed to be thread-safe if (log.isDebugEnabled()) { log.debug("Following packages are in this batch of getJAXBContext() :"); for (String pkg : contextPackages) { log.debug(pkg); } } if (JAXBUtilsMonitor.isMonitoring()) { JAXBUtilsMonitor.addPackageKey(contextPackages.toString()); } // Get or Create The InnerMap using the package key ConcurrentHashMap<ClassLoader, JAXBContextValue> innerMap = null; SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>> softRef = jaxbMap.get(key); if (softRef != null) { innerMap = softRef.get(); } if (innerMap == null) { synchronized (jaxbMap) { softRef = jaxbMap.get(key); if (softRef != null) { innerMap = softRef.get(); } if (innerMap == null) { innerMap = new ConcurrentHashMap<ClassLoader, JAXBContextValue>(); softRef = new SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>>(innerMap); jaxbMap.put(key, softRef); } } } // Now get the contextValue using either the classloader key or // the current Classloader ClassLoader cl = getContextClassLoader(); JAXBContextValue contextValue = null; if (cacheKey != null) { if (log.isDebugEnabled()) { log.debug("Using supplied classloader to retrieve JAXBContext: " + cacheKey); } contextValue = innerMap.get(cacheKey); } else { if (log.isDebugEnabled()) { log.debug("Using classloader from Thread to retrieve JAXBContext: " + cl); } contextValue = innerMap.get(cl); } // If the context value is found, but the caller requested that the JAXBContext // contain arrays, then rebuild the JAXBContext value if (forceArrays && contextValue != null && contextValue.constructionType != JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY_PLUS_ARRAYS) { if (log.isDebugEnabled()) { log.debug("Found a JAXBContextValue with constructionType=" + contextValue.constructionType + " but the caller requested a JAXBContext " + " that includes arrays. A new JAXBContext will be built"); } contextValue = null; } if (contextPackages == null) { contextPackages = new TreeSet<String>(); } if (contextValue == null) { synchronized (innerMap) { // Try to get the contextValue once more since sync was temporarily exited. ClassLoader clKey = (cacheKey != null) ? cacheKey : cl; contextValue = innerMap.get(clKey); adjustPoolSize(innerMap); if (forceArrays && contextValue != null && contextValue.constructionType != JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY_PLUS_ARRAYS) { contextValue = null; } if (contextValue == null) { // Create a copy of the contextPackages. This new TreeSet will // contain only the valid contextPackages. // Note: The original contextPackage set is accessed by multiple // threads and should not be altered. TreeSet<String> validContextPackages = new TreeSet<String>(contextPackages); List<String> classRefs = pruneDirectives(validContextPackages); int numPackages = validContextPackages.size(); contextValue = createJAXBContextValue(validContextPackages, clKey, forceArrays, properties, classRefs); synchronized (jaxbMap) { // Add the context value with the original package set ConcurrentHashMap<ClassLoader, JAXBContextValue> map1 = null; SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>> softRef1 = jaxbMap.get(key); if (softRef1 != null) { map1 = softRef1.get(); } if (map1 == null) { map1 = new ConcurrentHashMap<ClassLoader, JAXBContextValue>(); softRef1 = new SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>>(map1); jaxbMap.put(key, softRef1); } map1.put(clKey, contextValue); String validPackagesKey = validContextPackages.toString(); // Add the context value with the new package set ConcurrentHashMap<ClassLoader, JAXBContextValue> map2 = null; SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>> softRef2 = jaxbMap .get(validPackagesKey); if (softRef2 != null) { map2 = softRef2.get(); } if (map2 == null) { map2 = new ConcurrentHashMap<ClassLoader, JAXBContextValue>(); softRef2 = new SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>>(map2); jaxbMap.put(validPackagesKey, softRef2); } map2.put(clKey, contextValue); if (log.isDebugEnabled()) { log.debug("JAXBContext [created] for " + key); log.debug("JAXBContext also stored by the list of valid packages:" + validPackagesKey); } } } } } else { if (log.isDebugEnabled()) { log.debug("JAXBContext [from pool] for " + key); } } if (log.isDebugEnabled()) { log.debug("JAXBContext constructionType= " + contextValue.constructionType); log.debug("JAXBContextValue = " + JavaUtils.getObjectIdentity(contextValue)); log.debug("JAXBContext = " + JavaUtils.getObjectIdentity(contextValue.jaxbContext)); } constructionType.value = contextValue.constructionType; return contextValue.jaxbContext; } /** * The contextPackages may declare overrides. * Example: * "com.A" * "com.B" * "com.C" * "@com.A" <-- Indicates a reference to a class (versus ns 2 pkg conversion) * "com.A > com.B" <-- This says com.A overrides com.B * * This method prunes the overrides and overriden packages. * Example return: * "com.A" * "com.C" * @param contextPackages * @return List<String> class references */ protected static List<String> pruneDirectives(TreeSet<String> contextPackages) { List<String> removePkgsList = new ArrayList<String>(); List<String> strongPkgsList = new ArrayList<String>(); List<String> classRefs = new ArrayList<String>(); // Walk the contextPackages looking for entries representing directives Iterator<String> it = contextPackages.iterator(); while (it.hasNext()) { String entry = it.next(); // If the entry contains an override character if (entry.contains(">")) { if (log.isDebugEnabled()) { log.debug("Override found:" + entry); } // Remove the entry using an iterator remove() it.remove(); // Store the overridden package String removePkg = entry.substring(entry.indexOf(">") + 1); removePkg = removePkg.trim(); removePkgsList.add(removePkg); } if (entry.startsWith("@")) { if (log.isDebugEnabled()) { log.debug("Strong (class) reference found:" + entry); } // Remove the entry using an iterator remove() it.remove(); // Store the overridden package String strongPkg = entry.substring(1); strongPkg = strongPkg.trim(); strongPkgsList.add(strongPkg); } if (entry.startsWith("[")) { if (log.isDebugEnabled()) { log.debug("Class Reference found:" + entry); } // Remove the entry using an iterator remove() it.remove(); // Store the class String cls = entry.substring(1, entry.length() - 1); classRefs.add(cls); } } // Now walk the contextPackages and remove the overriden packages it = contextPackages.iterator(); while (it.hasNext()) { String entry = it.next(); // If the entry contains an override character if (removePkgsList.contains(entry)) { if (log.isDebugEnabled()) { log.debug("Removing override package:" + entry); } // Remove the overridden package using an iterator remove() it.remove(); } } // Now add back all of the strong packages contextPackages.addAll(strongPkgsList); return classRefs; } /** * Create a JAXBContext using the contextPackages * * @param contextPackages Set<String> * @param cl ClassLoader * @param forceArrays boolean (true if JAXBContext must include all arrays) * @param properties Map of properties for the JAXBContext.newInstance creation method * @param classRefs List of class references * @return JAXBContextValue (JAXBContext + constructionType) * @throws javax.xml.bind.JAXBException */ private static JAXBContextValue createJAXBContextValue(TreeSet<String> contextPackages, ClassLoader cl, boolean forceArrays, Map<String, ?> properties, List<String> classRefs) throws JAXBException { JAXBContextValue contextValue = null; if (log.isDebugEnabled()) { log.debug("Following packages are in this batch of getJAXBContext() :"); for (String pkg : contextPackages) { log.debug(pkg); } log.debug("This classloader will be used to construct the JAXBContext" + cl); } // The contextPackages is a set of package names that are constructed using PackageSetBuilder. // PackageSetBuilder gets the packages names from various sources. // a) It walks the various annotations on the WebService collecting package names. // b) It walks the wsdl/schemas and builds package names for each target namespace. // // The combination of these two sources should produce all of the package names. // ------------- // Note that (b) is necessary for the following case: // An operation has a parameter named BASE. // Object DERIVED is an extension of BASE and is defined in a different package/schema. // In this case, there will not be any annotations on the WebService that reference DERIVED. // The only way to find the package for DERIVED is to walk the schemas. // ------------- Iterator<String> it = contextPackages.iterator(); while (it.hasNext()) { String p = it.next(); // Don't consider java and javax packages // REVIEW: We might have to refine this if (p.startsWith("javax.xml.ws.wsaddressing")) { continue; } if (p.startsWith("java.") || p.startsWith("javax.")) { it.remove(); } } // There are two ways to construct the context. // 1) USE A CONTEXTPATH, which is a string containing // all of the packages separated by colons. // 2) USE A CLASS[], which is an array of all of the classes // involved in the marshal/unmarshal. // // There are pros/cons with both approaches. // USE A CONTEXTPATH: // Pros: preferred way of doing this. // performant // most dynamic // Cons: Each package in context path must have an ObjectFactory // // // USE CLASS[]: // Pros: Doesn't require ObjectFactory in each package // Cons: Hard to set up, must account for JAX-WS classes, etc. // Does not work if arrays of classes are needed // slower // // The following code attempts to build a context path. It then // choose one of the two constructions above (prefer USE A CONTEXT_PATH) // // The packages are examined to see if they have ObjectFactory/package-info classes. // Invalid packages are removed from the list it = contextPackages.iterator(); boolean contextConstruction = (!forceArrays); boolean isJAXBFound = false; while (it.hasNext()) { String p = it.next(); // See if this package has an ObjectFactory or package-info if (checkPackage(p, cl)) { // Flow to here indicates package can be used for CONTEXT construction isJAXBFound = true; if (log.isDebugEnabled()) { log.debug("Package " + p + " contains an ObjectFactory or package-info class."); } } else { // Flow to here indicates that the package is not valid for context construction. // Perhaps the package is invalid. if (log.isDebugEnabled()) { log.debug("Package " + p + " does not contain an ObjectFactory or package-info class. Searching for JAXB classes"); } List<Class> classes = null; classes = getAllClassesFromPackage(p, cl); if (classes == null || classes.size() == 0) { if (log.isDebugEnabled()) { log.debug("Package " + p + " does not have any JAXB classes. It is removed from the JAXB context path."); } it.remove(); } else { // Classes are found in the package. We cannot use the CONTEXT construction contextConstruction = false; if (log.isDebugEnabled()) { log.debug("Package " + p + " does not contain ObjectFactory, but it does contain other JAXB classes."); } } } } if (!isJAXBFound) { if (log.isDebugEnabled()) { log.debug("ObjectFactory & package-info are not found in package hierachy"); } } // The code above may have removed some packages from the list. // Retry our lookup with the updated list if (contextConstruction) { if (log.isDebugEnabled()) { log.debug("Recheck Cache Start: Some packages have been removed from the list. Rechecking cache."); } String key = contextPackages.toString(); ConcurrentHashMap<ClassLoader, JAXBContextValue> innerMap = null; SoftReference<ConcurrentHashMap<ClassLoader, JAXBContextValue>> softRef = jaxbMap.get(key); if (softRef != null) { innerMap = softRef.get(); } if (innerMap != null) { contextValue = innerMap.get(cl); if (forceArrays && contextValue != null && contextValue.constructionType != JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY_PLUS_ARRAYS) { if (log.isDebugEnabled()) { log.debug("Found a JAXBContextValue with constructionType=" + contextValue.constructionType + " but the caller requested a JAXBContext " + " that includes arrays. A new JAXBContext will be built"); } contextValue = null; } if (contextValue != null) { if (log.isDebugEnabled()) { log.debug("Successfully found JAXBContext with updated context list:" + contextValue.jaxbContext.toString()); } return contextValue; } } if (log.isDebugEnabled()) { log.debug("Recheck Cache End: Did not find a JAXBContext. Will build a new JAXBContext."); } } // CONTEXT construction if (contextConstruction) { if (log.isDebugEnabled()) { log.debug("Try building a JAXBContext using the packages only."); } JAXBContext context = createJAXBContextUsingContextPath(contextPackages, cl, classRefs); if (context != null) { contextValue = new JAXBContextValue(context, CONSTRUCTION_TYPE.BY_CONTEXT_PATH); } if (log.isDebugEnabled()) { log.debug("Building a JAXBContext with packages only success=" + (contextValue != null)); } } // CLASS construction if (contextValue == null) { if (log.isDebugEnabled()) { log.debug("Try building a JAXBContext using a list of classes."); log.debug("Start finding classes"); } it = contextPackages.iterator(); List<Class> fullList = new ArrayList<Class>(); while (it.hasNext()) { String pkg = it.next(); fullList.addAll(getAllClassesFromPackage(pkg, cl)); } //Lets add all common array classes addCommonArrayClasses(fullList); Class[] classArray = fullList.toArray(new Class[0]); if (log.isDebugEnabled()) { log.debug("End finding classes"); } JAXBContext context = JAXBContext_newInstance(classArray, cl, properties, classRefs); if (context != null) { if (forceArrays) { contextValue = new JAXBContextValue(context, CONSTRUCTION_TYPE.BY_CLASS_ARRAY_PLUS_ARRAYS); } else { contextValue = new JAXBContextValue(context, CONSTRUCTION_TYPE.BY_CLASS_ARRAY); } } } if (log.isDebugEnabled()) { log.debug("Successfully created JAXBContext " + contextValue.jaxbContext.toString()); } return contextValue; } /** * Get the unmarshaller. You must call releaseUnmarshaller to put it back into the pool * * @param context JAXBContext * @return Unmarshaller * @throws javax.xml.bind.JAXBException */ public static Unmarshaller getJAXBUnmarshaller(JAXBContext context) throws JAXBException { if (!ENABLE_UNMARSHALL_POOLING) { if (log.isDebugEnabled()) { log.debug("Unmarshaller created [no pooling]"); } return internalCreateUnmarshaller(context); } Unmarshaller unm = upool.get(context); if (unm == null) { if (log.isDebugEnabled()) { log.debug("Unmarshaller created [not in pool]"); } unm = internalCreateUnmarshaller(context); } else { if (log.isDebugEnabled()) { log.debug("Unmarshaller obtained [from pool]"); } } return unm; } private static Unmarshaller internalCreateUnmarshaller(final JAXBContext context) throws JAXBException { Unmarshaller unm; try { unm = (Unmarshaller) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws JAXBException { return context.createUnmarshaller(); } }); } catch (PrivilegedActionException e) { throw (JAXBException) e.getCause(); } return unm; } private static Marshaller internalCreateMarshaller(final JAXBContext context) throws JAXBException { Marshaller marshaller; try { marshaller = (Marshaller) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws JAXBException { return context.createMarshaller(); } }); } catch (PrivilegedActionException e) { throw (JAXBException) e.getCause(); } return marshaller; } /** * Release Unmarshaller Do not call this method if an exception occurred while using the * Unmarshaller. We object my be in an invalid state. * * @param context JAXBContext * @param unmarshaller Unmarshaller */ public static void releaseJAXBUnmarshaller(JAXBContext context, Unmarshaller unmarshaller) { if (log.isDebugEnabled()) { log.debug("Unmarshaller placed back into pool"); } if (ENABLE_UNMARSHALL_POOLING) { unmarshaller.setAttachmentUnmarshaller(null); upool.put(context, unmarshaller); } } /** * Get JAXBMarshaller * * @param context JAXBContext * @return Marshaller * @throws javax.xml.bind.JAXBException */ public static Marshaller getJAXBMarshaller(JAXBContext context) throws JAXBException { Marshaller m = null; if (!ENABLE_MARSHALL_POOLING) { if (log.isDebugEnabled()) { log.debug("Marshaller created [no pooling]"); } m = internalCreateMarshaller(context); } else { m = mpool.get(context); if (m == null) { if (log.isDebugEnabled()) { log.debug("Marshaller created [not in pool]"); } m = internalCreateMarshaller(context); } else { if (log.isDebugEnabled()) { log.debug("Marshaller obtained [from pool]"); } } } m.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE); // No PIs return m; } /** * releaseJAXBMarshalller * Do not call this method if an exception occurred while using the * Marshaller. We don't want an object in an invalid state. * * @param context JAXBContext * @param marshaller Marshaller */ public static void releaseJAXBMarshaller(JAXBContext context, Marshaller marshaller) { if (log.isDebugEnabled()) { log.debug("Marshaller placed back into pool"); log.debug(" Marshaller = " + JavaUtils.getObjectIdentity(marshaller)); log.debug(" JAXBContext = " + JavaUtils.getObjectIdentity(context)); } if (ENABLE_MARSHALL_POOLING) { // Make sure to clear any state or properties try { marshaller.setAttachmentMarshaller(null); // Set the JAXB_ENCODING back to the default value UTF-8 marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8"); mpool.put(context, marshaller); } catch (Throwable t) { // Log the problem, and continue without pooling if (log.isDebugEnabled()) { log.debug("The following exception is ignored. Processing continues " + t); } } } } /** * get JAXB Introspector * * @param context JAXBContext * @return JAXBIntrospector * @throws javax.xml.bind.JAXBException */ public static JAXBIntrospector getJAXBIntrospector(final JAXBContext context) throws JAXBException { JAXBIntrospector i = null; if (!ENABLE_INTROSPECTION_POOLING) { if (log.isDebugEnabled()) { log.debug("JAXBIntrospector created [no pooling]"); } i = internalCreateIntrospector(context); } else { i = ipool.get(context); if (i == null) { if (log.isDebugEnabled()) { log.debug("JAXBIntrospector created [not in pool]"); } i = internalCreateIntrospector(context); } else { if (log.isDebugEnabled()) { log.debug("JAXBIntrospector obtained [from pool]"); } } } return i; } private static JAXBIntrospector internalCreateIntrospector(final JAXBContext context) { JAXBIntrospector i; i = (JAXBIntrospector) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return context.createJAXBIntrospector(); } }); return i; } /** * Release JAXBIntrospector Do not call this method if an exception occurred while using the * JAXBIntrospector. We object my be in an invalid state. * * @param context JAXBContext * @param introspector JAXBIntrospector */ public static void releaseJAXBIntrospector(JAXBContext context, JAXBIntrospector introspector) { if (log.isDebugEnabled()) { log.debug("JAXBIntrospector placed back into pool"); } if (ENABLE_INTROSPECTION_POOLING) { ipool.put(context, introspector); } } /** * @param p Package * @param cl * @return true if each package has a ObjectFactory class or package-info */ private static boolean checkPackage(String p, ClassLoader cl) { // Each package must have an ObjectFactory if (log.isDebugEnabled()) { log.debug("checking package :" + p); } try { Class cls = forName(p + ".ObjectFactory", false, cl); if (cls != null) { return true; } } catch (Throwable e) { //Catch Throwable as ClassLoader can throw an NoClassDefFoundError that //does not extend Exception. So we will absorb any Throwable exception here. if (log.isDebugEnabled()) { log.debug("ObjectFactory Class Not Found " + e); } } try { Class cls = forName(p + ".package-info", false, cl); if (cls != null) { return true; } } catch (Throwable e) { //Catch Throwable as ClassLoader can throw an NoClassDefFoundError that //does not extend Exception. So we will absorb any Throwable exception here. if (log.isDebugEnabled()) { log.debug("package-info Class Not Found " + e); } } return false; } /** * Create a JAXBContext using the contextpath approach * * @param packages * @param cl ClassLoader * @param List<String> classRefs * @return JAXBContext or null if unsuccessful */ private static JAXBContext createJAXBContextUsingContextPath(TreeSet<String> packages, ClassLoader cl, List<String> classRefs) { JAXBContext context = null; String contextpath = ""; // Iterate through the classes and build the contextpath Iterator<String> it = packages.iterator(); while (it.hasNext()) { String p = it.next(); if (contextpath.length() != 0) { contextpath += ":"; } contextpath += p; } try { if (log.isDebugEnabled()) { log.debug("Attempting to create JAXBContext with contextPath=" + contextpath); } context = JAXBContext_newInstance(contextpath, cl); if (!containsClasses(context, classRefs)) { if (log.isDebugEnabled()) { log.debug(" Unsuccessful: Will now use an alterative JAXBConstruct construction"); } return null; } if (log.isDebugEnabled()) { log.debug(" Successfully created JAXBContext:" + context); } } catch (Throwable e) { if (log.isDebugEnabled()) { log.debug(" Unsuccessful: We will now use an alterative JAXBConstruct construction"); log.debug(" Reason " + e.toString()); } } return context; } /** * containsClasses * @param JAXBContext * @param List<String> classRefs */ private static boolean containsClasses(JAXBContext context, List<String> classRefs) { String text = context.toString(); text = text.replace('\n', ' '); text = text.replace('\t', ' '); text = text.replace('\r', ' '); text = text.replace('<', ' '); text = text.replace('[', ' '); text = text.replace(']', ' '); for (String classRef : classRefs) { // Strip off generic and array chars int index = classRef.indexOf('<'); if (index > 0) { classRef = classRef.substring(0, index); } index = classRef.indexOf('['); if (index > 0) { classRef = classRef.substring(0, index); } if (classRef.length() == 0 || classRef.endsWith(".ObjectFactory") || classRef.startsWith("java.util.") || classRef.startsWith("java.lang.")) { // skip these } else { String search = " " + classRef + " "; if (!text.contains(search)) { if (log.isDebugEnabled()) { log.debug("The context does not contain " + classRef + " " + context); } return false; } } } return true; } /** * This method will return all the Class names needed to construct a JAXBContext * * @param pkg Package * @param ClassLoader cl * @return * @throws ClassNotFoundException if error occurs getting package */ private static List<Class> getAllClassesFromPackage(String pkg, ClassLoader cl) { if (log.isDebugEnabled()) { log.debug("Start: getAllClassesFromPackage for " + pkg); } if (pkg == null) { if (log.isDebugEnabled()) { log.debug("End: getAllClassesFromPackage (package is null)"); } return new ArrayList<Class>(); } // See if this is a special package that has a set of known classes. List<Class> knownClasses = specialMap.get(pkg); if (knownClasses != null) { if (log.isDebugEnabled()) { try { log.debug("End: getAllClassesFromPackage (package is special) returning: " + knownClasses); } catch (Throwable t) { // In case classes cannot be toString'd log.debug("End: getAllClassesFromPackage (package is special)"); } } return knownClasses; } /* * This method is a best effort method. We should always return an object. */ ArrayList<Class> classes = new ArrayList<Class>(); if (log.isDebugEnabled()) { log.debug("Start: Obtain packages from similar directory"); } try { // List<Class> classesFromDir = getClassesFromDirectory(pkg, cl); checkClasses(classesFromDir, pkg); classes.addAll(classesFromDir); } catch (ClassNotFoundException e) { if (log.isDebugEnabled()) { log.debug("getClassesFromDirectory failed to get Classes"); } } if (log.isDebugEnabled()) { log.debug("End: Obtain packages from similar directory"); log.debug("Start: Obtain packages from ClassFinder plugin"); } try { //This will load classes from jar file. ClassFinderFactory cff = new ClassFinderFactory(); List<Class> classesFromJar = cff.getClassFinder().getClassesFromJarFile(pkg, cl); checkClasses(classesFromJar, pkg); classes.addAll(classesFromJar); } catch (ClassNotFoundException e) { if (log.isDebugEnabled()) { log.debug("getClassesFromJarFile failed to get Classes"); } } if (log.isDebugEnabled()) { log.debug("End: Obtain packages from ClassFinder plugin"); } if (log.isDebugEnabled()) { log.debug("End: Obtain packages from ClassFinder plugin"); } if (log.isDebugEnabled()) { try { log.debug("End: getAllClassesFromPackage for " + pkg + "with classes " + classes); } catch (Throwable e) { // In case classes cannot be toString'd log.debug("End: getAllClassesFromPackage for " + pkg); } } return classes; } /** * @param list * @param pkg */ private static void checkClasses(List<Class> list, String pkg) { // The installed classfinder or directory search may inadvertently add too many // classes. This rountine is a 'double check' to make sure that the classes // are acceptable. for (int i = 0; i < list.size();) { Class cls = list.get(i); if (!cls.isInterface() && (cls.isEnum() || getAnnotation(cls, XmlType.class) != null || ClassUtils.getDefaultPublicConstructor(cls) != null) && !ClassUtils.isJAXWSClass(cls) && !isSkipClass(cls) && cls.getPackage().getName().equals(pkg)) { i++; // Acceptable class } else { if (log.isDebugEnabled()) { log.debug("Removing class " + cls + " from consideration because it is not in package " + pkg + " or is an interface or does not have a public constructor or is" + " a jaxws class"); } list.remove(i); } } } private static ArrayList<Class> getClassesFromDirectory(String pkg, ClassLoader cl) throws ClassNotFoundException { // This will hold a list of directories matching the pckgname. There may be more than one if a package is split over multiple jars/paths String pckgname = pkg; ArrayList<File> directories = new ArrayList<File>(); try { String path = pckgname.replace('.', '/'); // Ask for all resources for the path Enumeration<URL> resources = cl.getResources(path); while (resources.hasMoreElements()) { directories.add(new File(URLDecoder.decode(resources.nextElement().getPath(), "UTF-8"))); } } catch (UnsupportedEncodingException e) { if (log.isDebugEnabled()) { log.debug(pckgname + " does not appear to be a valid package (Unsupported encoding)"); } throw new ClassNotFoundException( pckgname + " might not be a valid package because the encoding is unsupported."); } catch (IOException e) { if (log.isDebugEnabled()) { log.debug("IOException was thrown when trying to get all resources for " + pckgname); } throw new ClassNotFoundException( "An IOException error was thrown when trying to get all of the resources for " + pckgname); } ArrayList<Class> classes = new ArrayList<Class>(); // For every directory identified capture all the .class files for (File directory : directories) { if (log.isDebugEnabled()) { log.debug(" Adding JAXB classes from directory: " + directory.getName()); } if (directory.exists()) { // Get the list of the files contained in the package String[] files = directory.list(); for (String file : files) { // we are only interested in .class files if (file.endsWith(".class")) { // removes the .class extension // TODO Java2 Sec String className = pckgname + '.' + file.substring(0, file.length() - 6); try { Class clazz = forName(className, false, getContextClassLoader()); // Don't add any interfaces or JAXWS specific classes. // Only classes that represent data and can be marshalled // by JAXB should be added. if (!clazz.isInterface() && (clazz.isEnum() || getAnnotation(clazz, XmlType.class) != null || ClassUtils.getDefaultPublicConstructor(clazz) != null) && !ClassUtils.isJAXWSClass(clazz) && !isSkipClass(clazz) && !Exception.class.isAssignableFrom(clazz)) { // Ensure that all the referenced classes are loadable too clazz.getDeclaredMethods(); clazz.getDeclaredFields(); if (log.isDebugEnabled()) { log.debug("Adding class: " + file); } classes.add(clazz); // REVIEW: // Support of RPC list (and possibly other scenarios) requires that the array classes should also be present. // This is a hack until we can determine how to get this information. // The arrayName and loadable name are different. Get the loadable // name, load the array class, and add it to our list //className += "[]"; //String loadableName = ClassUtils.getLoadableClassName(className); //Class aClazz = Class.forName(loadableName, false, Thread.currentThread().getContextClassLoader()); } //Catch Throwable as ClassLoader can throw an NoClassDefFoundError that //does not extend Exception } catch (Throwable e) { if (log.isDebugEnabled()) { log.debug("Tried to load class " + className + " while constructing a JAXBContext. This class will be skipped. Processing Continues."); log.debug(" The reason that class could not be loaded:" + e.toString()); log.trace(JavaUtils.stackToString(e)); } } } } } } return classes; } private static String[] commonArrayClasses = new String[] { // primitives "boolean[]", "byte[]", "char[]", "double[]", "float[]", "int[]", "long[]", "short[]", "java.lang.String[]", // Others "java.lang.Object[]", "java.awt.Image[]", "java.math.BigDecimal[]", "java.math.BigInteger[]", "java.util.Calendar[]", "javax.xml.namespace.QName[]" }; private static void addCommonArrayClasses(List<Class> list) { // Add common primitives arrays (necessary for RPC list type support) ClassLoader cl = getContextClassLoader(); for (int i = 0; i < commonArrayClasses.length; i++) { String className = commonArrayClasses[i]; try { // Load and add the class Class cls = forName(ClassUtils.getLoadableClassName(className), false, cl); list.add(cls); //Catch Throwable as ClassLoader can throw an NoClassDefFoundError that //does not extend Exception } catch (Throwable e) { if (log.isDebugEnabled()) { log.debug("Tried to load class " + className + " while constructing a JAXBContext. This class will be skipped. Processing Continues."); log.debug(" The reason that class could not be loaded:" + e.toString()); log.trace(JavaUtils.stackToString(e)); } } } } /** @return ClassLoader */ private static ClassLoader getContextClassLoader() { // NOTE: This method must remain private because it uses AccessController ClassLoader cl = null; try { cl = (ClassLoader) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return Thread.currentThread().getContextClassLoader(); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw new RuntimeException(e.getException()); } return cl; } /** * @return true if clazz is a class that should be skipped (should not * be a considered for JAXB) */ private static boolean isSkipClass(Class clazz) { Class cls = clazz; while (cls != null) { // Check the name of the class to see if it should be excluded. String clsName = cls.getCanonicalName(); if (clsName != null && (clsName.equals("javax.ejb.SessionBean") || clsName.equals("org.apache.axis2.jaxws.spi.JAXBExclude"))) { if (log.isDebugEnabled()) { log.debug("isSkipClass returns true for : " + clazz); log.debug(" (It is skipped because the class extends " + clsName); } return true; } // Check the interfaces of the class to see if it should be excluded Class[] intferfaces = getInterfaces_priv(cls); if (intferfaces != null) { for (int i = 0; i < intferfaces.length; i++) { clsName = intferfaces[i].getCanonicalName(); if (clsName != null && (clsName.equals("javax.ejb.SessionBean") || clsName.equals("org.apache.axis2.jaxws.spi.JAXBExclude"))) { if (log.isDebugEnabled()) { log.debug("isSkipClass returns true for : " + clazz); log.debug(" (It is skipped because the class implements " + clsName); } return true; } } } cls = cls.getSuperclass(); // Proceed up the hierarchy } if (log.isDebugEnabled()) { log.debug("isSkipClass returns false for : " + clazz); } return false; } private static Class[] getInterfaces_priv(final Class cls) { Class[] intferfaces = null; if (cls == null) { return null; } try { intferfaces = (Class[]) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return cls.getInterfaces(); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); log.debug("Exception is ignored."); } } return intferfaces; } /** * Return the class for this name * * @return Class */ private static Class forName(final String className, final boolean initialize, final ClassLoader classloader) throws ClassNotFoundException { // NOTE: This method must remain private because it uses AccessController Class cl = null; try { cl = (Class) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { // Class.forName does not support primitives Class cls = ClassUtils.getPrimitiveClass(className); if (cls == null) { cls = Class.forName(className, initialize, classloader); } return cls; } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw (ClassNotFoundException) e.getException(); } return cl; } /** * Create JAXBContext from context String and ClassLoader * * @param context * @param classloader * @return * @throws Exception */ private static JAXBContext JAXBContext_newInstance(final String context, final ClassLoader classloader) throws Exception { // NOTE: This method must remain private because it uses AccessController JAXBContext jaxbContext = null; try { if (log.isDebugEnabled()) { if (context == null || context.length() == 0) { log.debug("JAXBContext is constructed without a context String."); } else { log.debug("JAXBContext is constructed with a context of:" + context); } } jaxbContext = (JAXBContext) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws JAXBException { return JAXBContext.newInstance(context, classloader); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw e.getException(); } return jaxbContext; } /** * Create JAXBContext from Class[] * * @param classArray * @param cl ClassLoader that loaded the classes * @param properties Map<String, ?> * @param ClassRefs List<String> * @return * @throws Exception */ private static JAXBContext JAXBContext_newInstance(final Class[] classArray, final ClassLoader cl, Map<String, ?> properties, List<String> classRefs) throws JAXBException { // NOTE: This method must remain private because it uses AccessController JAXBContext jaxbContext = null; if (log.isDebugEnabled()) { if (classArray == null || classArray.length == 0) { log.debug("JAXBContext is constructed with 0 input classes."); } else { log.debug("JAXBContext is constructed with " + classArray.length + " input classes."); } } // Get JAXBContext from classes jaxbContext = JAXBContextFromClasses.newInstance(classArray, cl, properties, classRefs); return jaxbContext; } /** Holds the JAXBContext and the manner by which it was constructed */ static class JAXBContextValue { public JAXBContext jaxbContext; public CONSTRUCTION_TYPE constructionType; public JAXBContextValue(JAXBContext jaxbContext, CONSTRUCTION_TYPE constructionType) { this.jaxbContext = jaxbContext; this.constructionType = constructionType; } } static private void adjustPoolSize(Map map) { if (map.size() > MAX_LOAD_FACTOR) { // Remove every other Entry in the map. Iterator it = map.entrySet().iterator(); boolean removeIt = false; while (it.hasNext()) { it.next(); if (removeIt) { it.remove(); } removeIt = !removeIt; } } } /** * Pool a list of items for a specific key * * @param <K> Key * @param <V> Pooled object */ private static class Pool<K, V> { private SoftReference<Map<K, List<V>>> softMap = new SoftReference<Map<K, List<V>>>( new ConcurrentHashMap<K, List<V>>()); // The maps are freed up when a LOAD FACTOR is hit private static int MAX_LIST_FACTOR = 50; // Limit the adjustSize calls private int count = 0; /** * @param key * @return removed item from pool or null. */ public V get(K key) { List<V> values = getValues(key); synchronized (values) { if (values.size() > 0) { V v = values.remove(values.size() - 1); return v; } } return null; } /** * Add item back to pool * @param key * @param value */ public void put(K key, V value) { adjustSize(); List<V> values = getValues(key); synchronized (values) { if (values.size() < MAX_LIST_FACTOR) { values.add(value); } } } /** * Get or create a list of the values for the key * @param key * @return list of values. */ private List<V> getValues(K key) { Map<K, List<V>> map = softMap.get(); List<V> values = null; if (map != null) { values = map.get(key); if (values != null) { return values; } } synchronized (this) { if (map != null) { values = map.get(key); } if (values == null) { if (map == null) { map = new ConcurrentHashMap<K, List<V>>(); softMap = new SoftReference<Map<K, List<V>>>(map); } values = new ArrayList<V>(); map.put(key, values); } return values; } } /** * AdjustSize * When the number of keys exceeds the maximum load, half * of the entries are deleted. * * The assumption is that the JAXBContexts, UnMarshallers, Marshallers, etc. require * a large footprint. */ private void adjustSize() { // Don't check each time, map.size() can be expensive count++; if (count < 10) { return; } count = 0; Map<K, List<V>> map = softMap.get(); if (map != null && map.size() > MAX_LOAD_FACTOR) { // Remove every other Entry in the map. Iterator it = map.entrySet().iterator(); boolean removeIt = false; while (it.hasNext()) { it.next(); if (removeIt) { it.remove(); } removeIt = !removeIt; } } } } private static Annotation getAnnotation(final AnnotatedElement element, final Class annotation) { return (Annotation) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return element.getAnnotation(annotation); } }); } private static String getDefaultNamespaceRemapProperty() { String external = "com.sun.xml.bind.defaultNamespaceRemap"; String internal = "com.sun.xml.internal.bind.defaultNamespaceRemap"; Boolean isExternal = testJAXBProperty(external); if (Boolean.TRUE.equals(isExternal)) { return external; } Boolean isInternal = testJAXBProperty(internal); if (Boolean.TRUE.equals(isInternal)) { return internal; } // hmm... both properties cannot be set return external; } private static Boolean testJAXBProperty(String propName) { final Map<String, String> props = new HashMap<String, String>(); props.put(propName, "http://test"); try { AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws JAXBException { return JAXBContext.newInstance(new Class[] { Integer.class }, props); } }); return Boolean.TRUE; } catch (PrivilegedActionException e) { if (e.getCause() instanceof JAXBException) { return Boolean.FALSE; } return null; } } }