Java学习之反射

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

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

一. 反射的概念

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

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

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

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

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

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

二. 反射机制的作用

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

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

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

的Action类的加载。

三、反射类

java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Field      
java.lang.reflect.Method
java.lang.reflect.Modifier

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

四、实例

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

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

// 方式1
Class userClass1 = Class.forName("User");
// 方式2
Class userClass2 = User.class;
// 方式3
Class 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("]");
    }

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

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