Java学习之反射

反射，在开发项目时， 需要使用DBUtils，好奇心的驱使之下， 阅读了一下DBUtils的源码， 发现在将数据库结果集转换为JavaBean

就是通过反射实现的，但对反射没有一个较深入的了解！

一. 反射的概念

反射是指程序可以访问、检测和修改它本身状态或行为的一种能力，允许以编程方式访问有关加载类的字段，方法和构造函数的信息，

以及在安全限制内使用反射的字段，方法和构造函数对其底层进行操作。

反射是JDK 1.1引入的机制， 便于创建高度灵活的代码， 代码可以运行时装配，但是如果使用不当， 使用成本会很高，建议阅读DBUtils

源码先小试牛刀， 如果有兴趣， 可以继续阅读spring源码。

注意： 不要和内省的概念相混淆， 内省用于在运行时检测某个对象的类型和其包含的属性； 而反射除了检测还可以修改， 如C++只支

持内省， 但是不支持反射。

二. 反射机制的作用

1. 反编译： class文件反编译为Java文件

2. 通过反射机制访问bean的属性、方法、构造方法； 可以动态的根据传入的数据选择正确的类型接收处理；修改

构造函数、方法、属性的可见性；例如在Struts框架中， 框架确定处理请求的Action类之后， 就是通过反射机制来实现

的Action类的加载。

三、反射类

java.lang.Classjava.lang.reflect.Constructorjava.lang.reflect.Field      java.lang.reflect.Methodjava.lang.reflect.Modifier

很多对象中的方法、属性等操作这四个类中查询。API才是成就霸业的军师。

四、实例

public class User {      private int id;      private int age;      private String username;      private String password;  } 

1. 通过反射机制从对象获取类

// 方式1Class userClass1 = Class.forName("User");// 方式2Class userClass2 = User.class;// 方式3Class userClass3 = new User().getClass();

2. 从已有对象创建新对象

User user01 = new User();User user02 = user01.getClass().newInstance();

3. 获取对象所有属性

public static void main(String[] args) throws ClassNotFoundException,            InstantiationException, IllegalAccessException {        Class c = Class.forName("java.lang.String");                Field[] fs = c.getDeclaredFields();        StringBuffer sb = new StringBuffer();         sb.append(Modifier.toString(c.getModifiers()) + " class "                + c.getSimpleName() + "{\n");        for (Field field : fs) {            sb.append("\t");//tab            sb.append(Modifier.toString(field.getModifiers()) + " ");            sb.append(field.getType().getSimpleName() + " ");// 属性的类型            sb.append(field.getName() + ";\n");// 属性名        }        sb.append("}");        System.out.println(sb);    }

4. 获取对象单个属性

public static void main(String[] args) throws NoSuchFieldException,            SecurityException, ClassNotFoundException, InstantiationException,            IllegalAccessException {        Class c = Class.forName("User");        Field username = c.getDeclaredField("username");        Object user = c.newInstance();        username.setAccessible(true); // 使用反射机制可以打破封装性，导致了java对象的属性不安全。        // username属性赋值"harry"        username.set(user, "harry");         System.out.println(username.get(user));    }

5. 获取对象方法及调用方法(有参和无参)

public class MyReflect {    public static void main(String[] args) {        Method method;        Task t = new Task();                try {            // 1. 获取带参数的方法            method = t.getClass().getMethod("setAll", new Class<?>[]{int.class, String.class});            // 2. 调用带参数的方法            method.invoke(t, 10, "update");                        // 1. 获取无参方法            method = t.getClass().getMethod("print", new Class<?>[0]);            // 2. 调用无参方法            method.invoke(t);                        // 1. 获取无参方法            method = t.getClass().getMethod("getTaskComment", new Class<?>[0]);            //method = t.getClass().getMethod("getTaskComment", null); // 使用这种方式时， 会产生警告            // 2. 调用方法并获取返回值            Object comment = method.invoke(t);            System.out.println(comment);        } catch (Exception e) {            e.printStackTrace();        }               }        private static class Task {        private int taskId;        private String taskComment;        public int getTaskId() {            return taskId;        }        public void setTaskId(int taskId) {            this.taskId = taskId;        }        public String getTaskComment() {            return taskComment;        }        public void setTaskComment(String taskComment) {            this.taskComment = taskComment;        }                public void print() {            System.out.println(this.taskId + "   " + this.taskComment);        }                public void setAll(int taskId, String taskComment) {            this.taskComment = taskComment;            this.taskId = taskId;        }    }}

6. 从类名字符串创建对象

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {        Class<?> clazz = Class.forName("com.main.User");        User user = (User)clazz.newInstance();                user.print();    }

7. 获取构造方法并从构造方法创建对象

public static void main(String[] args) throws ClassNotFoundException,            InstantiationException, IllegalAccessException,            NoSuchMethodException, SecurityException, IllegalArgumentException,            InvocationTargetException {        Class<?> clazz = Student.class;        // 1. 从带参构造方法获取实例        Constructor<?> conMethod = clazz.getConstructor(new Class<?>[] {                int.class, String.class });        Object o = conMethod.newInstance(20, "harry");        Method print = clazz.getMethod("print", new Class<?>[0]);        print.invoke(o);        // 2. 从无参构造方法获取实例        Constructor<?> conMethod1 = clazz.getConstructor(new Class<?>[0]);        Object o1 = conMethod1.newInstance();        clazz.getMethod("setUsername", String.class).invoke(o1, "natasha");        System.out.println(clazz.getMethod("getUsername").invoke(o1));        // 3. 获取所有构造方法        Constructor<?> cons[] = clazz.getConstructors();        // 获取参数个数        System.out.println(cons[0].getParameterCount());        // 获取参数类型        System.out.println(cons[1].getParameters()[1]);        // 通过构造方法创建对象， 并使用对象调用方法        Student s1 = (Student) cons[0].newInstance();        Student s2 = (Student) cons[1].newInstance(30, "joenas");        s2.print();    }    private static class Student {        private int id;        private String username;        public String getUsername() {            return username;        }        public void setUsername(String username) {            this.username = username;        }        public Student() {        }        public Student(int id, String username) {            this.id = id;            this.username = username;        }        public void print() {            System.out.println(this.id + "  " + this.username);        }    }

8. 获取实现的接口、父类、声明的属性等

public static void main(String[] args) throws NoSuchFieldException, SecurityException {        Class<?> clazz = Student.class;        // 1. 获取实现的接口        Class<?> inters[] = clazz.getInterfaces();        System.out.println(inters[0]);                // 2. 获取父类        Class<?> parent = clazz.getSuperclass();        System.out.println(parent);                // 3. 获取所有属性        Student stu = new Student();        Field fileds[] = clazz.getFields();        fileds = stu.getClass().getFields();        for (Field s : fileds) {            System.out.println(s.getName());        }                // 4. 获取单个属性        Field field = clazz.getField("username");        System.out.println(field.getName());                // 此行代码将报错, 不能获取private属性        field = clazz.getField("id");    }    private static class Student implements Serializable{        private int id;        public String username;        public Student() {        }        public Student(int id, String username) {            this.id = id;            this.username = username;        }        public void print() {            System.out.println(this.id + "  " + this.username);        }    }

9. 使用反射修改数组大小

public static void main(String[] args) {        int[] intArray = { 1, 2, 3, 4, 5 };        int[] newIntArray = (int[]) changeArraySize(intArray, 8);        print(newIntArray);         String[] atr = { "a", "b", "c", "d", "e" };        String[] str1 = (String[]) changeArraySize(atr, 8);        print(str1);    }     /*     * 修改数组大小， 原理为     *      1. 获取原数组的类型     *      2. 按照原类型新长度创建数组     *      3. 将原数组中数据赋值到新数组中     */    public static Object changeArraySize(Object obj, int len) {        // 获取数组元素类型        Class<?> type = obj.getClass().getComponentType();        Object newArray = Array.newInstance(type, len);        // 复制数组        int count = Array.getLength(obj);        System.arraycopy(obj, 0, newArray, 0, count);        return newArray;    }     // 输出数组内容    public static void print(Object obj) {        Class<?> c = obj.getClass();        if (!c.isArray()) {            return;        }         System.out.println("Array length: " + Array.getLength(obj));         System.out.print("[");        for (int index = 0; index < Array.getLength(obj); index++) {            System.out.print(Array.get(obj, index) + ",");        }        System.out.println("]");    }

当然、反射所能做的事情不限于如上所列， 还可以实现很多功能， 比如获取方法返回值类型，参数类型等； 在动态加载配置时反射也可以发挥大作用。

文章如有错误， 欢迎指正。