release13.07/framework/base/src/org/ofbiz/base/util/CachedClassLoader.java - ofbiz - Git at Google

 /*******************************************************************************
  * 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.ofbiz.base.util;

 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArraySet;

 /**
  * Caching Class Loader
  *
  */
 public class CachedClassLoader extends URLClassLoader {

     public interface Init {
         void loadClasses(ClassLoader loader) throws ClassNotFoundException;
     }

     public static final String module = CachedClassLoader.class.getName();
     public static final ConcurrentHashMap<String, Class<?>> globalClassNameClassMap = new ConcurrentHashMap<String, Class<?>>();
     private static final Set<String> globalBadClassNameSet = new CopyOnWriteArraySet<String>();
     private static final ConcurrentHashMap<String, URL> globalResourceMap = new ConcurrentHashMap<String, URL>();
     private static final Set<String> globalBadResourceNameSet = new CopyOnWriteArraySet<String>();

     private final String contextName;
     private final ConcurrentHashMap<String, Class<?>> localClassNameClassMap = new ConcurrentHashMap<String, Class<?>>();
     private final Set<String> localBadClassNameSet = new CopyOnWriteArraySet<String>();
     private final ConcurrentHashMap<String, URL> localResourceMap = new ConcurrentHashMap<String, URL>();
     private final Set<String> localBadResourceNameSet = new CopyOnWriteArraySet<String>();

     static {
         // setup some commonly used classes...
         registerClass(java.lang.Object.class);
         registerClass(java.lang.String.class);
         registerClass(java.lang.Boolean.class);
         registerClass(java.math.BigDecimal.class);
         registerClass(java.lang.Double.class);
         registerClass(java.lang.Float.class);
         registerClass(java.lang.Long.class);
         registerClass(java.lang.Integer.class);
         registerClass(java.lang.Short.class);
         registerClass(java.lang.Byte.class);
         registerClass(java.lang.Character.class);
         registerClass(java.sql.Timestamp.class);
         registerClass(java.sql.Time.class);
         registerClass(java.sql.Date.class);
         registerClass(java.util.Locale.class);
         registerClass(java.util.Date.class);
         registerClass(java.util.Collection.class);
         registerClass(java.util.List.class);
         registerClass(java.util.Set.class);
         registerClass(java.util.Map.class);
         registerClass(java.util.HashMap.class);
         registerClass(java.util.TimeZone.class);
         registerClass(java.util.Locale.class);

         // setup the primitive types
         registerClass(Boolean.TYPE);
         registerClass(Short.TYPE);
         registerClass(Integer.TYPE);
         registerClass(Long.TYPE);
         registerClass(Float.TYPE);
         registerClass(Double.TYPE);
         registerClass(Byte.TYPE);
         registerClass(Character.TYPE);

         // setup OFBiz classes
         registerClass(org.ofbiz.base.util.TimeDuration.class);

         ClassLoader loader = Thread.currentThread().getContextClassLoader();
         for(Init cachedClassLoader : ServiceLoader.load(Init.class, loader)) {
             try {
                 cachedClassLoader.loadClasses(loader);
             } catch (Exception e) {
                 Debug.logError(e, "Could not pre-initialize dynamically loaded class: ", module);
             }
         }
     }

     /** Registers a <code>Class</code> with the class loader. The class will be
      * added to the global class cache, and an alias name will be created.
      * <p>The alias name is the right-most portion of the binary name. Example:
      * the alias for <code>java.lang.Object</code> is <code>Object</code>.
      * If the alias already exists for another class, then no alias is created
      * (the previously aliased class takes precedence).</p>
      *
      * @param theClass The <code>Class</code> to register
      * @throws IllegalArgumentException If <code>theClass</code> is an array
      */
     public static void registerClass(Class<?> theClass) {
         if (theClass.isArray()) {
             throw new IllegalArgumentException("theClass cannot be an array");
         }
         Object obj = globalClassNameClassMap.get(theClass.getName());
         if (obj == null) {
             globalClassNameClassMap.putIfAbsent(theClass.getName(), theClass);
         }
         String alias = theClass.getName();
         int pos = alias.lastIndexOf(".");
         if (pos != -1) {
             alias = alias.substring(pos + 1);
         }
         obj = globalClassNameClassMap.get(alias);
         if (obj == null) {
             globalClassNameClassMap.putIfAbsent(alias, theClass);
         }
         if (Debug.verboseOn()) {
             Debug.logVerbose("Registered class " + theClass.getName() + ", alias " + alias, module);
         }
     }

     public CachedClassLoader(URL[] url, ClassLoader parent, String contextName) {
         super(url, parent);
         this.contextName = contextName;
         if (Debug.verboseOn()) {
             Package[] paks = this.getPackages();
             StringBuilder pakList = new StringBuilder();
             for (int i = 0; i < paks.length; i++) {
                 pakList.append(paks[i].getName());
                 if (i < (paks.length - 1)) {
                     pakList.append(":");
                 }
             }
             Debug.logVerbose("Cached ClassLoader Packages : " + pakList.toString(), module);
         }
     }

     public CachedClassLoader(ClassLoader parent, String contextName) {
         this(new URL[0], parent, contextName);
     }

     public CachedClassLoader(URL[] url, ClassLoader parent) {
         this(url, parent, "__globalContext");
     }

     @Override
     public String toString() {
         return "org.ofbiz.base.util.CachedClassLoader(" + contextName + ") / " + getParent().toString();
     }

     @Override
     public Class<?> loadClass(String name) throws ClassNotFoundException {
         return loadClass(name, false);
     }

     @Override
     protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
         // check global common classes, ie for all instances
         Class<?> theClass = globalClassNameClassMap.get(name);
         if (theClass != null) {
             return theClass;
         }
         // check local classes, ie for this instance
         theClass = this.localClassNameClassMap.get(name);
         if (theClass != null) {
             return theClass;
         }
         // make sure it is not a known bad class name
         if (this.localBadClassNameSet.contains(name) || globalBadClassNameSet.contains(name)) {
             if (Debug.verboseOn()) {
                 Debug.logVerbose("Cached loader got a known bad class name: [" + name + "]", module);
             }
             throw new ClassNotFoundException("Cached loader got a known bad class name: " + name);
         }
         if (Debug.verboseOn()) {
             Debug.logVerbose("Cached loader cache miss for class name: [" + name + "]", module);
         }
         try {
             theClass = super.loadClass(name, resolve);
             if (isGlobalPath(name)) {
                 globalClassNameClassMap.putIfAbsent(name, theClass);
                 theClass = globalClassNameClassMap.get(name);
             } else {
                 this.localClassNameClassMap.putIfAbsent(name, theClass);
                 theClass = this.localClassNameClassMap.get(name);
             }
         } catch (ClassNotFoundException e) {
             // Debug.logInfo(e, module);
             if (Debug.verboseOn()) {
                 Debug.logVerbose("Remembering invalid class name: [" + name + "]", module);
             }
             if (isGlobalPath(name)) {
                 globalBadClassNameSet.add(name);
             } else {
                 this.localBadClassNameSet.add(name);
             }
             throw e;
         }
         return theClass;
     }

     @Override
     public URL getResource(String name) {
         // check global common resources, ie for all instances
         URL theResource = globalResourceMap.get(name);
         if (theResource != null) {
             return theResource;
         }
         // check local resources, ie for this instance
         theResource = this.localResourceMap.get(name);
         if (theResource != null) {
             return theResource;
         }
         // make sure it is not a known bad resource name
         if (localBadResourceNameSet.contains(name) || globalBadResourceNameSet.contains(name)) {
             if (Debug.verboseOn()) {
                 Debug.logVerbose("Cached loader got a known bad resource name: [" + name + "]", module);
             }
             return null;
         }
         if (Debug.verboseOn()) {
             Debug.logVerbose("Cached loader cache miss for resource name: [" + name + "]", module);
         }
         // Debug.logInfo("Cached loader cache miss for resource name: [" + name + "]", module);
         theResource = super.getResource(name);
         if (theResource == null) {
             if (Debug.verboseOn())
                 Debug.logVerbose("Remembering invalid resource name: [" + name + "]", module);
             // Debug.logInfo("Remembering invalid resource name: [" + name + "]", module);
             if (isGlobalPath(name)) {
                 globalBadResourceNameSet.add(name);
             } else {
                 this.localBadResourceNameSet.add(name);
             }
         } else {
             if (isGlobalPath(name)) {
                 globalResourceMap.putIfAbsent(name, theResource);
                 theResource = globalResourceMap.get(name);
             } else {
                 this.localResourceMap.putIfAbsent(name, theResource);
                 theResource = this.localResourceMap.get(name);
             }
         }
         return theResource;
     }

     protected boolean isGlobalPath(String name) {
         if (name.startsWith("java.") || name.startsWith("java/") || name.startsWith("/java/")) return true;
         if (name.startsWith("javax.") || name.startsWith("javax/") || name.startsWith("/javax/")) return true;
         if (name.startsWith("sun.") || name.startsWith("sun/") || name.startsWith("/sun/")) return true;
         if (name.startsWith("org.ofbiz.") || name.startsWith("org/ofbiz/")) return true;
         return false;
     }
 }
	/*******************************************************************************
	* 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.ofbiz.base.util;

	import java.net.URL;
	import java.net.URLClassLoader;
	import java.util.ServiceLoader;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.CopyOnWriteArraySet;

	/**
	* Caching Class Loader
	*
	*/
	public class CachedClassLoader extends URLClassLoader {

	public interface Init {
	void loadClasses(ClassLoader loader) throws ClassNotFoundException;
	}

	public static final String module = CachedClassLoader.class.getName();
	public static final ConcurrentHashMap<String, Class<?>> globalClassNameClassMap = new ConcurrentHashMap<String, Class<?>>();
	private static final Set<String> globalBadClassNameSet = new CopyOnWriteArraySet<String>();
	private static final ConcurrentHashMap<String, URL> globalResourceMap = new ConcurrentHashMap<String, URL>();
	private static final Set<String> globalBadResourceNameSet = new CopyOnWriteArraySet<String>();

	private final String contextName;
	private final ConcurrentHashMap<String, Class<?>> localClassNameClassMap = new ConcurrentHashMap<String, Class<?>>();
	private final Set<String> localBadClassNameSet = new CopyOnWriteArraySet<String>();
	private final ConcurrentHashMap<String, URL> localResourceMap = new ConcurrentHashMap<String, URL>();
	private final Set<String> localBadResourceNameSet = new CopyOnWriteArraySet<String>();

	static {
	// setup some commonly used classes...
	registerClass(java.lang.Object.class);
	registerClass(java.lang.String.class);
	registerClass(java.lang.Boolean.class);
	registerClass(java.math.BigDecimal.class);
	registerClass(java.lang.Double.class);
	registerClass(java.lang.Float.class);
	registerClass(java.lang.Long.class);
	registerClass(java.lang.Integer.class);
	registerClass(java.lang.Short.class);
	registerClass(java.lang.Byte.class);
	registerClass(java.lang.Character.class);
	registerClass(java.sql.Timestamp.class);
	registerClass(java.sql.Time.class);
	registerClass(java.sql.Date.class);
	registerClass(java.util.Locale.class);
	registerClass(java.util.Date.class);
	registerClass(java.util.Collection.class);
	registerClass(java.util.List.class);
	registerClass(java.util.Set.class);
	registerClass(java.util.Map.class);
	registerClass(java.util.HashMap.class);
	registerClass(java.util.TimeZone.class);
	registerClass(java.util.Locale.class);

	// setup the primitive types
	registerClass(Boolean.TYPE);
	registerClass(Short.TYPE);
	registerClass(Integer.TYPE);
	registerClass(Long.TYPE);
	registerClass(Float.TYPE);
	registerClass(Double.TYPE);
	registerClass(Byte.TYPE);
	registerClass(Character.TYPE);

	// setup OFBiz classes
	registerClass(org.ofbiz.base.util.TimeDuration.class);

	ClassLoader loader = Thread.currentThread().getContextClassLoader();
	for(Init cachedClassLoader : ServiceLoader.load(Init.class, loader)) {
	try {
	cachedClassLoader.loadClasses(loader);
	} catch (Exception e) {
	Debug.logError(e, "Could not pre-initialize dynamically loaded class: ", module);
	}
	}
	}

	/** Registers a <code>Class</code> with the class loader. The class will be
	* added to the global class cache, and an alias name will be created.
	* <p>The alias name is the right-most portion of the binary name. Example:
	* the alias for <code>java.lang.Object</code> is <code>Object</code>.
	* If the alias already exists for another class, then no alias is created
	* (the previously aliased class takes precedence).</p>
	*
	* @param theClass The <code>Class</code> to register
	* @throws IllegalArgumentException If <code>theClass</code> is an array
	*/
	public static void registerClass(Class<?> theClass) {
	if (theClass.isArray()) {
	throw new IllegalArgumentException("theClass cannot be an array");
	}
	Object obj = globalClassNameClassMap.get(theClass.getName());
	if (obj == null) {
	globalClassNameClassMap.putIfAbsent(theClass.getName(), theClass);
	}
	String alias = theClass.getName();
	int pos = alias.lastIndexOf(".");
	if (pos != -1) {
	alias = alias.substring(pos + 1);
	}
	obj = globalClassNameClassMap.get(alias);
	if (obj == null) {
	globalClassNameClassMap.putIfAbsent(alias, theClass);
	}
	if (Debug.verboseOn()) {
	Debug.logVerbose("Registered class " + theClass.getName() + ", alias " + alias, module);
	}
	}

	public CachedClassLoader(URL[] url, ClassLoader parent, String contextName) {
	super(url, parent);
	this.contextName = contextName;
	if (Debug.verboseOn()) {
	Package[] paks = this.getPackages();
	StringBuilder pakList = new StringBuilder();
	for (int i = 0; i < paks.length; i++) {
	pakList.append(paks[i].getName());
	if (i < (paks.length - 1)) {
	pakList.append(":");
	}
	}
	Debug.logVerbose("Cached ClassLoader Packages : " + pakList.toString(), module);
	}
	}

	public CachedClassLoader(ClassLoader parent, String contextName) {
	this(new URL[0], parent, contextName);
	}

	public CachedClassLoader(URL[] url, ClassLoader parent) {
	this(url, parent, "__globalContext");
	}

	@Override
	public String toString() {
	return "org.ofbiz.base.util.CachedClassLoader(" + contextName + ") / " + getParent().toString();
	}

	@Override
	public Class<?> loadClass(String name) throws ClassNotFoundException {
	return loadClass(name, false);
	}

	@Override
	protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
	// check global common classes, ie for all instances
	Class<?> theClass = globalClassNameClassMap.get(name);
	if (theClass != null) {
	return theClass;
	}
	// check local classes, ie for this instance
	theClass = this.localClassNameClassMap.get(name);
	if (theClass != null) {
	return theClass;
	}
	// make sure it is not a known bad class name
	if (this.localBadClassNameSet.contains(name) \|\| globalBadClassNameSet.contains(name)) {
	if (Debug.verboseOn()) {
	Debug.logVerbose("Cached loader got a known bad class name: [" + name + "]", module);
	}
	throw new ClassNotFoundException("Cached loader got a known bad class name: " + name);
	}
	if (Debug.verboseOn()) {
	Debug.logVerbose("Cached loader cache miss for class name: [" + name + "]", module);
	}
	try {
	theClass = super.loadClass(name, resolve);
	if (isGlobalPath(name)) {
	globalClassNameClassMap.putIfAbsent(name, theClass);
	theClass = globalClassNameClassMap.get(name);
	} else {
	this.localClassNameClassMap.putIfAbsent(name, theClass);
	theClass = this.localClassNameClassMap.get(name);
	}
	} catch (ClassNotFoundException e) {
	// Debug.logInfo(e, module);
	if (Debug.verboseOn()) {
	Debug.logVerbose("Remembering invalid class name: [" + name + "]", module);
	}
	if (isGlobalPath(name)) {
	globalBadClassNameSet.add(name);
	} else {
	this.localBadClassNameSet.add(name);
	}
	throw e;
	}
	return theClass;
	}

	@Override
	public URL getResource(String name) {
	// check global common resources, ie for all instances
	URL theResource = globalResourceMap.get(name);
	if (theResource != null) {
	return theResource;
	}
	// check local resources, ie for this instance
	theResource = this.localResourceMap.get(name);
	if (theResource != null) {
	return theResource;
	}
	// make sure it is not a known bad resource name
	if (localBadResourceNameSet.contains(name) \|\| globalBadResourceNameSet.contains(name)) {
	if (Debug.verboseOn()) {
	Debug.logVerbose("Cached loader got a known bad resource name: [" + name + "]", module);
	}
	return null;
	}
	if (Debug.verboseOn()) {
	Debug.logVerbose("Cached loader cache miss for resource name: [" + name + "]", module);
	}
	// Debug.logInfo("Cached loader cache miss for resource name: [" + name + "]", module);
	theResource = super.getResource(name);
	if (theResource == null) {
	if (Debug.verboseOn())
	Debug.logVerbose("Remembering invalid resource name: [" + name + "]", module);
	// Debug.logInfo("Remembering invalid resource name: [" + name + "]", module);
	if (isGlobalPath(name)) {
	globalBadResourceNameSet.add(name);
	} else {
	this.localBadResourceNameSet.add(name);
	}
	} else {
	if (isGlobalPath(name)) {
	globalResourceMap.putIfAbsent(name, theResource);
	theResource = globalResourceMap.get(name);
	} else {
	this.localResourceMap.putIfAbsent(name, theResource);
	theResource = this.localResourceMap.get(name);
	}
	}
	return theResource;
	}

	protected boolean isGlobalPath(String name) {
	if (name.startsWith("java.") \|\| name.startsWith("java/") \|\| name.startsWith("/java/")) return true;
	if (name.startsWith("javax.") \|\| name.startsWith("javax/") \|\| name.startsWith("/javax/")) return true;
	if (name.startsWith("sun.") \|\| name.startsWith("sun/") \|\| name.startsWith("/sun/")) return true;
	if (name.startsWith("org.ofbiz.") \|\| name.startsWith("org/ofbiz/")) return true;
	return false;
	}
	}