一、反射机制是什么
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
二、反射机制能做什么
1.在运行时判断任意一个对象所属的类；
2.在运行时构造任意一个类的对象；
3.在运行时判断任意一个类所具有的成员变量和方法；
4.在运行时调用任意一个对象的方法；
5.生成动态代理。
三、反射机制的相关API
图片来源于 http://c.biancheng.net/view/1103.html
1.通过一个对象获得完整的包名和类名：
对象名.getClass().getName();
2.实例化Class类对象:
①clazz1 = Class.forName("完整的包名和类名");
②clazz2 = new 构造方法.getClass();
= 对象名.getClass();
③clazz3 = 类名.class;
3.获取一个对象的父类与实现的接口:
获得父类：clazz.getSuperclass();
获得所有的接口：clazz.getInterfaces();
4.获取某个类中的全部构造函数,实例化一个类的对象
①第一种方法，实例化默认构造方法：clazz.newInstance();
②第二种方法，取得全部的构造函数，可先查看每个构造函数的参数类型，再使用构造函数赋值：
clazz.getConstructors()[i].getParameterTypes()[j].getName();
clazz.getConstructors()[i].newInstance(参数);
5.获取某个类的全部属性：
本类的所有属性：
clazz.getDeclaredFields()；
父类或实现的接口的所有属性：
clazz.getFields();
属性名：
fields[i].getName();
属性权限修饰符:
int mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
属性类型:
field[i].getType();
属性类型名：
field[i].getType().getName();
6.获取某个类的全部方法
全部方法：
clazz.getMethods();
方法的返回类型：
methods[i].getReturnType();
某个方法的所有参数类型：
methods[i].getParameterTypes();
7.调用某个类的方法
Method method = clazz.getMethod("方法名",new Class[]{参数类型1，参数类型2，...});
method.invoke(对象名，new Object[]{参数1，参数2，...});
8.操作某个类的属性
可以直接对 private 的属性赋值:
Field field = clazz.getDeclaredField("属性名");
field.setAccessible(true);
field.set(对象名,"属性值");
四、反射机制的应用实例
1.在泛型为Integer的ArrayList中存放一个String类型的对象。
2.通过反射取得并修改数组的信息
3.通过反射机制修改数组的大小
4.将反射机制应用于工厂模式
实例1：利用反射来审查一个对象的内部
Main.java
package reflecttest; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { // 打开连接 // 准备语句，设置参数 // 发送语句，执行并处理结果集（ResultSet） // 遍历结果集，把每一行封装成对象 /* List<Student> students = new ArrayList<>(); for (row : resultSet) { Student student = new Student(); // 要素1：要new的是哪个类 student.setId(row.getInt(1)); // 要素2：这个类中有哪些属性，并且要能调用其setter student.setName(row.getString(2)); student.setAge(row.getInt(3)); students.add(student); } */ // Java中类似镜子的机制叫做反射，可以用来审查某个对象或者某个类的内部（哪些字段，哪些方法，调用之） // 这面镜子叫做元对象（meta object),元数据 Student student = new Student(1, "zhangan", 20); inspect(student); inspect(new Teacher(1, "lisi", "软件工程")); } /** * 审查一个对象（打印类名，打印声明的字段列表，打印定义的方法列表） * @param o */ private static void inspect(Object o) { Class clazz = o.getClass(); // 获取描述对象的元数据 System.out.println("限定类名：" + clazz.getName()); System.out.println("简单类名：" + clazz.getSimpleName()); Field[] fields = clazz.getDeclaredFields(); // 包括public、private等，但排除集成的字段 // System.out.println(Arrays.toString(fields)); // 打印字段列表 for (int i = 0; i < fields.length; i++) { Field field = fields[i]; // field等元信息是跟类走的 Object value; try { // value = field.get(o); // 实际取值或者调用时得传入目标对象（与对象挂钩的） // 默认是不能访问私有字段的，改为调用其getter String getterName = "get" + StringUtils.cap(field.getName()); // getName, getAge Method getter = clazz.getDeclaredMethod(getterName); value = getter.invoke(o); } catch (Exception e) { e.printStackTrace(); value = "--- 取值错误 ---"; } System.out.println("字段：" + field.getName() + ", " + field.getType().getSimpleName() + " = " + value); } // 打印方法列表 Method[] methods = clazz.getDeclaredMethods(); for (int i = 0; i < methods.length; i++) { Method method = methods[i]; System.out.println("方法：" + method.getName() + ", " + method.getReturnType().getSimpleName()); } } }
StringUtils.java
package reflecttest; public class StringUtils { /** * 将首字母大写 * @param name * @return */ public static String cap(String name) { return name.substring(0, 1).toUpperCase() + name.substring(1); } }
Student.java
package reflecttest; public class Student { private Integer id; private String name; private int age; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Student(Integer id, String name, int age) { this.id = id; this.name = name; this.age = age; } public Student() { } @Override public String toString() { return "Student [id=" + id + ", name=" + name + ", age=" + age + "]"; } }
Teacher.java
package reflecttest; public class Teacher { private Integer id; private String name; private String major; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getMajor() { return major; } public void setMajor(String major) { this.major = major; } public Teacher(Integer id, String name, String major) { this.id = id; this.name = name; this.major = major; } public Teacher() { } }
实例2：利用反射给对象属性赋值
Mapper.java
package reflecttest; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; /** * 作为MyBatis的一个最原始的原型 * @author Administrator * */ public class Mapper { /** * 将row中的每一列set到目标类的对象上 * @param clazz * @param row * @return */ public static Object map(Class clazz, Map<String, Object> row) { // new一个目标对象 // new Student() try { // 获取无参构造器 Constructor constructor = clazz.getDeclaredConstructor(); Object obj = constructor.newInstance(); // 将各列set到obj的属性上，如id列就setId(?) for (String columnName : row.keySet()) { // System.out.println(columnName + " -> " + row.get(columnName)); Object value = row.get(columnName); String setterName = "set" + StringUtils.cap(columnName); // 此处忽略一个细节：如果列名对应的setter不存在应该忽略该列 Field field = clazz.getDeclaredField(columnName); Method setter = clazz.getDeclaredMethod(setterName, field.getType()); setter.invoke(obj, value); } return obj; } catch (Exception e) { throw new RuntimeException(e); } } public static void main(String[] args) { Map<String, Object> row = new HashMap<String, Object>(); row.put("id", 3); row.put("name", "王五"); row.put("age", 25); Object obj = map(Student.class, row); System.out.println(obj); } }
实例3：利用Apache Commons工具来复制对象(属性)
BeanUtilsTest.java
package reflecttest; import java.lang.reflect.InvocationTargetException; import org.apache.commons.beanutils.PropertyUtils; public class BeanUtilsTest { public static void main(String[] args) throws Exception { // 如何获取bean属性 // id, name, age Student o = new Student(5, "xyz", 30); String name = (String) PropertyUtils.getProperty(o, "name"); System.out.println("name: " + name); // 如何设置bean属性 PropertyUtils.setProperty(o, "name", "张三"); System.out.println(o.getName()); // 应该是张三 // 如何复制所有属性 Student o2 = new Student(); PropertyUtils.copyProperties(o2, o); System.out.println(o2); } }
案例4：利用反射完成javabean之间的复制
package com.myreflect; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import com.pojo.User; public class ReflectDemo { //写一个类，写一个方法完成两个数求幂值 x的n次方值 //用反射来调用此方法 //写一个工具类，完成功能是javabean之间的复制 方法的原型：copyObject(Object obj1,Object obj2); //从obj1到obj2的复制功能 //思路：Student对象 有属性：id，name，age，sex，birthday 有方法：Set和get方法 //1.创建一个学员类给其属性赋值，然后再创建一个新的学员类，将原来的学员对象的值复制到新的学员对象中 public void copy(Object obj1,Object obj2) throws Exception{ //1.拿到obj1和obj2的类型 Class c1 = obj1.getClass(); Class c2 = obj2.getClass(); //2.通过类型中的获取obj1的get方法取值。obj2的set方法来完成复制功能 Field[] fs1 = c1.getDeclaredFields(); //获取c1中以get开头属性名结尾的所有方法 for (int i = 0; i < fs1.length; i++) { String getmethodName = "get"+cap(fs1[i].getName()); Method getMethod = c1.getDeclaredMethod(getmethodName,null); String setmethodName = "set"+cap(fs1[i].getName()); Method setMethod = c2.getDeclaredMethod(setmethodName, new Class[]{fs1[i].getType()}); Object result = getMethod.invoke(obj1, null); setMethod.invoke(obj2, new Object[]{result}); } } public String cap(String name) { return name.substring(0, 1).toUpperCase() + name.substring(1); } public static void main(String[] args) throws Exception { User user1 = new User(); user1.setUsername("张三"); user1.setPwd("q2w"); User user2 = new User(); ReflectDemo rd = new ReflectDemo(); rd.copy(user1, user2); System.out.println(user2.getUsername()+" "+user2.getPwd()); } }