实现自定义的classLoader加载classpath中的class

转载：http://www.blogjava.net/shenh062326/archive/2012/05/20/378623.html

 

最近这些天学习了classLoader的原理, 原因是因为服务器上的一个java进程启动时加载两个不同版本的jar包, 含有相同名字的类, 而且服务端的jar包排在前面, 我上传的jar包排在后面, 于是每次都使用服务端的jar包, 我的jar包便无法生效, 因此希望修改classLader, 让它按相反的顺序加载jar包.
     网上查阅了classLoader的原理, 分析jvm默认使用AppClassLoader加载classpath中的类, 因此目标很明确, 替换它就行了, 找到一个参数

java.system.class.loader, 只需要在启动java进程的时候把它设置为自己的类就行. 
     开始写自己的classLoader, 参考URLClassLoader与网上的介绍, 写了一个简单的,上代码:

  1  package org.taobao.yuling.testClassLoader;
  2 
  3  import java.io.*;
  4  import java.lang.reflect.*;
  5  import java.net.MalformedURLException;
  6  import java.net.URL;
  7  import java.net.URLClassLoader;
  8  import java.nio.ByteBuffer;
  9  import java.security.AccessControlContext;
 10  import java.security.AccessController;
 11  import java.security.CodeSigner;
 12  import java.security.CodeSource;
 13  import java.security.PermissionCollection;
 14  import java.security.PrivilegedAction;
 15  import java.security.SecureClassLoader;
 16  import java.util.Arrays;
 17  import java.util.HashMap;
 18  import java.util.Map;
 19  import java.util.jar.Attributes;
 20  import java.util.jar.Manifest;
 21 
 22 
 23  import sun.misc.JavaNetAccess;
 24  import sun.misc.Resource;
 25  import sun.misc.SharedSecrets;
 26  import sun.misc.URLClassPath;
 27 
 28  /**
 29   * The class loader used for loading from java.class.path.
 30   * runs in a restricted security context.
 31    */
 32  public  class MyClassLoader  extends URLClassLoader {
 33      public URLClassPath ucp;
 34        private Map<String, Class<?>> cache =  new HashMap();
 35        private  static  final Method defineClassNoVerifyMethod;
 36       
 37        static String[] paths = System.getProperty("java.class.path").split(";");
 38       
 39        static URL[] urls =  new URL[paths.length];
 40 
 41        static{
 42           System.out.println(Arrays.toString(paths));
 43           System.out.println(System.getProperty("java.class.path"));
 44            for( int i=0; i<urls.length; i++){
 45                try {
 46                   
 47                 urls[i] =  new URL("file:"+paths[paths.length-1-i]);
 48             }  catch (MalformedURLException e) {
 49                 e.printStackTrace();
 50             }
 51           }
 52           System.out.println(Arrays.toString(urls));
 53         SharedSecrets.setJavaNetAccess( new JavaNetAccess() {
 54            public URLClassPath getURLClassPath(URLClassLoader u) {
 55              return ((MyClassLoader)u).ucp;
 56           } } );
 57         Method m;
 58          try {
 59           m = SecureClassLoader. class.getDeclaredMethod(
 60             "defineClassNoVerify",  new Class[] { String. class, 
 61             ByteBuffer. class, CodeSource. class });
 62           m.setAccessible( true);
 63         }  catch (NoSuchMethodException nsme) {
 64           m =  null;
 65         }
 66         defineClassNoVerifyMethod = m;
 67       }
 68       
 69        public MyClassLoader(URL[] urls) {
 70              super(MyClassLoader.urls);
 71              this.ucp =  new URLClassPath(MyClassLoader.urls);
 72         }
 73       
 74        public MyClassLoader(ClassLoader parent) {
 75              super(MyClassLoader.urls, parent);
 76              this.ucp =  new URLClassPath(MyClassLoader.urls);
 77         }
 78 
 79        public Class<?> loadClass(String name)
 80          throws ClassNotFoundException{
 81         Class c =  null;
 82         
 83          if (name.contains("hadoop")) {
 84           c = (Class) this.cache.get(name);
 85            if (c ==  null) {
 86             c = findClass(name);
 87              this.cache.put(name, c);
 88           }
 89         }  else {
 90           c = loadClass(name,  false);
 91         }
 92          return c;
 93       }
 94 
 95        protected Class<?> findClass(String name)
 96          throws ClassNotFoundException
 97       {
 98         String path = name.replace('.', '/').concat(".class");
 99         Resource res =  this.ucp.getResource(path);
100          if (res !=  null) {
101            try {
102              return defineClass(name, res,  true);
103           }  catch (IOException e) {
104              throw  new ClassNotFoundException(name, e);
105           }
106         }
107          throw  new ClassNotFoundException(name);
108       }
109 
110        private Class<?> defineClass(String name, Resource res,  boolean verify)  throws IOException
111       {
112          int i = name.lastIndexOf('.');
113         URL url = res.getCodeSourceURL();
114          if (i != -1) {
115           String pkgname = name.substring(0, i);
116 
117           Package pkg = getPackage(pkgname);
118           Manifest man = res.getManifest();
119            if (pkg !=  null)
120           {
121              if (pkg.isSealed())
122             {
123                if (!pkg.isSealed(url)) {
124                  throw  new SecurityException(
125                   "sealing violation: package " + pkgname + 
126                   " is sealed");
127               }
128 
129             }
130              else  if ((man !=  null) && (isSealed(pkgname, man))) {
131                throw  new SecurityException(
132                 "sealing violation: can't seal package " + 
133                 pkgname + ": already loaded");
134             }
135 
136           }
137            else  if (man !=  null)
138             definePackage(pkgname, man, url);
139            else {
140             definePackage(pkgname,  null,  null,  null,  null,  null,  null, 
141                null);
142           }
143 
144         }
145 
146         ByteBuffer bb = res.getByteBuffer();
147          byte[] bytes = bb ==  null ? res.getBytes() :  null;
148 
149         CodeSigner[] signers = res.getCodeSigners();
150         CodeSource cs =  new CodeSource(url, signers);
151 
152          if (!verify)
153         {
154           Object[] args = { name, bb ==  null ? ByteBuffer.wrap(bytes) : bb, 
155             cs };
156            try {
157              return (Class)defineClassNoVerifyMethod.invoke( this, args);
158           }
159            catch (IllegalAccessException localIllegalAccessException) {
160           }
161            catch (InvocationTargetException ite) {
162             Throwable te = ite.getTargetException();
163              if ((te  instanceof LinkageError))
164                throw ((LinkageError)te);
165              if ((te  instanceof RuntimeException)) {
166                throw ((RuntimeException)te);
167             }
168              throw  new RuntimeException("Error defining class " + name, 
169               te);
170           }
171 
172         }
173          return defineClass(name, bytes, 0, bytes.length, cs);
174       }
175 
176        private  boolean isSealed(String name, Manifest man) {
177         String path = name.replace('.', '/').concat("/");
178         Attributes attr = man.getAttributes(path);
179         String sealed =  null;
180          if (attr !=  null) {
181           sealed = attr.getValue(Attributes.Name.SEALED);
182         }
183          if ((sealed ==  null) && 
184           ((attr = man.getMainAttributes()) !=  null)) {
185           sealed = attr.getValue(Attributes.Name.SEALED);
186         }
187 
188          return "true".equalsIgnoreCase(sealed);
189       }
190 }
191 

注: isSealed(), defineClass(), findClass(), 都是直接从URLClassLoader复制过来.

代码较粗糙, 不过意思很简单, 就是通过把java.class.path的jar包反顺序, 然后定义了自己的

Class<?> loadClass(String name) 方法, 在加载我需要的类时在已被反序的的jar包中查找, 这样就能首先加载我修改的类了. 
运行方法:

java -Djava.system.class.loader=org.taobao.yuling.testClassLoader.MyClassLoader -classpath ...  MyTestClass