Java反射API
反射定义:
JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
反射最常用到的操作：
取得属性的修饰符，属性名，属性值，设置属性值，取得所有的属性。
操作方法，取得方法的修饰符，方法名，方法参数，方法参数类型，方法返回值，取得一个类的所有方法。
反射可以动态的调用、修改一个对象的任何属性、方法（包括私有属性和方法）。
Field
访问字段：
Field getField(name) : 根据字段名获取某个 public 的field（包括父类）；
Field getDeclaredField(name) : 根据字段名获取当前类的某个 Field（不包括父类，可以获取private属性）
Field[] getFields() : 获取所有 public 的 field（含父类）；
Field[] getDeclaredFields() : 获取当前类的所有 filed （不包括父类）；
Field对象包含的信息：
Object get(Object obj)
getName() ：返回字段名称；
getType() : 返回字段类型， 一个 Class 实例；
getAnnotation(xxx.class) : 获取 xxx 注解；
Type getGenericType() # 字段类型（能正确表示出泛型） java.util.List<java.lang.String> ,ParameterizedType的实例；
field.set(Object,Object) # 设置字段值：(指定的实例，待修改的值)；
getModifiers() ： 字段修饰符，是一个 int；
Method
通过 Class 获取 Method：
Method getMethod(name,Class…) # 获取某个 public 的 Method（包括父类）；
Method getDeclaredMethod(name,Class…) # 获取当前类的某个 Method(不包括父类)；
Method[] getMethods() # 获取所有 public 的Method(包括父类)；
Method[] getDeclaredMethods() # 获取当前类的所有Method(不包括父类)；
Method 对象包含一个方法的所有信息
getName() : 返回方法名称；
getReturnType() : 返回方法的返回值类型，一个 Class 实例；
getParameterTypes() : 返回方法的参数类型，是一个 Class 数组
getParameterAnnotations() ： 返回方法参数的所有注解，是一个Annotation[][]
1、取得一个类的Class对象的三种方式
//第一种 Class<?> clazz1 = Class.forName("com.wp.reflect.entity.Child"); //第二种 Class<? extends Child> clazz2 = new Child().getClass(); //第三种 Class<?> clazz3 = Child.class;
2、获取一个类的父类以及所有实现的接口
Class<?> superclass = clazz1.getSuperclass();
Class<?>[] interfaces = clazz1.getInterfaces();
//取得一个类的全类名（包名 + 类名） clazz1.getName() //取得类的简单名称 clazz1.getSimpleName();
3、构造函数
1、取得一个类的所有构造函数
Class<?> clazz1 = Class.forName("xxxx");
Constructor<?>[] constructors = clazz1.getConstructors();
Constructor<?>[] constructors1 = clazz1.getDeclaredConstructors();
2、根据参数类型取得构造函数
//取得只有一个参数且参数类型为String的构造方法 Constructor<?> constructor1 = clazz1.getDeclaredConstructor(String.class); System.out.println(constructor1);
4、通过反射实例化对象
1、通过Class对象的newInstance()方法
Object instance = clazz1.newInstance();
2、通过构造方法实例化对象
//取得无参构造 Constructor<?> constructor2 = clazz1.getConstructor(); //通过无参构造创建一个对象 Object child1 = constructor2.newInstance(); //取得指定参数的构造方法对象 Constructor<?> constructor3 = clazz1.getConstructor(String.class, int.class); //通过构造方法对象创建一个对象 constructor3.newInstance("wenpan",21);
5、反射操作属性
1、取得本类的所有属性（不包含父类和接口）
Field[] declaredFields = clazz1.getDeclaredFields(); for (int i = 0; i < declaredFields.length; i++) { //属性名称 String fieldName = declaredFields[i].getName(); //属性的类型 String fieldType = declaredFields[i].getType().getName(); //属性修饰符 String fieldModifier = Modifier.toString(declaredFields[i].getModifiers()); System.out.println(fieldModifier + " " + fieldType + " " + fieldName + ";"); }
2、取得实现的接口里的所有属性
Field[] fields = clazz1.getFields(); for (int i = 0; i < fields.length; i++) { //属性名称 String fieldName = fields[i].getName(); //属性的类型 String fieldType = fields[i].getType().getName(); //属性修饰符 String fieldModifier = Modifier.toString(fields[i].getModifiers()); System.out.println(fieldModifier + " " + fieldType + " " + fieldName + ";"); }
3、通过指定属性名取得属性
//通过属性名取得属性
Field field = clazz1.getDeclaredField("name");
//访问私有属性需要设置Accessible为true才可以更改或读取值（get 或 set）
field.setAccessible(true);
//取得instance对象里面的属性值
System.out.println("更改前的name值：" + field.get(instance));
//更改instance对象里的name属性值
field.set(instance,"文攀啊");
System.out.println("更改后的name属性值：" + field.get(instance));
通过属性名获取属性： Field field = clazz1.getDeclaredField("name"); 返回的是属性对象: Field
6、反射操作方法
1、取得一个类的所有方法（包括父类和实现的接口）
Method[] methods = clazz1.getMethods();
Method[] methods = clazz1.getMethods(); //输出取得的方法 for (int i = 0; i < methods.length; i++) { StringBuffer buffer = new StringBuffer(); //方法修饰符 String modifier = Modifier.toString(methods[i].getModifiers()); //返回值类型 String returnType = methods[i].getReturnType().getSimpleName(); //方法名 String name = methods[i].getName(); //方法参数类型 Class<?>[] parameterTypes = methods[i].getParameterTypes(); buffer.append(modifier).append(" ").append(returnType).append(" "). append(name).append("("); for (int j = 0; j < parameterTypes.length; j++) { buffer.append(parameterTypes[j].getSimpleName()).append(" arg").append(j); if(j < parameterTypes.length - 1){ buffer.append(","); } } buffer.append(")"); //方法抛出的异常信息 Class<?>[] exceptionTypes = methods[i].getExceptionTypes(); if(exceptionTypes.length > 0){ buffer.append(" throws"); } for (int k = 0; k < exceptionTypes.length; k++) { buffer.append(exceptionTypes[k].getSimpleName()); if(k < exceptionTypes.length -1){ buffer.append(","); } } buffer.append("{ }"); System.out.println(buffer); }
2、取得一个类的所有方法（不包括父类和实现的接口）
Method[] declaredMethods = clazz1.getDeclaredMethods();
3、通过反射调用某个对象的方法
要调用某个对象的方法，首先这个对象得存在，所以可以通过反射创建一个对象
public static void main(String[] args) throws Exception { //使用反射将Child类的Class对象加载进来 Class<?> clazz1 = Class.forName("com.wp.reflect.entity.Child"); //创建一个实例对象（使用反射调用方法必须要有实例对象） Object instance = clazz1.newInstance(); //通过方法名称和指定的参数类型获取指定方法 Method method = clazz1.getDeclaredMethod("setName", String.class); //调用Method对象的invoke方法执行instance对象的方法 method.invoke(instance,"文攀啊"); //通过方法名称和指定的参数类型获取指定方法 Method getNameMethod = clazz1.getMethod("getName"); //调用Method对象的invoke方法执行方法 String name = (String)getNameMethod.invoke(instance); //输出执行方法返回的结果 System.out.println(name); }
通过方法名和方法参数类型取得对象的方法：Method method = clazz1.getDeclaredMethod(“setName”, String.class);
7、反射操作注解
1、通过反射获取类上的注解，类属性上的注解
public static void main(String[] args) throws Exception{ User user = new User(); // 取得类上的所有注解 Annotation[] annotations = user.getClass().getAnnotations(); // 获取类上指定类型的注解 MyAnnotation annotation = user.getClass().getAnnotation(MyAnnotation.class); // 获取类的某个属性上的所有注解 Annotation[] allAnnotations = user.getClass().getDeclaredField("name").getAnnotations(); // 获取类的某个属性上指定类型的注解 MyAnnotation annotation1 = user.getClass().getDeclaredField("name").getAnnotation(MyAnnotation.class); // 获取注解的属性 String value = annotation1.value(); String pattern = annotation1.pattern(); }
8、反射实例应用
1、使用反射向一个int集合添加一个String元素
**原理：**首先通过反射取得该List集合的add（）方法，然后使用反射调用该方法向list集合里面添加一个String类型元素
//创建一个int类型的集合 ArrayList<Integer> list = new ArrayList<Integer>(); //取得集合的添加方法 Method addMethod = list.getClass().getMethod("add", Object.class); //执行集合的add方法，向集合中添加一个String类型元素 addMethod.invoke(list, "wenpan"); System.out.println("取得元素=========================>" + list.get(0));
2、通过反射修改数组元素的值
**原理：**其实就是通过反射中的 Array.get() 和 Array.set()来读取和修改数组中的元素值。
int temp[] = {1,2,3,4,5}; System.out.println("数组第一个元素：" + Array.get(temp,0)); Array.set(temp,0,100); System.out.println("修改之后数组第一个元素为：" + Array.get(temp,0));
扩展方法：
int temp[] = {1,2,3,4,5}; //取得数组的类型，该方法为动态扩展数组大小做铺垫 Class<?> componentType = temp.getClass().getComponentType(); System.out.println("数组类型：" + componentType.getName()); System.out.println("数组长度：" + Array.getLength(temp));
3、通过反射修改数组的大小
**原理：**其本质就是通过反射得到原数组的类型，然后通过Array.newInstance()方法根据数组类型创造出一个指定长度的新数组，最后使用System.arraycopy()方法将原数组的值拷贝到新数组中
public static Object arrayInc(Object obj, int length) { //取得传入数组的类型，以便于创造出同类型的数组 Class<?> componentType = obj.getClass().getComponentType(); //根据传入的数组类型创建出新的指定长度的数组实例 Object newArr = Array.newInstance(componentType, length); //原有的数组长度 int originArrLen = Array.getLength(obj); //将原有的数组数据拷贝到新的数组中去 System.arraycopy(obj,0,newArr,0,originArrLen); //返回修改大小后的数组 return newArr; }
4、通过反射实现通用工厂模式
class Factory { /** * 通过传入的全类名返回该类的对象 * 但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。 * java读取配置文件可实现完全解耦 * @param className * @return */ public static Object getInstance(String className){ Object instance = null; try { //通过反射创建对象实例 instance = Class.forName(className).newInstance(); }catch (Exception e) { e.printStackTrace(); } return instance; } }
public static void main(String[] args) { //反射工厂 Apple apple = (Apple)Factory.getInstance("com.wp.reflect.Apple"); apple.method(); Banana banana = (Banana)Factory.getInstance("com.wp.reflect.Banana"); banana.method(); }
反射还可以实现动态代理
9 安全问题
如下形式enum 枚举类实现单例模式
public enum EnumSingleton { INSTANCE; private EnumSingleton(){ } public static EnumSingleton getInstance() { return INSTANCE; } }
在反射的newInstance()方法里面，会检查该类是否ENUM修饰，如果是则抛出异常，反射失败，枚举类实现单例模式不用怕反射破坏
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { //其他代码已删除 if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); //其他代码已删除 }
总结: 只有枚举实现单例模式可以防止反射攻击，其它单例模式无法防止
