自定义ClassLoader

 package com.classloader.util;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandlerFactory;
import java.security.CodeSource;
import java.security.PermissionCollection;
import java.util.Enumeration;
import java.util.jar.Manifest;

public class NetworkClassLoader extends URLClassLoader {

	String baseUrl;

	public String getBaseUrl() {
		return baseUrl;
	}

	public void setBaseUrl(String baseUrl) {
		this.baseUrl = baseUrl;
	}

	public NetworkClassLoader(){
		this(new URL[]{});
	}

	/**
	 * URL 以'/'结尾的为目录
	 *     否则为jar包
	 *     未指定其父类加载器为系统类加载器
	 * @param urls
	 */
	public NetworkClassLoader(URL[] urls) {
		super(urls);
	}

	/**
	 * 同上，指定classLoader
	 * @param urls
	 * @param parent
	 */
	public NetworkClassLoader(URL[] urls, ClassLoader parent) {
		super(urls,parent);
	}

	/**
	 * 同上,URL工厂处理器
	 * @param urls
	 * @param parent
	 * @param factory
	 */
	public NetworkClassLoader(URL[] urls, ClassLoader parent,
			  URLStreamHandlerFactory factory) {
		 super(urls,parent,factory);
	}

	/**
	 * [添加baseUrl]
	 * @param url
	 */
	public void addURL(String url){
		URL uurl=null;
		try {
			uurl = new URL(baseUrl+url);
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		addURL(uurl);
	}

	/**
	 * 添加url[添加baseUrl]
	 */
	protected void addURL(URL url) {
		super.addURL(url);
	}

	/**
	 * 返回urls
	 */
	public URL[] getURLs() {
		return super.getURLs();
	}

	/**
	 * 查找类对象
	 *   从以上的URLS中查找加载当前类对象[会打开所有的jars去查找指定的类]
	 *   (可以通过调用findClass来得到以上URL加载包中的类)
	 */
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		return super.findClass(name);
	}

	/**
	 * defineClass SecureClassLoader定义为最终方法，不允许更改.
	 * 在使用这个类对象前，必须先resolved(解析)
	 */


	/**
	 * 查找资源[自定义相对URL查找路径]
	 *   从以上的URLS中查找当前名称的资源
	 * 这个必须重写，因为是public 哈哈
	 */
	public URL findResource(String name) {
		URL url = null;
		try {
			url = new URL(baseUrl+name);
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return url;
	}

	/**
	 * 查找资源列表[URL查找路径]
	 */
	public Enumeration<URL> findResources(String name) throws IOException {
		return super.findResources(name);
	}

	/**
	 * 在当前的ClassLoader中，定义一个新的Package,Package的属性由Manifest指定.这个包的源文件
	 */
	protected Package definePackage(String name, Manifest man, URL url)
			throws IllegalArgumentException {
		return super.definePackage(name, man, url);
	}

	/**
	 * 加载路径权限
	 */
	protected PermissionCollection getPermissions(CodeSource codesource) {
		return super.getPermissions(codesource);
	}
}

以下是用法:

	NetworkClassLoader loader = new NetworkClassLoader();
		loader.setBaseUrl("file:///F:\\框架\\maven\\app\\jms\\src\\main\\webapp\\modules\\");

		loader.addURL("App/lib/test.jar");
		loader.addURL("App/lib/test1.jar");
		loader.addURL("App/template/view.vm");
		loader.addURL("App/config.xml");

这里初始化了此类加载器所使用的类资源，配置文件等。
以下是如何加载类资源:

Class clazz= loader.findClass("com.jvm.look.A");//加载类

以下是加载配置文件资源

URL uuu = loader.findResource("App/config.xml");

有一点需要注意的，这个类加载器还是双亲委托机制，比如有一个类"com.annotation.table.Test"在父类加载器中如果已经加载过了，那么如果这个类在test.jar中存在，那么不会重新定义加载，而使用父类加载器加载的类，有人问了，那我如何覆盖父类加载器中定义的类。
可以进行如下操作:

Class clazz2= loader.findClass("com.annotation.table.Test");

重新加载类,类的加载序列我在上一篇已经讲过了，不熟悉的可以看以上文章.
可能有人会问了，如果每一个类都这样，那我不崩溃了，我需要把我加载的jar覆盖父类加载器中定义的所有类.

	/**
	 * 覆盖父加载器中定义的类，使用当前类加载器加载资源，那么所有的类都在此加载器中执行.
	 * 这样，所有URL中的类都通过此类加载器加载，也就是说URL中的类的定义类加载器就是当前类加载器.
	 * 建议:尽量不要使用这种方式覆盖父加载器定义的类.[按一种约定双亲委托机制加载]
	 * (如果重载了，那么尽量使用此loader加载类，这样所有逻辑都在此ClassLoader中运行,当然还有SDK还是从双亲加载)
	 * 可以在SDK中定义接口，在此JAR里面提供实现.
	 */
	public void initAllJar(){
		URL[] urls = this.getURLs();

		for(URL urll:urls){
			String url = urll.getFile();
			//重新定义这个架包中的所有类.
			if(url.endsWith("jar")){
				File jarFile  = getJarFile(url);
				JarFile jarFileTemp = null;
				try {
					jarFileTemp = new JarFile(jarFile);
					Enumeration<JarEntry> en = jarFileTemp.entries();
					while (en.hasMoreElements()) {
						JarEntry je = en.nextElement();
						String name = je.getName();
						if (name.endsWith(CLASS_FILE)) {
							String className = name.substring(0, name.length()
									- CLASS_FILE.length());
							findClass(pathToDot(className));
						}
					}

				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ClassNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

/**
	 * 转jar包路径和jar文件名为具体文件.
	 *
	 * @param root
	 * @param jar
	 * @return
	 */
	private File getJarFile(String file) {
		if (file.startsWith(PREFIX_FILE))
			file = file.substring(PREFIX_FILE.length());
		int end = file.indexOf(JAR_URL_SEPERATOR);
		if (end != (-1))
			file = file.substring(0, end);
		return new File(file);
	}

   /**
     * 转路径为包名[/ ==> .]/[\\ ==> .]
     * @param s
     * @return
     */
    private String pathToDot(String s) {
        return s.replace('/', '.').replace('\\', '.');
    }

其实JDK中已经提供了好几个ClassLoader,大家可以扩展，比如项目中有两个架包版本，结构全部都一样，但是两个架包都必须运行。这时自定义类加载器就有用了。