类加载器简介
Java虚拟机中的类加载器（ClassLoader）负责加载来自文件系统、网络或其他来源的类文件。Java虚拟机中的类加载器默认使用的是双亲委派模式，如图所示，其中有三种默认使用的类加载器，分别是Bootstrap ClassLoader、Extension ClassLoader和System ClassLoader（也被称为Application ClassLoader），每种类加载器都已经确定从哪个位置加载类文件。
Bootstrap ClassLoader: 加载JDK自带的rt.jar包中的中的类文件，它是所有类加载器的父加载器
Extension ClassLoader: 负责加载Java的扩展类库，从jre/lib/ext目录下或者java.ext.dirs系统属性指定的目录下加载类。
System ClassLoader: 负责从classpath环境变量中加载类文件,它是Extension ClassLoader的子加载器。
根据双亲委派模式，在加载类文件时，子加载器首先会将加载请求委托给它的父加载器。父加载器会检测自己是否已经加载过该类，如果已加载则加载过程结束；如果未加载则请求继续向上传递，直到Bootstrap ClassLoader。如果在请求向上委托的过程中，始终未检测到该类已加载，则从Bootstrap ClassLoader开始尝试从其对应路径中加载该类文件，如果加载失败则由子加载器继续尝试加载，直至发起加载请求的子加载器位为止。
除了系统提供三种类加载器，也可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求，例如Tomcat、JBoss等都涉及了自定义类加载器的使用。
ClassLoaderWrapper
在Mybatis IO包中提供的ClassLoaderWrapper是一个ClassLoader的包装器，其中包含了多个ClassLoader对象。通过调整多个类加载器的使用顺序，ClassLoaderWrapper可以确保返回给系统使用的是正确的类加载器。使用ClassLoaderWrapper就如同使用一个ClassLoader对象，ClassLoaderWrapper会按照指定的顺序依次检测其中封装的ClassLoader对象，并从中选取第一个可用的ClassLoader完成相关功能。
ClassLoaderWrapper的主要功能可以分为三类，分别是getResourceAsURL（）方法、classForName（）方法、getResourceAsStream（）方法，这三个方法都有多个重载，这三类方法最终都会调用参数为String和ClassLoader[]的重载。
/**
* 该类封装了多个类加载器，统一了使用入口
*
* @author kaifeng
* @author Clinton Begin
*/
public class ClassLoaderWrapper {
//默认类加载器
ClassLoader defaultClassLoader;
//系统类加载器
ClassLoader systemClassLoader;
/**
* 无参构造函数
*/
ClassLoaderWrapper() {
try {
//初始化系统类加载器
systemClassLoader = ClassLoader.getSystemClassLoader();
} catch (SecurityException ignored) {
// AccessControlException on Google App Engine
}
}
//region getResourceAsURL 方法重载
/**
* 使用当前类路径获取资源作为URL
*
* @param resource 要定位的资源
* @return 返回URL或null
*/
public URL getResourceAsURL(String resource) {
return getResourceAsURL(resource, getClassLoaders(null));
}
/**
* Get a resource from the classpath, starting with a specific class loader
*
* @param resource - 要定位的资源
* @param classLoader - 指定的类加载器
* @return 返回URL或null
*/
public URL getResourceAsURL(String resource, ClassLoader classLoader) {
return getResourceAsURL(resource, getClassLoaders(classLoader));
}
//endregion
//region getResourceAsStream 方法重载
/**
* 从指定路径获取资源
*
* @param resource - 要定位的资源
* @return 返回流格式资源或null
*/
public InputStream getResourceAsStream(String resource) {
return getResourceAsStream(resource, getClassLoaders(null));
}
/**
* 根据指定路径和类加载器查找资源
*
* @param resource - 要定位的资源
* @param classLoader - 指定的类加载器
* @return 返回流格式资源或null
*/
public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
return getResourceAsStream(resource, getClassLoaders(classLoader));
}
//endregion
//region classForName 方法重载
/**
* 根据类名查找类对象
*
* @param name - 要查找的类对象
* @return - 返回找到的类对象
* @throws ClassNotFoundException 不存在抛出异常
*/
public Class<?> classForName(String name) throws ClassNotFoundException {
return classForName(name, getClassLoaders(null));
}
/**
* 根据指定的类名，优先使用指定的类加载器查找类对象
*
* @param name - 要查找的类对象
* @param classLoader - 优先使用指定的类加载器
* @return - 返回找到的类对象
* @throws ClassNotFoundException 不存在抛出异常
*/
public Class<?> classForName(String name, ClassLoader classLoader) throws ClassNotFoundException {
return classForName(name, getClassLoaders(classLoader));
}
//endregion
/**
* 根据指定的资源路径，尝试使用各种类加载器查找资源
*
* @param resource - 要查找的资源
* @param classLoader - 类加载器数组
* @return 返回找到的资源或null
*/
InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
for (ClassLoader cl : classLoader) {
if (null != cl) {
// 通过使用不同的类加载器查找资源
InputStream returnValue = cl.getResourceAsStream(resource);
// 如果没有找到资源，通过在指定路径前面加上“/”，重新尝试一次
if (null == returnValue) {
returnValue = cl.getResourceAsStream("/" + resource);
}
// 找到资源并返回
if (null != returnValue) {
return returnValue;
}
}
}
return null;
}
/**
* 根据指定的资源路径，尝试使用多种类加载器查找资源
*
* @param resource - 指定的资源路径
* @param classLoader - 多种类加载器组成的数组
* @return 返回找到的资源或null
*/
URL getResourceAsURL(String resource, ClassLoader[] classLoader) {
URL url;
for (ClassLoader cl : classLoader) {
if (null != cl) {
// 通过使用不同的类加载器查找资源
url = cl.getResource(resource);
// 如果没有找到资源，通过在指定路径前面加上“/”，重新尝试一次
if (null == url) {
url = cl.getResource("/" + resource);
}
// 找到资源并返回
if (null != url) {
return url;
}
}
}
// 没找到返回null
return null;
}
/**
* 根据指定的类名，尝试使用各种类加载器查找类对象
*
* @param name - 要定位的类名
* @param classLoader - 类加载器组成的数组
* @return the class
* @throws ClassNotFoundException - 抛出找不到异常
*/
Class<?> classForName(String name, ClassLoader[] classLoader) throws ClassNotFoundException {
for (ClassLoader cl : classLoader) {
if (null != cl) {
try {
Class<?> c = Class.forName(name, true, cl);
if (null != c) {
return c;
}
} catch (ClassNotFoundException e) {
// we'll ignore this until all classloaders fail to locate the class
}
}
}
throw new ClassNotFoundException("Cannot find class: " + name);
}
/**
* 构造类加载器数组，指定了类加载器的使用顺序
* <p>
* classLoader 指定的类加载器
* defaultClassLoader 指定的默认类加载器
* Thread.currentThread().getContextClassLoader() 当前线程绑定的类加载器
* getClass().getClassLoader() 加载当前类所使用的类加载器
* systemClassLoader 系统类加载器
* </p>
*
* @param classLoader 类加载器
*/
ClassLoader[] getClassLoaders(ClassLoader classLoader) {
return new ClassLoader[]{
classLoader,
defaultClassLoader,
Thread.currentThread().getContextClassLoader(),
getClass().getClassLoader(),
systemClassLoader};
}
}
Resources是一个提供了多个静态方法的工具类，其中封装了一个ClassLoaderWrapper类型的静态字段，Resources提供的这些静态工具都是都是通过调用该ClassLoaderWrapper对象的相应方法实现的。
ResolverUtil
ResolverUtil可以根据指定的条件查找指定包下的类，其中使用的条件由Test接口表示。ResolverUtil中使用classLoader字段（ClassLoader类型）记录了当前使用的类加载器，默认情况下，使用的是当前线程上下文绑定的ClassLoader，我们可以通过setClassLoader（）方法修改使用类加载器。
MyBatis提供了两个常用的Test接口实现，分别是IsA和AnnotatedWith，如图。IsA用于检测类是否继承了指定的类或接口，AnnotatedWith用于检测类是否添加了指定的注解。
ResolverUtil.findImplementations（）方法和ResolverUtil.findAnnotated（）方法都是依赖ResolverUtil.find（）方法实现的，findImplementations（）方法会创建IsA对象作为检测条件，findAnnotated（）方法会创建AnnotatedWith对象作为检测条件。
/**
* ResolverUtil可以根据指定的条件查找指定包下的类，其中使用的条件由Test接口表示。
*
* @author kaifeng
* @author Tim Fennell
*/
public class ResolverUtil<T> {
/**
* 为当前类实例化一个日志对象
*/
private static final Log log = LogFactory.getLog(ResolverUtil.class);
/**
* 一个简单的接口，指定如何检测类，以确定它们是否包含在ResolverUtil生成的结果中。
*/
public interface Test {
/**
* 如果待检测的类符合条件，则返回True，否则返回false。
*
* @param type 待检测的类
*/
boolean matches(Class<?> type);
}
/**
* 用于检测类是否继承了指定的类或接口，
*/
public static class IsA implements Test {
private Class<?> parent;
/**
* 构造函数指定父类或实现的接口
*/
public IsA(Class<?> parentType) {
this.parent = parentType;
}
/**
* 如果继承了构造函数中指定的父类则返回true
*/
@Override
public boolean matches(Class<?> type) {
return type != null && parent.isAssignableFrom(type);
}
@Override
public String toString() {
return "is assignable to " + parent.getSimpleName();
}
}
/**
* 检测指定类是否添加了指定的注解
*/
public static class AnnotatedWith implements Test {
private Class<? extends Annotation> annotation;
/**
* 构造函数指定注解类型
*/
public AnnotatedWith(Class<? extends Annotation> annotation) {
this.annotation = annotation;
}
/**
* 如果检测的类使用了构造函数中指定的注解，则返回true
*/
@Override
public boolean matches(Class<?> type) {
return type != null && type.isAnnotationPresent(annotation);
}
@Override
public String toString() {
return "annotated with @" + annotation.getSimpleName();
}
}
/**
* The set of matches being accumulated.
*/
private Set<Class<? extends T>> matches = new HashSet<Class<? extends T>>();
/**
* 类加载器，默认使用Thread.currentThread().getContextClassLoader() will be used.
*/
private ClassLoader classloader;
/**
* 获取匹配的类集合
*
* @return 匹配的类集合
*/
public Set<Class<? extends T>> getClasses() {
return matches;
}
/**
* 获取类加载器，默认使用当前线程绑定的类加载器
*
* @return 用来加载类的类加载器
*/
public ClassLoader getClassLoader() {
return classloader == null ? Thread.currentThread().getContextClassLoader() : classloader;
}
/**
* 修改类加载器
*
* @param classloader 指定的类加载器
*/
public void setClassLoader(ClassLoader classloader) {
this.classloader = classloader;
}
/**
* 查找指定包中所有继承了指定父类的类
*
* @param parent 父类或接口
* @param packageNames 一个或多个包名
*/
public ResolverUtil<T> findImplementations(Class<?> parent, String... packageNames) {
if (packageNames == null) {
return this;
}
Test test = new IsA(parent);
for (String pkg : packageNames) {
find(test, pkg);
}
return this;
}
/**
* 查找指定包下所有使用指定注解的类
*
* @param annotation 指定的注解对象
* @param packageNames 一个或多个包名
*/
public ResolverUtil<T> findAnnotated(Class<? extends Annotation> annotation, String... packageNames) {
if (packageNames == null) {
return this;
}
Test test = new AnnotatedWith(annotation);
for (String pkg : packageNames) {
find(test, pkg);
}
return this;
}
/**
* 扫描指定包及子包下的所有类，检测包下所有的类
*
* @param test 检测类的实例对象
* @param packageName 包名 e.g. {@code net.sourceforge.stripes}
*/
public ResolverUtil<T> find(Test test, String packageName) {
//根据包名获取包的路径
String path = getPackagePath(packageName);
try {
List<String> children = VFS.getInstance().list(path);
for (String child : children) {
if (child.endsWith(".class")) {
//检测类是否符合test条件
addIfMatching(test, child);
}
}
} catch (IOException ioe) {
log.error("Could not read package: " + packageName, ioe);
}
return this;
}
/**
* 根据包名转换成包路径
*
* @param packageName 包名
*/
protected String getPackagePath(String packageName) {
return packageName == null ? null : packageName.replace('.', '/');
}
/**
* 检测类是否符合指定的test条件
*
* @param test 检测条件
* @param fqn 一个类的完整限定名，包括所在包的路径
*/
@SuppressWarnings("unchecked")
protected void addIfMatching(Test test, String fqn) {
try {
String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
ClassLoader loader = getClassLoader();
if (log.isDebugEnabled()) {
log.debug("Checking to see if class " + externalName + " matches criteria [" + test + "]");
}
Class<?> type = loader.loadClass(externalName);
if (test.matches(type)) {
matches.add((Class<T>) type);
}
} catch (Throwable t) {
log.warn("Could not examine class '" + fqn + "'" + " due to a " +
t.getClass().getName() + " with message: " + t.getMessage());
}
}
}ResolverUtil 的使用方式
//在pkg1，pkg2两个包下查找ActionBean类
ResolverUtil<ActionBean> resolver = new ResolverUtil<ActionBean>();
//在pkg1,pkg2中查找继承了ActionBean的类
resolver.findImplementation(ActionBean.class, pkg1, pkg2);
resolver.find(new CustomTest(), pkg1);//在pkg1中查找符合条件CustomTest的类
resolver.find(new CustomTest(), pkg2);//在pkg2中查找符合条件CustomTest的类
//收集上述三个的结果
Collection<ActionBean> beans = resolver.getClasses();VFS
VFS表示虚拟文件系统（Virtual File System），它用来查找指定路径下的资源。VFS是一个抽象类，MyBatis中提供了JBoss6VFS 和 DefaultVFS两个VFS的实现，如图所示。用户也可以提供自定义的VFS实现类
VFS中定义了list（URL, String）和isValid（）两个抽象方法，
isValid（）负责检测当前VFS对象在当前环境下是否有效，list（URL, String）方法负责查找指定的资源名称列表，在ResolverUtil.find（）方法查找类文件时会调用list（）方法的重载方法，该重载最终会调用list（list（URL,String）这个重载。
/**
* VFS表示虚拟文件系统（Virtual File System），它用来查找指定路径下的资源。
* VFS是一个抽象类，MyBatis中提供了JBoss6VFS 和 DefaultVFS两个VFS的实现。
*
* @author kaifeng
* @author Ben Gunter
*/
public abstract class VFS {
private static final Log log = LogFactory.getLog(VFS.class);
/**
* 记录两个VFS实现类
*/
public static final Class<?>[] IMPLEMENTATIONS = {JBoss6VFS.class, DefaultVFS.class};
/**
* 记录用户自定义的VFS实现类，通过 {@link #addImplClass(Class)}.将自定义实现类添加到USER_IMPLEMENTATIONS集合中
*/
public static final List<Class<? extends VFS>> USER_IMPLEMENTATIONS = new ArrayList<Class<? extends VFS>>();
/**
* 单例模式，记录全局唯一VFS
*/
private static class VFSHolder {
static final VFS INSTANCE = createVFS();
@SuppressWarnings("unchecked")
static VFS createVFS() {
// 优先使用用户自定义的VFS实现类，其次使用系统的
List<Class<? extends VFS>> impls = new ArrayList<Class<? extends VFS>>();
impls.addAll(USER_IMPLEMENTATIONS);
impls.addAll(Arrays.asList((Class<? extends VFS>[]) IMPLEMENTATIONS));
// 遍历实现类，依次实例化VFS对象并检测实例对象是否有效，如果获得有效实例对象则循环结束
VFS vfs = null;
for (int i = 0; vfs == null || !vfs.isValid(); i++) {
Class<? extends VFS> impl = impls.get(i);
try {
vfs = impl.newInstance();
if (vfs == null || !vfs.isValid()) {
if (log.isDebugEnabled()) {
log.debug("VFS implementation " + impl.getName() +
" is not valid in this environment.");
}
}
} catch (InstantiationException e) {
log.error("Failed to instantiate " + impl, e);
return null;
} catch (IllegalAccessException e) {
log.error("Failed to instantiate " + impl, e);
return null;
}
}
if (log.isDebugEnabled()) {
log.debug("Using VFS adapter " + vfs.getClass().getName());
}
return vfs;
}
}
/**
* 获取全局唯一VFS实例化对象
*/
public static VFS getInstance() {
return VFSHolder.INSTANCE;
}
/**
* 将用户自定义VFS实现类添加到集合USER_IMPLEMENTATIONS
*
* @param clazz 自定义VFS实现类
*/
public static void addImplClass(Class<? extends VFS> clazz) {
if (clazz != null) {
USER_IMPLEMENTATIONS.add(clazz);
}
}
/**
* 根据类名获取类
*/
protected static Class<?> getClass(String className) {
try {
return Thread.currentThread().getContextClassLoader().loadClass(className);
// return ReflectUtil.findClass(className);
} catch (ClassNotFoundException e) {
if (log.isDebugEnabled()) {
log.debug("Class not found: " + className);
}
return null;
}
}
/**
* 根据指定的类，方法名及方法参数获取方法对象
*
* @param clazz 方法所属类对象
* @param methodName 方法名
* @param parameterTypes 方法参数
*/
protected static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
if (clazz == null) {
return null;
}
try {
return clazz.getMethod(methodName, parameterTypes);
} catch (SecurityException e) {
log.error("Security exception looking for method " + clazz.getName() + "." + methodName + ". Cause: " + e);
return null;
} catch (NoSuchMethodException e) {
log.error("Method not found " + clazz.getName() + "." + methodName + "." + methodName + ". Cause: " + e);
return null;
}
}
/**
* 调用指定对象的指定方法并返回内容
*
* @param method 指定的方法对象
* @param object 实例化对象
* @param parameters 方法参数
* @return 返回调用方法的返回值
* @throws IOException If I/O errors occur
* @throws RuntimeException If anything else goes wrong
*/
@SuppressWarnings("unchecked")
protected static <T> T invoke(Method method, Object object, Object... parameters)
throws IOException, RuntimeException {
try {
return (T) method.invoke(object, parameters);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
if (e.getTargetException() instanceof IOException) {
throw (IOException) e.getTargetException();
} else {
throw new RuntimeException(e);
}
}
}
/**
* 根据指定的路径，使用当前线程绑定的类加载器获取该路径下所有资源的URL
*
* @param path 指定的资源路径
* @return 所有资源的URL集合 {@link ClassLoader#getResources(String)}.
* @throws IOException If I/O errors occur
*/
protected static List<URL> getResources(String path) throws IOException {
return Collections.list(Thread.currentThread().getContextClassLoader().getResources(path));
}
/**
* 检测当前VFS对象在当前环境下是否有效
*/
public abstract boolean isValid();
/**
* 查找指定的资源名称列表，
*
* @param url 资源url地址
* @param forPath URL标识的资源的路径
* @return 包含资源名称的集合
* @throws IOException If I/O errors occur
*/
protected abstract List<String> list(URL url, String forPath) throws IOException;
/**
* 递归列出在指定路径中找到的所有的完整资源路径。
*
* @param path 资源路径
* @return 所有的完整资源路径集合
* @throws IOException If I/O errors occur
*/
public List<String> list(String path) throws IOException {
List<String> names = new ArrayList<String>();
for (URL url : getResources(path)) {
names.addAll(list(url, path));
}
return names;
}
}