六、反射类分析

六、反射 

    原理：反射是指计算机程序在运行时可以访问、检测和修改它本身状态或行为的一种能力。

    1.Class类

            获取：Object对象getClass()方法会返回一个Class类型的实例 ；

            方法：

                        forName(pathName) ;   通过class路径获取Class对象

                        newInstance() ;  快速创建一个Class实例

                        

                        getModifiers() ; 返回标识符

                        getName() ; 返回类名字

                        getMethods() ; 返回公有方法  （包括超类公有成员）

                        getFields() ;  返回公有字段  （包括超类公有成员）·

                        getConstructors() 返回公有构造器数组    （包括超类公有成员）

                        getParameterTypes() ; 返回参数类型

                        getMethods() ; 返回全部方法  （不包括超类的成员）

                        getFields() ;  返回全部字段  （不包括超类的成员）

                        getConstructors() 返回全部构造器数组    （不包括超类的成员）

    2.Method类

            获取：通过class.getMethods()获取 ;

            方法：

                        getModifiers() ; 返回标识符

                        getReturnType() ; 返回返回类型

                        getName() ; 返回方法名字

                        getParameterTypes() ;返回参数类型

                            

                        

    3.Field类

            获取：通过class.getFields()获取 ；

            方法：

                        getModifiers() ; 返回标识符

                        getType() ; 返回类型 

                        getName() ;  返回名称

    4.Modifier类

            作用：判断标识符  如public、final、static等

            获取：通过getModifiers() 获取 ;

            方法：

                        toString(int) ; 返回标识符

                        isPublic(int) ; 判断是否公有

                        isPrivate(int) ; 判断是否私有

                        isStatic(int) ; 判断是否公有

                        isFinal(int) ; 判断是否公有

实例：1.类分析器

package net.itaem.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * 
 * 类分析器
 * @author sen
 * @version 1.0,2014年8月23日
 */
public class AnalysisUtils {
	
	/**
	 * 实现具有防御型单例
	 */
	private static final AnalysisUtils analysisUtils = new AnalysisUtils() ;
		
	/**
	 * 私有构造函数防止多次实例化
	 */
	private AnalysisUtils(){
		if(analysisUtils==null){
			
		}else{
			//被反射攻击了
			throw new RuntimeException("AnalysisUtils被反射攻击了") ;
		}
	}
	
	/**
	 * 
	 * 打印全部类信息
	 * @author sen
	 * @param clazzName 类路径名
	 */
	@SuppressWarnings("rawtypes")
	public static void printAll(String clazzName){
		
		try {
			/*
			 * 获取类信息
			 */
			Class clazz = Class.forName(clazzName); //通过类名加载类
			/*
			 * 打印
			 */
			printAll(clazz) ;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * 打印全部类信息
	 * @author sen
	 * @param Object obj实例
	 */
	@SuppressWarnings("rawtypes")
	public static void printAll(Object obj){
		
		/*
		 * 获取类信息
		 */
		Class clazz = obj.getClass() ; //通过类名加载类
		/*
		 * 打印
		 */
		printAll(clazz) ;
	}
	
	/**
	 * 
	 * 打印全部类信息
	 * @author sen
	 * @param clazz class类
	 */
	@SuppressWarnings("rawtypes")
	public static void printAll(Class clazz){
		
		/*
		 * 获取类信息
		 */
		Class superClazz = clazz.getSuperclass() ; //获取超类
		String modifiers = Modifier.toString(clazz.getModifiers()) ; //获取标识符
		
		/*
		 * 打印
		 */
		if(modifiers.length() > 0)
			System.out.print(modifiers + " "); //打印标识符
		System.out.print("class " + clazz.getName()); //打印类名
		if(superClazz != null && superClazz != Object.class)
			System.out.print(" extends " + superClazz.getName()); //打印超类名
		
		//打印字段信息
		System.out.print("\n{\n");
		printFields(clazz);
		
		//打印构造器信息
		System.out.println();
		printConstructors(clazz);
		
		//打印
		System.out.println();
		printMethods(clazz);
		
		//尾结束符
		System.out.println("}");
	}
	
	/**
	 * 
	 * 打印构造器
	 * @author sen
	 * @param String 类路径
	 */
	@SuppressWarnings("rawtypes")
	public static void printConstructors(String clazzName){
		try {
			/*
			 * 获取类信息
			 */
			Class clazz = Class.forName(clazzName); //通过类名加载类
			/*
			 * 打印
			 */
			printConstructors(clazz) ;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * 打印构造器
	 * @author sen
	 * @param Object 实例
	 */
	@SuppressWarnings("rawtypes")
	public static void printConstructors(Object obj){
		/*
		 * 获取类信息
		 */
		Class clazz = obj.getClass() ; //通过类名加载类
		/*
		 * 打印
		 */
		printConstructors(clazz) ;
	}

	/**
	 * 
	 * 打印构造器
	 * @author sen
	 * @param clazz
	 */
	@SuppressWarnings("rawtypes")
	public static void printConstructors(Class clazz){
		System.out.println("	/*构造器*/");
		/*
		 * 获取类的全部构造器
		 */
		Constructor[] constructors = clazz.getDeclaredConstructors() ;
		
		/*
		 * 遍历
		 */
		for(Constructor c : constructors){
			/*
			 * 获取构造器信息
			 */
			String modifiers = Modifier.toString(c.getModifiers()) ; //获取标识符
			String name = c.getName() ; //获取名称
			Class[] paramTypes = c.getParameterTypes() ; //获取参数类型
			
			/*
			 * 打印 
			 */
			System.out.print("	") ;
			if(modifiers.length() > 0)
				System.out.print(modifiers + " ");	//打印标识符
			System.out.print(name + "("); //打印名称
			
			//打印参数
			for(int typeIndex = 0 ; typeIndex<paramTypes.length; typeIndex++){
				if(typeIndex>0)
					System.out.print(", ");
				if(paramTypes[typeIndex].isArray())
					System.out.println(paramTypes[typeIndex].getComponentType()+"[]");
				else
					System.out.print(paramTypes[typeIndex].getName()); //打印参数
			}
			System.out.println(");");
		}
	}
	
	/**
	 * 
	 * 打印方法
	 * @author sen
	 * @param String 类路径
	 */
	@SuppressWarnings("rawtypes")
	public static void printMethods(String clazzName){
		try {
			/*
			 * 获取类信息
			 */
			Class clazz = Class.forName(clazzName); //通过类名加载类
			/*
			 * 打印
			 */
			printMethods(clazz) ;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * 打印方法
	 * @author sen
	 * @param Object 实例
	 */
	@SuppressWarnings("rawtypes")
	public static void printMethods(Object obj){
		/*
		 * 获取类信息
		 */
		Class clazz = obj.getClass() ; //通过类名加载类
		/*
		 * 打印
		 */
		printMethods(clazz) ;
	}
	/**
	 * 
	 * 打印方法
	 * @author sen
	 * @param clazz
	 */
	@SuppressWarnings("rawtypes")
	public static void printMethods(Class clazz){
		System.out.println("	/*方法*/");
		/*
		 * 获取类的所有方法
		 */
		Method[] methods = clazz.getDeclaredMethods() ;
		
		/*
		 * 遍历
		 */
		for(Method m : methods){
			System.out.print("	");
			/*
			 * 获取方法信息
			 */
			String modifiers = Modifier.toString(m.getModifiers()); //获取标识符
			Class retType = m.getReturnType() ; //获取返回类型
			String name = m.getName() ; //获取方法名
			Class[] paramTypes = m.getParameterTypes() ; //获取参数
			
			/*
			 * 打印
			 */
			if(modifiers.length() > 0)
				System.out.print(modifiers + " "); //打印标识符
			System.out.print(retType.getName() + " " + name + "("); //打印返回类型和名称
			
			//打印参数
			for(int typeIndex=0; typeIndex<paramTypes.length; typeIndex++){
				if(typeIndex > 0)
					System.out.print(", ");
				if(paramTypes[typeIndex].isArray())
					System.out.println(paramTypes[typeIndex].getComponentType()+"[]");
				else
					System.out.print(paramTypes[typeIndex].getName());
			}
			System.out.println(");");
		}
	}
	
	/**
	 * 
	 * 打印字段
	 * @author sen
	 * @param String 类路径
	 */
	@SuppressWarnings("rawtypes")
	public static void printFields(String clazzName){
		try {
			/*
			 * 获取类信息
			 */
			Class clazz = Class.forName(clazzName); //通过类名加载类
			/*
			 * 打印
			 */
			printFields(clazz) ;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * 打印字段
	 * @author sen
	 * @param Object 实例
	 */
	@SuppressWarnings("rawtypes")
	public static void printFields(Object obj){
		/*
		 * 获取类信息
		 */
		Class clazz = obj.getClass() ; //通过类名加载类
		/*
		 * 打印
		 */
		printFields(clazz) ;
	}
	/**
	 * 
	 * 打印字段信息
	 * @author sen
	 * @param clazz 类对象
	 */
	@SuppressWarnings("rawtypes")
	public static void printFields(Class clazz){
		System.out.println("	/*字段*/");
		/*
		 * 获取类的全部字段信息
		 */
		Field[] fields = clazz.getDeclaredFields() ;
		
		/*
		 * 遍历字段
		 */
		for(Field f : fields){
			System.out.print("	");
			
			/*
			 * 获取标识符、类型、名称
			 */
			String modifiers = Modifier.toString(f.getModifiers()) ; //获取标识符
			Class type = f.getType() ;  //获取类型
			String name = f.getName() ; //获取名称
			
			/*
			 * 打印
			 */
			if(modifiers.length() > 0)
				System.out.print(modifiers + " "); //打印标识符
			//打印类型和名称
			if(type.isArray())
				System.out.println(type.getComponentType() + "[] " + name + ";");
			else
				System.out.println(type.getName() + " " + name + ";"); //打印类型和名称
		}
	}
}

2.toString（）工具类

package net.itaem.reflect;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * 
 * toString工具类
 * @author sen
 * @version 1.0,2014年8月23日
 */
public class ToStringUtils {
	
	@SuppressWarnings("rawtypes")
	public static String toString(Object obj){
		/*
		 * 验证
		 */
		//判断是否为空
		if(obj == null)
			return "null" ;
		//获取类对象
		Class clazz = obj.getClass() ;
		//判断是否为String类型
		if(clazz == String.class)
			return (String)obj ; //直接返回
		
		/*
		 * 存储内容
		 */
		StringBuilder higher = new StringBuilder() ;  //上级元素
		
		
		/*
		 * 数组类型
		 */
		if(clazz.isArray()){
			higher.append(clazz.getComponentType().getName()).append("[]{") ;//打印数据类型
			
			//遍历数组
			for(int i=0; i<Array.getLength(obj);i++){
				if(i>0) 
					higher.append(",") ;
				
				//获取数组第i个对象
				Object val = Array.get(obj, i) ;
				
				//如果是原始类型
				if(clazz.getComponentType().isPrimitive())
					higher.append(val) ;  //原始类型
				//非原始类型
				else
					higher.append(toString(val)) ; //递归
			}
			
			//结束符
			higher.append("}") ;
			
			return higher.toString() ;
		}
		
		/*
		 * 非数组类型
		 */
		StringBuilder lower = new StringBuilder() ; //下级元素
		
		lower.append(clazz.getName()) ;//获取类名称
		
		while(clazz != Object.class){
			lower.append("[") ;
			
			/*
			 * 获取全部字段
			 */
			Field[] fields = clazz.getDeclaredFields() ;
			//设置字段可访问权限 ,可查询和设置字段值  （ 默认为false）
			AccessibleObject.setAccessible(fields, true);
			
			/*
			 * 遍历字段
			 */
			for(Field f : fields){
				//非全局字段
				if(!Modifier.isStatic(f.getModifiers())){
					if(!lower.toString().endsWith("["))
						lower.append(",") ;
					//获取字段名称
					lower.append(f.getName()).append("=") ;
					
					try{
						//获取字段类型
						Class t = f.getType() ;
						//获取字段
						Object val = f.get(obj) ;
						
						//原始类型
						if(t.isPrimitive())
							lower.append(val) ;
						//非原始类型
						else
							lower.append(toString(val)) ;
					} catch(Exception e){
						e.printStackTrace(); 
					}
				}
			}
			
			//结束符
			lower.append("]") ;
			//父类
			clazz = clazz.getSuperclass() ;		
			
		}
		
		return lower.toString() ;
	}
}