Tomcat学习之ClassLoader

类装载器

JDK中提供了3种不同的类加载器：启动类装载器，扩展类装载器和系统类装载器。引导类装载器，用于引导启动JAVA虚拟机，当执行一个JAVA程序时，就会启动引导类装载器，它是使用本地代码来实现的，会装载%JAVA_HOME%\\jre\lib\rt.jar，它是所有类装载器类的父装载器。扩展类装载器负责载入标准扩展目录中的类，其搜索路径是%JAVA_HOME%\jre\lib\ext,只需要将打包好的jar文件放入这个目录就可以了，给开发提供了很大的便利性。系统类装载器是默认的装载器，其搜索路径是classpath。

JVM到底使用的是哪一个类装载器，取决于类装载器的代理模式。每当需要装载一个类的时候，会首先调用系统类装载器，但是系统类装载器并不会立即装载，而是将其交给父装载器：扩展类装载器，扩展类装载器其将交给引导类装载器，引导类装载器没有父装载器，它会尝试装载这个类，如果找不到这个类，会交给扩展类装载器，如果扩展类装载器还是没有找到，会交给系统类装载器，如果系统类装载器还是没有找到这个类，则会抛出java.lang.ClassNotFoundException异常。代理模式主要是为了解决类装载的安全问题。例如：对于自定类的java.lang.Object类，永远得不到装载，除非，rt.jar中确实没有这个类。

tomcat也提供了几种不同的类装载器用于加载不同位置的jar包和class文件，特别是Context容器需要有一个单独的类装载器，因为不同应用可能有相同的类，如果用同一个类装载器去装载，就不知道该加载哪个应用里面的类了。这些类装载器之间的关系如下图所示：

系统类装载器

tomcat的系统类装载器和JDK的系统类装载器有点不同的地方是搜索路径并不相同，在catalina.bat中做了如下修改：

rem Add on extra jar file to CLASSPATH
rem Note that there are no quotes as we do not want to introduce random
rem quotes into the CLASSPATH
if "%CLASSPATH%" == "" goto emptyClasspath
set "CLASSPATH=%CLASSPATH%;"
:emptyClasspath
set "CLASSPATH=%CLASSPATH%%CATALINA_HOME%\bin\bootstrap.jar"
rem Add tomcat-juli.jar to classpath
rem tomcat-juli.jar can be over-ridden per instance
if not exist "%CATALINA_BASE%\bin\tomcat-juli.jar" goto juliClasspathHome
set "CLASSPATH=%CLASSPATH%;%CATALINA_BASE%\bin\tomcat-juli.jar"

先将classpath清空，因为classpath中可能有tomcat启动相关的类会影响tomcat的正常启动。然后将bootstrap.jar和tomcat-juli.jar加入classpath中，在catalina.bat中调用了Bootstrap类的main方法，这里系统类装载器会装载Bootstrap类，Bootstrap类用到的Catalina类也是由系统类装载器装载的。

随后在Bootstrap的init方法中创建了3个类装载器：

public void init() throws Exception{
	// Set Catalina path
	setCatalinaHome();
	setCatalinaBase();

	initClassLoaders();

	Thread.currentThread().setContextClassLoader(catalinaLoader);

	SecurityClassLoad.securityClassLoad(catalinaLoader);
	...
}	

private void initClassLoaders() {
	try {
		commonLoader = createClassLoader("common", null);
		if( commonLoader == null ) {
			// no config file, default to this loader - we might be in a 'single' env.
			commonLoader=this.getClass().getClassLoader();
		}
		catalinaLoader = createClassLoader("server", commonLoader);
		sharedLoader = createClassLoader("shared", commonLoader);
	} catch (Throwable t) {
		handleThrowable(t);
		log.error("Class loader creation threw exception", t);
		System.exit(1);
	}
}

Common Class Loader

首先创建CommonLoader，是在createClassLoader方法中完成的，代码如下：

private ClassLoader createClassLoader(String name, ClassLoader parent)throws Exception {
	String value = CatalinaProperties.getProperty(name + ".loader");
	if ((value == null) || (value.equals("")))
		return parent;

	value = replace(value);

	List<Repository> repositories = new ArrayList<Repository>();
	StringTokenizer tokenizer = new StringTokenizer(value, ",");
	while (tokenizer.hasMoreElements()) {
		String repository = tokenizer.nextToken().trim();
		if (repository.length() == 0) {
			continue;
		}

		// Check for a JAR URL repository
		try {
			@SuppressWarnings("unused")
			URL url = new URL(repository);
			repositories.add(new Repository(repository, RepositoryType.URL));
			continue;
		} catch (MalformedURLException e) {
			// Ignore
		}

		// Local repository
		if (repository.endsWith("*.jar")) {
			repository = repository.substring(0, repository.length() - "*.jar".length());
			repositories.add(new Repository(repository, RepositoryType.GLOB));
		} else if (repository.endsWith(".jar")) {
			repositories.add(new Repository(repository, RepositoryType.JAR));
		} else {
			repositories.add(new Repository(repository, RepositoryType.DIR));
		}
	}

	ClassLoader classLoader = ClassLoaderFactory.createClassLoader(repositories, parent);
	...

	return classLoader;
}

(1)、从bootstrap.jar包可以找到catalina.properties文件：common.loader=${catalina.home}/lib,${catalina.home}/lib/*.jar，很明显这个类装载器搜索路径就是${catalina.home}/lib和${catalina.home}/lib/*.jar，之所以叫common class loader，是因为它加载每个应用要用到的公共jar包和class文件；

(2)、遍历values，将每个value封装成Repository，然后根据repository和parent创建这个classLoader,在这个方法中parent传入的是null值，代表这个类装载器的父装载器是系统类装载器,实际上返回的是StandardClassLoader类，StandardClassLoader类是URLClassLoader的子类，即将被废弃。之所以返回的是StandardClassLoader是在ClassLoaderFactory的createClassLoader方法中被包装了一层。

Catalina Class Loader

common class loader创建好之后，又创建了catalinaLoader，其搜索路径为空，以下是catalina.properties的配置项：

common.loader=${catalina.base}/lib,${catalina.base}/lib/*.jar,${catalina.home}/lib,${catalina.home}/lib/*.jar
server.loader=
shared.loader=

common class loader是以common class loader为父装载器的，因此其搜索路径和common class loader一样。catalina class loader创建好后，在init方法中随即调用了Thread.currentThread().setContextClassLoader(catalinaLoader);将其设置为当前线程的类装载器

Shared Class Loader

已不再使用，tomcat早期的版本在使用这个类装载器，负责装载应用中公用的类，后来这些公用的类被移到了{catalina.base}/lib目录下，这个装载器暂时未被使用

综上所述：tomcat在启动的时候初始化了三个类加载器，commonLoader,catalinaLoader,sharedLoader.其中commonLoader是另外两个的父装载器，且为standardClassLoader类型，tomcat真正使用的是commonLoader，engine,host,connector等都是使用commonLoader装载的。

Webapp Class Loader

这个类装载器是tomcat自定义的类装载器，先来看看类图：

tomcat的一个service除了容器和连接器外还有很多组件，比如sessionManager,logger,loader等，这个类装载器是以组件的形式附着在每个容器上的，Engine和Host的这两个容器的loader组件为null,context里面是有值的，看看context的startInternal方法：

 protected synchronized void startInternal() throws LifecycleException {
	...
        if (getLoader() == null) {
            WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
            webappLoader.setDelegate(getDelegate());
            setLoader(webappLoader);
        }
	...
        // Binding thread
        ClassLoader oldCCL = bindThread();
        try {

            if (ok) {
                
                // Start our subordinate components, if any
                if ((loader != null) && (loader instanceof Lifecycle))
                    ((Lifecycle) loader).start();

                // since the loader just started, the webapp classloader is now
                // created.
                // By calling unbindThread and bindThread in a row, we setup the
                // current Thread CCL to be the webapp classloader
                unbindThread(oldCCL);
                oldCCL = bindThread();
	}
	...
        } finally {
            // Unbinding thread
            unbindThread(oldCCL);
        }
}

很明显，context在启动的时候创建了一个loader组件，webapploader正是loader的实现类，这个类并不是最终的类装载器，在这个类里面有一个webappclassloader类型的字段叫classloader,这个classloader的创建是在loader组件的start方法中完成的

    protected void startInternal() throws LifecycleException {
		...
        // Construct a class loader based on our current repositories list
        try {
            classLoader = createClassLoader();
            classLoader.setResources(container.getResources());
            classLoader.setDelegate(this.delegate);
            classLoader.setSearchExternalFirst(searchExternalFirst);
            if (container instanceof StandardContext) {
                classLoader.setAntiJARLocking(
                        ((StandardContext) container).getAntiJARLocking());
                classLoader.setClearReferencesStatic(
                        ((StandardContext) container).getClearReferencesStatic());
                classLoader.setClearReferencesStopThreads(
                        ((StandardContext) container).getClearReferencesStopThreads());
                classLoader.setClearReferencesStopTimerThreads(
                        ((StandardContext) container).getClearReferencesStopTimerThreads());
                classLoader.setClearReferencesHttpClientKeepAliveThread(
                        ((StandardContext) container).getClearReferencesHttpClientKeepAliveThread());
            }

            for (int i = 0; i < repositories.length; i++) {
                classLoader.addRepository(repositories[i]);
            }

            // Configure our repositories
            setRepositories();
            setClassPath();

            setPermissions();

            ((Lifecycle) classLoader).start();
			...
        } catch (Throwable t) {
         ...
        }
		...
    }

(1)、在createClassLoader方法中通过反射实例化了org.apache.catalina.loader.WebappClassLoader这个类，并调用了它的setParentClassLoader设置其父装载器为standardClassLoader

    private WebappClassLoader createClassLoader()
        throws Exception {

        Class<?> clazz = Class.forName(loaderClass);
        WebappClassLoader classLoader = null;

        if (parentClassLoader == null) {
            parentClassLoader = container.getParentClassLoader();
        }
        Class<?>[] argTypes = { ClassLoader.class };
        Object[] args = { parentClassLoader };
        Constructor<?> constr = clazz.getConstructor(argTypes);
        classLoader = (WebappClassLoader) constr.newInstance(args);

        return classLoader;

    }

(2)、为webappclassloader添加仓库（仓库表示类装载器会在哪些路径搜索类）

将/WEB-INF/classes目录添加到仓库中，然后将/WEB-INF/lib目录下的jar包也添加到仓库中

private void setRepositories() throws IOException {
	...
	// Setting up the class repository (/WEB-INF/classes), if it exists
	String classesPath = "/WEB-INF/classes";
	
	...
	// Adding the repository to the class loader
	classLoader.addRepository(classesPath + "/", classRepository);

	// Setting up the JAR repository (/WEB-INF/lib), if it exists
	String libPath = "/WEB-INF/lib";
	...
	// Looking up directory /WEB-INF/lib in the context
	NamingEnumeration<NameClassPair> enumeration = libDir.list("");
	while (enumeration.hasMoreElements()) {
		NameClassPair ncPair = enumeration.nextElement();
		String filename = libPath + "/" + ncPair.getName();
		if (!filename.endsWith(".jar"))
			continue;
		...
		try {
			JarFile jarFile = new JarFile(destFile);
			classLoader.addJar(filename, jarFile, destFile);
		} catch (Exception ex) {
		 ...
		}
		...
	}
}

(3)、为类装载器设置权限，这里Globals.IS_SECURITY_ENABLED值为false，表示安全机制未打开，直接返回

(4)、启动这个loader

Webappclassloader设计的过程中考虑了优化和安全两方面。例如，它会缓存之前已经载入的类以提高性能。此外，它还会缓存失败的类的名字，下次再次请求加载相同的类时直接抛出ClassNotFoundException异常。考虑到安全性，不允许载入指定的某些类，这些类在triggers数组中，目前有两个类：

    protected static final String[] triggers = {
        "javax.servlet.Servlet", "javax.el.Expression"       // Servlet API
    };

WebappClassLoader装载类

loadClass是在其loadClass方法中完成的，下面详细分析这个方法：

	public synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
		...
		// 先检查本地缓存
		clazz = findLoadedClass0(name);
		if (clazz != null) {
			if (log.isDebugEnabled())
				log.debug("  Returning class from cache");
			if (resolve)
				resolveClass(clazz);
			return (clazz);
		}

		// 如果本地缓存没有，则检查上一级缓存
		clazz = findLoadedClass(name);
		if (clazz != null) {
			if (log.isDebugEnabled())
				log.debug("  Returning class from cache");
			if (resolve)
				resolveClass(clazz);
			return (clazz);
		}

		// 如果两个缓存都没有，则使用系统的类装载器进行装载，防止Web应用程序中的类覆盖J2EE的类
		try {
			clazz = system.loadClass(name);
			if (clazz != null) {
				if (resolve)
					resolveClass(clazz);
				return (clazz);
			}
		} catch (ClassNotFoundException e) {
			// Ignore
		}

		// 如果启用了SecurityManager，则检查此类是否允许被载入，如果不允许，则抛出异常
		if (securityManager != null) {
			int i = name.lastIndexOf('.');
			if (i >= 0) {
				try {
					securityManager.checkPackageAccess(name.substring(0, i));
				} catch (SecurityException se) {
					String error = "Security Violation, attempt to use " + "Restricted Class: " + name;
					log.info(error, se);
					throw new ClassNotFoundException(error, se);
				}
			}
		}

		boolean delegateLoad = delegate || filter(name);

		// 若打开了delegateLoad标志位，调用父装载器来加载。如果父装载器为null，使用系统类装载器装载
		if (delegateLoad) {
			if (log.isDebugEnabled())
				log.debug("  Delegating to parent classloader1 " + parent);
			ClassLoader loader = parent;
			if (loader == null)
				loader = system;
			try {
				clazz = Class.forName(name, false, loader);
				if (clazz != null) {
					if (log.isDebugEnabled())
						log.debug("  Loading class from parent");
					if (resolve)
						resolveClass(clazz);
					return (clazz);
				}
			} catch (ClassNotFoundException e) {
				// Ignore
			}
		}

		// 从本地仓库中载入相关类
		if (log.isDebugEnabled())
			log.debug("  Searching local repositories");
		try {
			clazz = findClass(name);
			if (clazz != null) {
				if (log.isDebugEnabled())
					log.debug("  Loading class from local repository");
				if (resolve)
					resolveClass(clazz);
				return (clazz);
			}
		} catch (ClassNotFoundException e) {
			// Ignore
		}

		// 若当前仓库中没有需要的类，且delegateLoad标志位关闭，则使用父装载器。若父装载器为null，使用系统类装载器来装载
		if (!delegateLoad) {
			if (log.isDebugEnabled())
				log.debug("  Delegating to parent classloader at end: " + parent);
			ClassLoader loader = parent;
			if (loader == null)
				loader = system;
			try {
				clazz = Class.forName(name, false, loader);
				if (clazz != null) {
					if (log.isDebugEnabled())
						log.debug("  Loading class from parent");
					if (resolve)
						resolveClass(clazz);
					return (clazz);
				}
			} catch (ClassNotFoundException e) {
				// Ignore
			}
		}
		//仍未找到，抛出异常
		throw new ClassNotFoundException(name);

	}

整个思路是：先到缓存中获取，如果缓存中有直接返回，否则根据delegateLoad采取不同的加载方式。如果未启用这个标志：先本地仓库加载再父装载器或者系统类装载器装载；如果启用了这个标志：直接由父装载器或者系统类装载器装载。

类缓存

tomcat之所以采用自定义类装载器，除了不同应用之间有相同类不好解决之外，还有一个原因是可以缓存类以提高速度。每个由webappclassloader装载的类被视为资源，用ResourceEntry表示。加入缓存的代码是在loadclass方法中完成的，前面提到会搜索本地仓库，就是在这步调用了findClass方法完成了类的查找，并把找到的类封装成ResourceEntry，最后把这个resourceEntry放入resourceEntries中缓存起来。

Tomcat学习之ClassLoader

类装载器

系统类装载器

Common Class Loader

Catalina Class Loader

Shared Class Loader

Webapp Class Loader

WebappClassLoader装载类

类缓存

數據的網絡傳輸學習筆記

瀏覽器緩存學習筆記

Apache Mina Filter

JAVA NIO Socket通道

Apache Mina Session

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結