一.概述
我们在<a href="http://www.jianshu.com/p/4791207253a0">jdk源码分析（一）</a>中讲了Object类，今天要讲的Class类同样非常基础。java程序中所有正在运行中的类和接口都是Class类的实例。枚举类型，数据，所有的java基础类型以及关键字void都是Class实例。
类声明：
public final class Class<T> implements java.io.Serializable,
java.lang.reflect.GenericDeclaration,
java.lang.reflect.Type,
java.lang.reflect.AnnotatedElement
Class类中方法非常多，有超过50个方法，但是经过梳理，我们可以发现，其实方法主要有三类：生成实例、获取类信息、类型转换。
下面我们分别来看一下这三类方法。
二.生成实例
此类方法的主要目的是根据给定的类名，加载类信息并执行初始化。然后可以根据已经完成初始化的信息生成类的实例。
这一类方法主要有两个：
forName方法和newInstance方法。
我们先来看forName方法，这个方法相信大家都不陌生，如果你曾经使用过jdbc进行mysql数据库操作，那么你一定写过如下代码：
String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/test";
String username = "root";
String password = "123456";
Connection conn = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
我们这里只看forName方法。forName方法有两种声明：
public static Class<?> forName(String className)
throws ClassNotFoundException {
return forName0(className, true, ClassLoader.getCallerClassLoader());
}
public static Class<?> forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException {
// 如果传入的类加载器为null，则获取调用类的类加载器
if (loader == null) {
// 获取安全管理器
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// 获取调用类的类加载器
ClassLoader ccl = ClassLoader.getCallerClassLoader();
if (ccl != null) {
// 使用安全管理器检查是否有获取类加载器的权限
sm.checkPermission(
SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
}
}
return forName0(name, initialize, loader)
}
从以上代码可以看到，第一个forName方法相当于调用
forName(name, true, null)
最终两个forName方法都调用了forName0方法：
private static native Class forName0(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException;
这是一个本地方法，我们暂且不深究，只需知道forName0方法将根据指定类完全限定名，以及类加载器完成类的加载，如果需要，还将执行类的初始化操作。
在forName方法实现中，出现了两个类，一个是SecurityManager，另一个是ClassLoader，其中SecurityManager是jvm提供的在应用层进行安全检查的机制，应用程序可以根据策略文件被赋予一定的权限，例如是否可以读写文件，是否可以读写网络端口，是否可以读写内存，是否可以获取类加载器……。在进行特殊操作时，需要进行安全检查，从而给程序的运行安全提供一定保障。
而ClassLoader则涉及到另一个大的话题：类加载，此处我们暂时先不深入展开，只需知道我们程序运行中使用的类都需要由类加载器来完成加载，并执行一定的初始化，随后才可以被我们使用。
类完成加载后，通常需要被实例化，而这就会用到newInstance方法了。
// 获取类的实例
public T newInstance()
throws InstantiationException, IllegalAccessException {
// 进行安全检查
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), false);
}
return newInstance0();
}
/**
* 检查客户端是否有成员的访问权限
* @param which 权限识别码，整数类型
* @param ccl 类加载器
* @param checkProxyInterfaces
*/
private void checkMemberAccess(int which, ClassLoader ccl, boolean checkProxyInterfaces) {
SecurityManager s = System.getSecurityManager();
if (s != null) {
// 检查客户端能否有权限访问该类
s.checkMemberAccess(this, which);
ClassLoader cl = getClassLoader0();
if (ReflectUtil.needsPackageAccessCheck(ccl, cl)) {
// 获取类的完全限定名
String name = this.getName();
int i = name.lastIndexOf('.');
// 类的完全限定名中含有.（例如com.Test）
if (i != -1) {
// 获取包名
String pkg = name.substring(0, i);
// 如果该类是com.sun.proxy包下的代理类，则不需要进行包访问权限验证，否则需要验证
// 代理类指使用Proxy.getProxyClass或Proxy.newProxyInstance动态生成的类
if (!Proxy.isProxyClass(this) || !pkg.equals(ReflectUtil.PROXY_PACKAGE)) {
s.checkPackageAccess(pkg);
}
}
}
// 如果该类是代理类，并且需要检查代理类的接口，则检查接口的访问权限
if (checkProxyInterfaces && Proxy.isProxyClass(this)) {
ReflectUtil.checkProxyPackageAccess(ccl, this.getInterfaces());
}
}
}
private T newInstance0() throws InstantiationException, IllegalAccessException {
// 每次先检查是否有已经缓存过的构造器，如果没有，则重新获取
if (cachedConstructor == null) {
// 如果该类是Class类，则直接抛出异常，意思是，我们不能利用此方法生成Class类的实例
if (this == Class.class) {
throw new IllegalAccessException(
"Can not call newInstance() on the Class for java.lang.Class"
);
}
try {
Class[] empty = {};
// 获取该类已经声明的的无参构造方法
final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
// 此处是为了使无参构造方法可以被访问，因为有时，构造方法被声明为private的
java.security.AccessController.doPrivileged
(new java.security.PrivilegedAction() {
public Object run() {
c.setAccessible(true);
return null;
}
});
// 将获取的无参构造方法缓存
cachedConstructor = c;
} catch (NoSuchMethodException e) {
throw new InstantiationException(getName());
}
}
Constructor<T> tmpConstructor = cachedConstructor;
// 获取构造方法的语言修饰符，诸如public,private,static,final等
int modifiers = tmpConstructor.getModifiers();
// 根据已经获取的语言修饰符判断是否具有访问权限，如果没有，则执行以下操作
if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
// 获取调用者的类
Class caller = Reflection.getCallerClass(3);
// 与之前缓存的调用者类进行对比，如果不是之前的，则需重新确保调用者类可以访问无参构造方法
if (newInstanceCallerCache != caller) {
Reflection.ensureMemberAccess(caller, this, null, modifiers);
newInstanceCallerCache = caller;
}
}
try {
// 整个方法的核心，使用类的构造方法来生成实例
return tmpConstructor.newInstance((Object[]) null);
} catch (InvocationTargetException e) {
Unsafe.getUnsafe().throwException(e.getTargetException());
return null;
}
}
以上就是newInstance的具体实现，本质上是获取的类的无参构造方法，然后执行无参构造方法来生成实例。
三.获取类信息
这一类方法非常多，作用包括获取类的构造方法，已经声明的字段、方法，获取类或者方法的注解，获取类的包名、父类，以及判断类是否是数组、是否是枚举、是否是接口。由于方法众多，此处不一一列举，只选择一个看看究竟，不妨看看getDeclaredMethods方法。
// 返回类中声明的方法，核心实现在privateGetDeclaredMethods和copyMethods中
public Method[] getDeclaredMethods() throws SecurityException {
checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
return copyMethods(privateGetDeclaredMethods(false));
}
// 拷贝方法数组，使用ReflectionFactory来拷贝
//个人理解之所以需要拷贝是因为不想让获取的方法被随意修改
private static Method[] copyMethods(Method[] arg) {
Method[] out = new Method[arg.length];
ReflectionFactory fact = getReflectionFactory();
for (int i = 0; i < arg.length; i++) {
out[i] = fact.copyMethod(arg[i]);
}
return out;
}
/**
* 获取类中声明方法的具体实现
* @param publicOnly 是否只获取public方法
* @return 方法数组
*/
private Method[] privateGetDeclaredMethods(boolean publicOnly) {
// 等待系统内部类初始化完成，系统属性(sun.reflect.noCaches)被解析完成
checkInitted();
Method[] res = null;
// 根据用户指定的系统属性sun.reflect.noCaches值来决定是否使用缓存，默认使用缓存
if (useCaches) {
// 清空缓存，将缓存的declaredFields、declaredMethods、annotations等设置为null
clearCachesOnClassRedefinition();
// 如果只获取public方法
if (publicOnly) {
// 如果declaredPublicFields缓存可用，则直接从缓存中获取
if (declaredPublicMethods != null) {
res = (Method[]) declaredPublicMethods.get();
}
} else {
// 如果declaredMethods缓存可用，则直接从缓存中获取
if (declaredMethods != null) {
res = (Method[]) declaredMethods.get();
}
}
if (res != null) return res;
}
// 不使用缓存，则需要调用本地方法进行获取
res = getDeclaredMethods0(publicOnly);
// 如果可以使用缓存，则设置缓存，以备下次使用
if (useCaches) {
if (publicOnly) {
declaredPublicMethods = new SoftReference(res);
} else {
declaredMethods = new SoftReference(res);
}
}
return res;
}
private native Method[] getDeclaredMethods0(boolean publicOnly);
四.类型转换
该类方法主要有两个：
/**
* 将类转换为它的子类Class
* @param clazz 父类的Class
* @param <U> 父类
* @return U的子类Class
*/
public <U> Class<? extends U> asSubclass(Class<U> clazz) {
// 判断clazz是否是当前类，或者是当前类的父类
if (clazz.isAssignableFrom(this))
return (Class<? extends U>) this;
else
throw new ClassCastException(this.toString());
}
/**
* 将给定的类转换为当前Class所代表的类
* @param obj 需要转换的类
* @return 当前Class所代表的类
*/
public T cast(Object obj) {
// obj不为null，并且可以被转换为当前Class代表的类
// isInstance为native方法，类似于instanceOf的作用
if (obj != null && !isInstance(obj))
throw new ClassCastException();
return (T) obj;
}
五.使用示例
class Car {
private String name = "car";
public String getName() {
return name;
}
}
class SUV extends Car {
private String name = "suv";
@Override
public String getName() {
return name;
}
}
class Tiguan extends SUV {
private String name = "tiguan";
@Override
public String getName() {
return name;
}
}
public class ClassTest {
public static void main(String[] args) {
try {
// 使用forName方法与newInstance方法生成实例
Car tiguanCar = (Car) Class.forName("Tiguan").newInstance();
// 输出"tiguan"
System.out.println(tiguanCar.getName());
// 从上面的输出可以看出，tiguanCar是一个Tiguan实例，将其转换为SUV的类
// 注意，此处只能窄化tiguanCar的范围，本质上仍然是Tiguan.class
Class<? extends SUV> tiguanClass = tiguanCar.getClass().asSubclass(SUV.class);
// 输出"class Tiguan"
System.out.println(tiguanClass);
// 将tiguanCar转换为SUV实例,tiguanCar是一个Tiguan类的实例，作用与(SUV) tiguanCar一样。
SUV suv = SUV.class.cast(tiguanCar);
// 输出"tiguan"
System.out.println(suv.getName());
// 获取Tiguan类声明的字段
Field[] tiguanFields = tiguanClass.getDeclaredFields();
// 输出"name"
for (Field field : tiguanFields) {
System.out.println(field.getName());
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
参考资料
- java Class类详解
- Java反射相关类源码浅析-Class类
- Class.asSubclass浅谈
- Class.asSubclass signature
- Java安全管理器——SecurityManager
- java Class.forName详解
另外本文中结构图使用了ProcessOn免费在线作图工具，感觉很赞，推荐一下。
本文已迁移至我的博客：http://ipenge.com/11304.html
