OverridingClassLoader


1   /*
2    * Copyright 2002-2007 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.springframework.core;
18  
19  import java.io.IOException  ;
20  import java.io.InputStream  ;
21  import java.util.Collections  ;
22  import java.util.HashSet  ;
23  import java.util.Iterator  ;
24  import java.util.Set  ;
25  
26  import org.springframework.util.Assert;
27  import org.springframework.util.FileCopyUtils;
28  
29  /**
30   * <code>ClassLoader</code> that does <i>not</i> always delegate to the
31   * parent loader, as normal class loaders do. This enables, for example,
32   * instrumentation to be forced in the overriding ClassLoader, or a
33   * "throwaway" class loading behavior, where selected classes are
34   * temporarily loaded in the overriding ClassLoader, in order to be load
35   * an instrumented version of the class in the parent ClassLoader later on.
36   *
37   * @author Rod Johnson
38   * @author Juergen Hoeller
39   * @since 2.0.1
40   */
41  public class OverridingClassLoader extends ClassLoader   {
42  
43      private static final String   CLASS_FILE_SUFFIX = ".class";
44  
45  
46      private final Set   excludedPackages = Collections.synchronizedSet(new HashSet  ());
47  
48      private final Set   excludedClasses = Collections.synchronizedSet(new HashSet  ());
49  
50  
51      /**
52       * Create a new OverridingClassLoader for the given class loader.
53       * @param parent the ClassLoader to build an overriding ClassLoader for
54       */
55      public OverridingClassLoader(ClassLoader   parent) {
56          super(parent);
57          this.excludedPackages.add("java.");
58          this.excludedPackages.add("javax.");
59      }
60  
61  
62      /**
63       * Add a package name to exclude from overriding.
64       * <p>Any class whose fully-qualified name starts with the name registered
65       * here will be handled by the parent ClassLoader in the usual fashion.
66       * @param packageName the package name to exclude
67       */
68      public void excludePackage(String   packageName) {
69          Assert.notNull(packageName, "Package name must not be null");
70          this.excludedPackages.add(packageName);
71      }
72  
73      /**
74       * Add a class name to exclude from overriding.
75       * <p>Any class name registered here will be handled by
76       * the parent ClassLoader in the usual fashion.
77       * @param className the class name to exclude
78       */
79      public void excludeClass(String   className) {
80          Assert.notNull(className, "Class name must not be null");
81          this.excludedClasses.add(className);
82      }
83  
84  
85      protected Class   loadClass(String   name, boolean resolve) throws ClassNotFoundException   {
86          Class   result = null;
87  
88          if (isEligibleForOverriding(name)) {
89              result = findLoadedClass(name);
90              if (result == null) {
91                  String   internalName = name.replace('.', '/') + CLASS_FILE_SUFFIX;
92                  InputStream   is = getParent().getResourceAsStream(internalName);
93                  if (is != null) {
94                      try {
95                          // Load the raw bytes.
96                          byte[] bytes = FileCopyUtils.copyToByteArray(is);
97                          // Transform if necessary and use the potentially transformed bytes.
98                          byte[] transformed = transformIfNecessary(name, bytes);
99                          result = defineClass(name, transformed, 0, transformed.length);
100                     }
101                     catch (IOException   ex) {
102                         throw new ClassNotFoundException  ("Cannot load resource for class [" + name + "]", ex);
103                     }
104                 }
105             }
106         }
107 
108         if (result != null) {
109             if (resolve) {
110                 resolveClass(result);
111             }
112             return result;
113         }
114         else {
115             return super.loadClass(name, resolve);
116         }
117     }
118 
119     /**
120      * Determine whether the specified class is eligible for overriding
121      * by this class loader.
122      * <p>The default implementation checks against excluded packages and classes.
123      * @param className the class name to check
124      * @return whether the specified class is eligible
125      * @see #excludePackage
126      * @see #excludeClass
127      */
128     protected boolean isEligibleForOverriding(String   className) {
129         if (this.excludedClasses.contains(className)) {
130             return false;
131         }
132         for (Iterator   it = this.excludedPackages.iterator(); it.hasNext();) {
133             String   packageName = (String  ) it.next();
134             if (className.startsWith(packageName)) {
135                 return false;
136             }
137         }
138         return true;
139     }
140 
141 
142     /**
143      * Transformation hook to be implemented by subclasses.
144      * <p>The default implementation simply returns the given bytes as-is.
145      * @param name the fully-qualified name of the class being transformed
146      * @param bytes the raw bytes of the class
147      * @return the transformed bytes (never <code>null</code>;
148      * same as the input bytes if the transformation produced no changes)
149      */
150     protected byte[] transformIfNecessary(String   name, byte[] bytes) {
151         return bytes;
152     }
153 
154 }
155
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags