Class最后一部分源码，这一部分大都是private方法、属性、类，都是Class本身各种方法的实现细节，涉及到了很多Class的实现原理，较为深奥，网上能找到的资料也比较少，目前只懂皮毛，仅供参考，所以，我这一部分说的可能是不正确的，需要抱着怀疑的态度看待！咳，就这样，闪人。
//缓存反射的数据信息
private volatile transient SoftReference<ReflectionData<T>> reflectionData;
//由JVM自动增加，表示虚拟机内，该类被重新定义的次数，JVM TI可以动态更新类定义
//关于类的动态定义这一点，可以参考：
// http://blog.csdn.net/raintungli/article/details/51655608
private volatile transient int classRedefinedCount = 0;
private ReflectionData<T> reflectionData() {
//获取缓存中的反射数据，如果没启用缓存，或者没数据，则调用下面方法，新建反射缓存数据
}
private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
int classRedefinedCount) {
......
}
/**
* 查看该类是否是泛型，虽然jdk上面说的是签名的handler(虽然我也不太明白这签名是什么)，
* 但是我查到，很多地方，包括Class源码上面判断泛型相关，都有类似这句代码：
* if (getGenericSignature() != null)
* 详见：getGenericInterfaces()方法以及类似方法
*/
//
private native String getGenericSignature();
/**
* 该类的类型仓库，其主要作用是操作及缓存该类的类型信息以及父类信息，比如其内就有泛型
* 工厂对象，和父类对象类型信息及所实现的父类接口信息
*/
private transient ClassRepository genericInfo;
/**
* GenericsFactory：泛型工厂，用来生产及操作各种类型对象（Java类型详见：）
* http://blog.csdn.net/a327369238/article/details/52621043
*/
private GenericsFactory getFactory() {
return CoreReflectionFactory.make(this, ClassScope.make(this));
}
private ClassRepository getGenericInfo() {
if (genericInfo == null) {
genericInfo = ClassRepository.make(getGenericSignature(),
getFactory());
}
return genericInfo;
}
//获取该类的注解，本地实现，详见getAnnotation()
native byte[] getRawAnnotations();
//获取常量池
native ConstantPool getConstantPool();
//获取所有字段信息，可根据参数获取相应访问权限类型字段————————方法1
private Field[] privateGetDeclaredFields(boolean publicOnly) {
//只获取该类声明的字段（所有权限类型的），其父类、父接口中声明的并没有
}
//类似上面方法，但是返回的是public类型字段，且包括父类、父接口中声明定义的
//要学会看方法名字，根据英文意思大概能知道方法意义——————————方法2
private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces){
//有反射的缓存数据，则直接获取后返回
//若没有，则通过上面方法获取（参数置为true）
//还要加上其父类以及父接口中声明的公共字段
}
private static void addAll(Collection<Field> c, Field[] o) {
for (int i = 0; i < o.length; i++) {
c.add(o[i]);
}
}
//类似方法1
private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
......
}
//类似方法1
private Method[] privateGetDeclaredMethods(boolean publicOnly) {
......
}
//方法数组类
static class MethodArray {
private Method[] methods;
private int length;
MethodArray() {
methods = new Method[20];
length = 0;
}
void add(Method m) {
if (length == methods.length) {
methods = Arrays.copyOf(methods, 2 * methods.length);
}
methods[length++] = m;
}
void addAll(Method[] ma) {
for (int i = 0; i < ma.length; i++) {
add(ma[i]);
}
}
void addAll(MethodArray ma) {
for (int i = 0; i < ma.length(); i++) {
add(ma.get(i));
}
}
void addIfNotPresent(Method newMethod) {
for (int i = 0; i < length; i++) {
Method m = methods[i];
if (m == newMethod || (m != null && m.equals(newMethod))) {
return;
}
}
add(newMethod);
}
void addAllIfNotPresent(MethodArray newMethods) {
......
}
int length() {
return length;
}
Method get(int i) {
return methods[i];
}
void removeByNameAndSignature(Method toRemove) {
......
}
void compactAndTrim() {
......
}
Method[] getArray() {
return methods;
}
}
//类似方法2
private Method[] privateGetPublicMethods() {
......
}
//根据字段名称获取fields中字段信息————————方法3
private static Field searchFields(Field[] fields, String name) {
}
//只获取public字段————————方法4
private Field getField0(String name) throws NoSuchFieldException {
Field res;
// 首先，在本类公共字段中搜索获取同名字段
if ((res = searchFields(privateGetDeclaredFields(true), name)) != null) {
return res;
}
// 若无，则搜索父接口同名字段，递归调用
Class<?>[] interfaces = getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
Class<?> c = interfaces[i];
if ((res = c.getField0(name)) != null) {
return res;
}
}
// 若仍无，判断该类为非接口类型，获取父类同名字段，递归调用
if (!isInterface()) {
Class<?> c = getSuperclass();
if (c != null) {
if ((res = c.getField0(name)) != null) {
return res;
}
}
}
//都无，则返回空
return null;
}
//类似方法3
private static Method searchMethods(Method[] methods,
String name,
Class<?>[] parameterTypes)
{
......
}
//类似方法4
private Method getMethod0(String name, Class<?>[] parameterTypes) {
......
}
//类似方法4
private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
int which) throws NoSuchMethodException
{
}
//辅助，判断数组是否相等
private static boolean arrayContentsEq(Object[] a1, Object[] a2) {
}
//复制字段数组信息
private static Field[] copyFields(Field[] arg) {
Field[] out = new Field[arg.length];
ReflectionFactory fact = getReflectionFactory();
for (int i = 0; i < arg.length; i++) {
out[i] = fact.copyField(arg[i]);
}
return out;
}
//复制方法数组信息
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;
}
//复制构造器数组信息
private static <U> Constructor<U>[] copyConstructors(Constructor<U>[] arg) {
Constructor<U>[] out = arg.clone();
ReflectionFactory fact = getReflectionFactory();
for (int i = 0; i < out.length; i++) {
out[i] = fact.copyConstructor(out[i]);
}
return out;
}
//以下四个，为获取本类所有声明的字段/方法/构造器/类
private native Field[] getDeclaredFields0(boolean publicOnly);
private native Method[] getDeclaredMethods0(boolean publicOnly);
private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
private native Class<?>[] getDeclaredClasses0();
//输出类型数组各个名称
private static String argumentTypesToString(Class<?>[] argTypes) {
.......
}
private static final long serialVersionUID = 3206093459760846163L;
//ObjectStreamField：序列化的对象中成员属性的元数据信息
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];
//获取该类的断言状态，类的断言状态可通过类的ClassLoader设置
public boolean desiredAssertionStatus() {
......
}
//上面方法的本地实现
private static native boolean desiredAssertionStatus0(Class<?> clazz);
//判断是否是枚举类型
public boolean isEnum() {
return (this.getModifiers() & ENUM) != 0 &&
this.getSuperclass() == java.lang.Enum.class;
}
private static ReflectionFactory getReflectionFactory() {
}
//反射工厂，可以通过可个工厂对类的元数据进行操作，比如新建一个构造器、方法等
private static ReflectionFactory reflectionFactory;
//系统属性是否初始化
private static boolean initted = false;
//判断系统属性是否已经初始化，若已经初始化，直接返回，否则初始化
private static void checkInitted() {
if (initted) return;
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
......
}
}
//如果，此类为枚举类，返回其中的枚举值，否则返回空
public T[] getEnumConstants() {
T[] values = getEnumConstantsShared();
return (values != null) ? values.clone() : null;
}
//如果此类为枚举类，返回其中的枚举值，否则返回空
T[] getEnumConstantsShared() {
......
}
//枚举值
private volatile transient T[] enumConstants = null;
//将枚举转化为map<String, T> String是每个枚举的name属性
Map<String, T> enumConstantDirectory() {
if (enumConstantDirectory == null) {//若缓存中为空
T[] universe = getEnumConstantsShared();//获取所有枚举值
if (universe == null)//为空则抛出异常
throw new IllegalArgumentException(
getName() + " is not an enum type");
Map<String, T> m = new HashMap<>(2 * universe.length);
for (T constant : universe)//遍历存储
m.put(((Enum<?>)constant).name(), constant);
enumConstantDirectory = m;
}
return enumConstantDirectory;
}
private volatile transient Map<String, T> enumConstantDirectory = null;
//强制转换，如实例为null或不是实例对象，且强制转换不成功，抛出异常
public T cast(Object obj) {
if (obj != null && !isInstance(obj))
throw new ClassCastException(cannotCastMsg(obj));
return (T) obj;//只是简单的进行强制转换
}
//无法强转的报错信息
private String cannotCastMsg(Object obj) {
return "Cannot cast " + obj.getClass().getName() + " to " + getName();
}
//将调用这个方法的class对象转换成由clazz参数所表示的class对象的某个子类
//可参考：http://blog.csdn.net/csywwx2008/article/details/17641405
public <U> Class<? extends U> asSubclass(Class<U> clazz) {
if (clazz.isAssignableFrom(this))
return (Class<? extends U>) this;
else
throw new ClassCastException(this.toString());
}
//获得参数对应的注解对象信息
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
if (annotationClass == null)
throw new NullPointerException();
initAnnotationsIfNecessary();
return (A) annotations.get(annotationClass);
}
//判断该注解类型是否是在该类上（有该注解）
public boolean isAnnotationPresent(
Class<? extends Annotation> annotationClass) {
if (annotationClass == null)
throw new NullPointerException();
return getAnnotation(annotationClass) != null;
}
//获取该类上所有注解（包括继承），无，则返回长度为零的注解数组
public Annotation[] getAnnotations() {
initAnnotationsIfNecessary();
return AnnotationParser.toArray(annotations);
}
//获取该类上所有的声明的注解（不包括继承的），无，则返回长度为零的注解数组
public Annotation[] getDeclaredAnnotations() {
initAnnotationsIfNecessary();
return AnnotationParser.toArray(declaredAnnotations);
}
private transient Map<Class<? extends Annotation>, Annotation> annotations;
private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
//类似classRedefinedCount，最后一次注解被定义的个数
private transient int lastAnnotationsRedefinedCount = 0;
//在类被反射重新定义的时候，清除缓存的注解信息
private void clearAnnotationCachesOnClassRedefinition() {
if (lastAnnotationsRedefinedCount != classRedefinedCount) {//二者不相等，说明类有被重新定义
annotations = declaredAnnotations = null;//清空信息
lastAnnotationsRedefinedCount = classRedefinedCount;
}
}
//初始化类的注解（缓存信息：annotations和declaredAnnotations）
private synchronized void initAnnotationsIfNecessary() {
......
}
//注解类型信息缓存
@SuppressWarnings("UnusedDeclaration")
private volatile transient AnnotationType annotationType;
boolean casAnnotationType(AnnotationType oldType, AnnotationType newType) {
return Atomic.casAnnotationType(this, oldType, newType);
}
AnnotationType getAnnotationType() {
return annotationType;
}
transient ClassValue.ClassValueMap classValueMap;
}
1.关于反射工厂ReflectionFactory，是一个很破坏安全的类：
public class Test {
private Test(){
System.out.println("test");
}
public void say(){
System.out.println("hello world");
}
}//按理说，Test这个类只有私有构造器，外部类不能实例化，也就不能在外调用say方法
public class Main{
private static final ReflectionFactory reflectionFactory = (ReflectionFactory) AccessController
.doPrivileged(new ReflectionFactory.GetReflectionFactoryAction());
public static void main(String[] args) throws Exception{
Constructor<Test> constr = reflectionFactory.newConstructorForSerialization(Test.class, Object.class.getConstructor(new Class[0]));
Test test = constr.newInstance(new Object[0]);
test.say();
}
}
/**
* 然而事实，却是可以通过ReflectionFactory这个反射工厂新建一个Test的构造器，而后
* 通过newInstance获取其实例，进而访问其成员方法，这显然是一种对访问权限的破坏
*/