java反射机制深入理解剖析

在java开发中有一个非常重要的概念就是java反射机制，也是java的重要特征之一。反射的概念是由smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，通过反射可以调用私有方法和私有属性，大部分框架也都是运用反射原理的。java通常是先有类再有对象，有对象就可以调用方法或者属性，java中的反射其实是通过class对象来调用类里面的方法。掌握了反射的知识，才能更好的学习java高级课程。

java

反射简介：

主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

一个类有多个组成部分，例如：成员变量、方法、构造方法等，反射就是加载类,并解剖出类的各个组成部分。

反射机制主要提供以下功能：

①在运行时判断任意一个对象所属的类；

②在运行时构造任意一个类的对象；

③在运行时判断任意一个类所具有的成员变量和方法；

④在运行时调用任意一个对象的方法；

⑤生成动态代理。

java中的反射及作用：

假如有两个程序员，一个程序员在写程序的时需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码是不能通过编译的。此时，利用java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。

java的反射机制它知道类的基本结构，这种对java类结构探知的能力，我们称为java类的“自审”。如eclipse中，一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了java反射的原理，是对我们创建对象的探知、自审。

java反射机制中有哪些类：

java.lang.class;                
java.lang.reflect.constructor; java.lang.reflect.field;        
java.lang.reflect.method;
java.lang.reflect.modifier;

通过一个对象获得完整的包名和类名：

package net.xsoftlab.baike;
public class testreflect {
    public static void main(string[] args) throws exception {
        testreflect testreflect = new testreflect();
        system.out.println(testreflect.getclass().getname());
        // 结果 net.xsoftlab.baike.testreflect
    }
}

实例化class类对象

package net.xsoftlab.baike;
public class testreflect {
    public static void main(string[] args) throws exception {
        class<?> class1 = null;
        class<?> class2 = null;
        class<?> class3 = null;
        // 一般采用这种形式
        class1 = class.forname("net.xsoftlab.baike.testreflect");
        class2 = new testreflect().getclass();
        class3 = testreflect.class;
        system.out.println("类名称   " + class1.getname());
        system.out.println("类名称   " + class2.getname());
        system.out.println("类名称   " + class3.getname());
    }
}

获取一个对象的父类与实现的接口

package net.xsoftlab.baike;
import java.io.serializable;
public class testreflect implements serializable {
    private static final long serialversionuid = -2862585049955236662l;
    public static void main(string[] args) throws exception {
        class<?> clazz = class.forname("net.xsoftlab.baike.testreflect");
        // 取得父类
        class<?> parentclass = clazz.getsuperclass();
        system.out.println("clazz的父类为：" + parentclass.getname());
        // clazz的父类为： java.lang.object
        // 获取所有的接口
        class<?> intes[] = clazz.getinterfaces();
        system.out.println("clazz实现的接口有：");
        for (int i = 0; i < intes.length; i++) {
            system.out.println((i + 1) + "：" + intes[i].getname());
        }
        // clazz实现的接口有：
        // 1：java.io.serializable
    }
}

通过反射机制实例化一个类的对象

package net.xsoftlab.baike;
import java.lang.reflect.constructor;
public class testreflect {
    public static void main(string[] args) throws exception {
        class<?> class1 = null;
        class1 = class.forname("net.xsoftlab.baike.user");
        // 第一种方法，实例化默认构造方法，调用set赋值
        user user = (user) class1.newinstance();
        user.setage(20);
        user.setname("rollen");
        system.out.println(user);
        // 结果 user [age=20, name=rollen]
        // 第二种方法 取得全部的构造函数 使用构造函数赋值
        constructor<?> cons[] = class1.getconstructors();
        // 查看每个构造方法需要的参数
        for (int i = 0; i < cons.length; i++) {
            class<?> clazzs[] = cons[i].getparametertypes();
            system.out.print("cons[" + i + "] (");
            for (int j = 0; j < clazzs.length; j++) {
                if (j == clazzs.length - 1)
                    system.out.print(clazzs[j].getname());
                else
                    system.out.print(clazzs[j].getname() + ",");
            }
            system.out.println(")");
        }
        // 结果
        // cons[0] (java.lang.string)
        // cons[1] (int,java.lang.string)
        // cons[2] ()
        user = (user) cons[0].newinstance("rollen");
        system.out.println(user);
        // 结果 user [age=0, name=rollen]
        user = (user) cons[1].newinstance(20, "rollen");
        system.out.println(user);
        // 结果 user [age=20, name=rollen]
    }
}
class user {
    private int age;
    private string name;
    public user() {
        super();
    }
    public user(string name) {
        super();
        this.name = name;
    }
    public user(int age, string name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    @override
    public string tostring() {
        return "user [age=" + age + ", name=" + name + "]";
    }
}

获取某个类的全部属性

package net.xsoftlab.baike;
import java.io.serializable;
import java.lang.reflect.field;
import java.lang.reflect.modifier;
public class testreflect implements serializable {
    private static final long serialversionuid = -2862585049955236662l;
    public static void main(string[] args) throws exception {
        class<?> clazz = class.forname("net.xsoftlab.baike.testreflect");
        system.out.println("===============本类属性===============");
        // 取得本类的全部属性
        field[] field = clazz.getdeclaredfields();
        for (int i = 0; i < field.length; i++) {
            // 权限修饰符
            int mo = field[i].getmodifiers();
            string priv = modifier.tostring(mo);
            // 属性类型
            class<?> type = field[i].gettype();
            system.out.println(priv + " " + type.getname() + " " + field[i].getname() + ";");
        }
         
        system.out.println("==========实现的接口或者父类的属性==========");
        // 取得实现的接口或者父类的属性
        field[] filed1 = clazz.getfields();
        for (int j = 0; j < filed1.length; j++) {
            // 权限修饰符
            int mo = filed1[j].getmodifiers();
            string priv = modifier.tostring(mo);
            // 属性类型
            class<?> type = filed1[j].gettype();
            system.out.println(priv + " " + type.getname() + " " + filed1[j].getname() + ";");
        }
    }
}

获取某个类的全部方法

package net.xsoftlab.baike;
import java.io.serializable;
import java.lang.reflect.method;
import java.lang.reflect.modifier;
public class testreflect implements serializable {
    private static final long serialversionuid = -2862585049955236662l;
    public static void main(string[] args) throws exception {
        class<?> clazz = class.forname("net.xsoftlab.baike.testreflect");
        method method[] = clazz.getmethods();
        for (int i = 0; i < method.length; ++i) {
            class<?> returntype = method[i].getreturntype();
            class<?> para[] = method[i].getparametertypes();
            int temp = method[i].getmodifiers();
            system.out.print(modifier.tostring(temp) + " ");
            system.out.print(returntype.getname() + "  ");
            system.out.print(method[i].getname() + " ");
            system.out.print("(");
            for (int j = 0; j < para.length; ++j) {
                system.out.print(para[j].getname() + " " + "arg" + j);
                if (j < para.length - 1) {
                    system.out.print(",");
                }
            }
            class<?> exce[] = method[i].getexceptiontypes();
            if (exce.length > 0) {
                system.out.print(") throws ");
                for (int k = 0; k < exce.length; ++k) {
                    system.out.print(exce[k].getname() + " ");
                    if (k < exce.length - 1) {
                        system.out.print(",");
                    }
                }
            } else {
                system.out.print(")");
            }
            system.out.println();
        }
    }
}

通过反射机制调用某个类的方法

package net.xsoftlab.baike;
import java.lang.reflect.method;
public class testreflect {
    public static void main(string[] args) throws exception {
        class<?> clazz = class.forname("net.xsoftlab.baike.testreflect");
        // 调用testreflect类中的reflect1方法
        method method = clazz.getmethod("reflect1");
        method.invoke(clazz.newinstance());
        // java 反射机制 - 调用某个类的方法1.
        // 调用testreflect的reflect2方法
        method = clazz.getmethod("reflect2", int.class, string.class);
        method.invoke(clazz.newinstance(), 20, "张三");
        // java 反射机制 - 调用某个类的方法2.
        // age -> 20. name -> 张三
    }
    public void reflect1() {
        system.out.println("java 反射机制 - 调用某个类的方法1.");
    }
    public void reflect2(int age, string name) {
        system.out.println("java 反射机制 - 调用某个类的方法2.");
        system.out.println("age -> " + age + ". name -> " + name);
    }
}

通过反射机制操作某个类的属性

package net.xsoftlab.baike;
import java.lang.reflect.field;
public class testreflect {
    private string proprety = null;
    public static void main(string[] args) throws exception {
        class<?> clazz = class.forname("net.xsoftlab.baike.testreflect");
        object obj = clazz.newinstance();
        // 可以直接对 private 的属性赋值
        field field = clazz.getdeclaredfield("proprety");
        field.setaccessible(true);
        field.set(obj, "java反射机制");
        system.out.println(field.get(obj));
    }
}

反射机制的动态代理

// 获取类加载器的方法
testreflect testreflect = new testreflect();
        system.out.println("类加载器  " + testreflect.getclass().getclassloader().getclass().getname());
package net.xsoftlab.baike;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
//定义项目接口
interface subject {
    public string say(string name, int age);
}
// 定义真实项目
class realsubject implements subject {
    public string say(string name, int age) {
        return name + "  " + age;
    }
}
class myinvocationhandler implements invocationhandler {
    private object obj = null;
    public object bind(object obj) {
        this.obj = obj;
        return proxy.newproxyinstance(obj.getclass().getclassloader(), obj.getclass().getinterfaces(), this);
    }
    public object invoke(object proxy, method method, object[] args) throws throwable {
        object temp = method.invoke(this.obj, args);
        return temp;
    }
}
/**
 * 在java中有三种类类加载器。
 * 
 * 1）bootstrap classloader 此加载器采用c++编写，一般开发中很少见。
 * 
 * 2）extension classloader 用来进行扩展类的加载，一般对应的是jrelibext目录中的类
 * 
 * 3）appclassloader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
 * 
 * 如果想要完成动态代理，首先需要定义一个invocationhandler接口的子类，已完成代理的具体操作。
 * 
 * @author xsoftlab.net
 * 
 */
public class testreflect {
    public static void main(string[] args) throws exception {
        myinvocationhandler demo = new myinvocationhandler();
        subject sub = (subject) demo.bind(new realsubject());
        string info = sub.say("rollen", 20);
        system.out.println(info);
    }
}

射机制的应用实例

在泛型为integer的arraylist中存放一个string类型的对象

package net.xsoftlab.baike;
import java.lang.reflect.method;
import java.util.arraylist;
public class testreflect {
    public static void main(string[] args) throws exception {
        arraylist<integer> list = new arraylist<integer>();
        method method = list.getclass().getmethod("add", object.class);
        method.invoke(list, "java反射机制实例。");
        system.out.println(list.get(0));
    }
}

通过反射取得并修改数组的信息

package net.xsoftlab.baike;
import java.lang.reflect.array;
public class testreflect {
    public static void main(string[] args) throws exception {
        int[] temp = { 1, 2, 3, 4, 5 };
        class<?> demo = temp.getclass().getcomponenttype();
        system.out.println("数组类型： " + demo.getname());
        system.out.println("数组长度  " + array.getlength(temp));
        system.out.println("数组的第一个元素: " + array.get(temp, 0));
        array.set(temp, 0, 100);
        system.out.println("修改之后数组第一个元素为： " + array.get(temp, 0));
    }
}

通过反射机制修改数组的大小

package net.xsoftlab.baike;
import java.lang.reflect.array;
public class testreflect {
    public static void main(string[] args) throws exception {
        int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int[] newtemp = (int[]) arrayinc(temp, 15);
        print(newtemp);
        string[] atr = { "a", "b", "c" };
        string[] str1 = (string[]) arrayinc(atr, 8);
        print(str1);
    }
    // 修改数组大小
    public static object arrayinc(object obj, int len) {
        class<?> arr = obj.getclass().getcomponenttype();
        object newarr = array.newinstance(arr, len);
        int co = array.getlength(obj);
        system.arraycopy(obj, 0, newarr, 0, co);
        return newarr;
    }
    // 打印
    public static void print(object obj) {
        class<?> c = obj.getclass();
        if (!c.isarray()) {
            return;
        }
        system.out.println("数组长度为： " + array.getlength(obj));
        for (int i = 0; i < array.getlength(obj); i++) {
            system.out.print(array.get(obj, i) + " ");
        }
        system.out.println();
    }
}

将反射机制应用于工厂模式

package net.xsoftlab.baike;
interface fruit {
    public abstract void eat();
}
class apple implements fruit {
    public void eat() {
        system.out.println("apple");
    }
}
class orange implements fruit {
    public void eat() {
        system.out.println("orange");
    }
}
class factory {
    public static fruit getinstance(string classname) {
        fruit f = null;
        try {
            f = (fruit) class.forname(classname).newinstance();
        } catch (exception e) {
            e.printstacktrace();
        }
        return f;
    }
}
/**
 * 对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。 当我们添加很多的子类的时候，会很麻烦。
 * java 工厂模式可以参考
 * http://baike.xsoftlab.net/view/java-factory-pattern
 * 
 * 现在我们利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。
 * 
 * 但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。
 * 
 * java 读取 properties 配置文件 的方法可以参考
 * http://baike.xsoftlab.net/view/java-read-the-properties-configuration-file
 * 
 * @author xsoftlab.net
 */
public class testreflect {
    public static void main(string[] args) throws exception {
        fruit f = factory.getinstance("net.xsoftlab.baike.apple");
        if (f != null) {
            f.eat();
        }
    }
}

使用java反射的优势与弊端

反射虽然很灵活，能够使得写的代码，变的大幅精简，所以在用的时候，一定要注意具体的应用场景，反射的优缺点如下：

优点：
（1）能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性。
（2）与java动态编译相结合，可以实现无比强大的功能

缺点：
（1）使用反射的性能较低
（2）使用反射相对来说不安全
（3）破坏了类的封装性，可以通过反射获取这个类的私有方法和属性

任何事物，都有两面性，反射的优点，也同是就是它的缺点，所以，没有好与坏，只有最合适的场景。