java反射

• 简介

　　JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

　　java不是一种动态语言（程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言），但是JAVA有着一个非常突出的动态相关机制:Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造(但不包括methods定义)，并生成其对象实体、或对其fields设值、或唤起其methods。

• 应用

　　java反射引用最多的场合就是在java的第三方框架中，一般类都是在配置文件中配置，然后在项目启动的时候进行加载，这其中就是反射的功劳。下面就从反射的基础一点点的深入到其核心来研究一下。

　　Person代码：

public interface Chinese {
    public static final String name="abc";
    public static  int age=20;
    public void sayChina();
    public void sayHello(String name, int age);
}
public class Person implements Chinese{
    private String sex;
    private String address;
    public Person() {

    }
    public Person(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Person(String sex, String address) {
        this.sex = sex;
        this.address = address;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public void sayChina() {
        System.out.println("say,chinese");
    }
    public void sayHello(String name, int age) {
        System.out.println(name+" "+age);
    }
    @Override
    public String toString() {
        return this.name+" "+this.age+" "+this.sex;
    }
}

　　1、返回一个类的class的几种方式：

Class<?> class1 = Person.class;
Class<?> class2 = new Person().getClass();
Class<?> class3 = Person.class;
try {
    class1 = Class.forName("reflecttest.Person");
} catch (ClassNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
System.out.println(class1.getName());
System.out.println(class2.getName());
System.out.println(class3.getName());

　　所有类的对象其实都是Class的实例。

　　2、通过无参构造实例化对象

Person person = null;
try {
    person = (Person)class1.newInstance();
} catch (InstantiationException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (IllegalAccessException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
person.setSex("男");
System.out.println(person);

　　当我们把Person中的默认的无参构造函数取消的时候，比如自己定义只定义一个有参数的构造函数之后。错误如下：

java.lang.InstantiationException: reflecttest.Person

　　所以在自己定于类的时候一定要定于无参构造函数，尤其在使用其他第三方框架的时候，这也就是好多书上反复强调如果定义有参构造函数一定要实现无参构造函数的原因。

　　3、通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）

        Person person1 = null;
        Person person2 = null;
        Constructor<?> [] constructors = class1.getConstructors();
        try {
            person1 = (Person)constructors[0].newInstance();
            person2 = (Person)constructors[1].newInstance("男");
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(person1);
        System.out.println(person2);    

　　一个类中可能有多个构造函数，我们可以通过反射获取其全部的构造函数，然后通过构造函数来实例化对象，在这里是否想到了spring的构造器注入的方式。

　　4、返回一个类实现的接口：

        Class<?>[] interfaces = class1.getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            System.out.println(interfaces[i].getName());
        }        

　　5、返回父类

Class<?> supClasss = class1.getSuperclass();
System.out.println(supClasss.getName());

　　6、返回类的全部构造方法

Constructor<?> [] constructors = class1.getConstructors();
for (int i = 0; i < constructors.length; i++) {
    System.out.println(constructors[i]);
}

　　7、返回完整的构造方法实现

Constructor<?> [] constructors = class1.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
            Constructor<?> constructor = constructors[i];
            Class<?>[] parameter = constructor.getParameterTypes();
            System.out.print("构造方法 ");
            int j = constructor.getModifiers();//获取修饰符编号
            System.out.print(Modifier.toString(j)+" ");
            System.out.print(constructor.getName()+" ");
            System.out.print("(");
            for (int k = 0; k < parameter.length; k++) {
                if(parameter.length>0){
                    System.out.print(parameter[k].getName() +" arg"+k);
                    if(k<parameter.length-1){
                        System.out.print(",");
                    }
                }
                
            }
            System.out.println(")");
        }

　　这个返回的构造函数更加完善，与我们平时所看到的基本相同，包括修饰符、名称、参数类型、参数名称等。

　　8、返回方法包括异常

Method[] methods = class1.getMethods();
        for (int i = 0; i < methods.length; i++) {
            //System.out.println(methods[i]);
            int m = methods[i].getModifiers();
            Class<?> returnTypes = methods[i].getReturnType();
            Class<?>[] parameterTypes = methods[i].getParameterTypes();
            System.out.print(Modifier.toString(m)+" ");
            System.out.print(returnTypes.getName()+" ");
            System.out.print(methods[i].getName());
            System.out.print("(");
            for (int j = 0; j < parameterTypes.length; j++) {
                System.out.print(parameterTypes[j].getName() +" arg"+j);
                if(j<parameterTypes.length-1){
                    System.out.print(",");
                }
            }
            System.out.print(")");
            Class<?>[] exes = methods[i].getExceptionTypes();
            if(exes.length>0){
                System.out.print("throws ");
                for (int j = 0; j < exes.length; j++) {
                    System.out.print(exes[j]);
                    if(j<exes.length){
                        System.out.print(",");
                    }
                }
            }
            System.out.println("{}");
        }

　　9、获取类属性

Field [] fields = class1.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            //System.out.println(fields[i]);
            int m = fields[i].getModifiers();
            String modifier = Modifier.toString(m);
            Class<?> type = fields[i].getType();
            String fieldName = fields[i].getName();
            System.out.println(modifier +" "+type.getName()+" " +fieldName);
}

　　10、通过反射调用其他的方法

try {
            Person person = (Person)class1.newInstance();
            Method method = class1.getMethod("sayChina");
            method.invoke(person);
            Method method1 = class1.getMethod("sayHello",String.class,int.class);
            method1.invoke(person, "lc",22);
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

　　这个也很好理解，先获取对象和方法名称，然后更具参数类型来获取具体的方法（因为有重载的原因），最后在利用反射传入参数来调用方法。

　　11、通过反射调用getset的方法

　　　try {
            Person person = (Person)class1.newInstance();
            setMethod(person, "Sex", String.class, "女");
            System.out.println(getMethod(person, "Sex"));
            System.out.println(person);
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
　　public static Object getMethod(Object obj,String MethodName) throws Exception{
        Method method = obj.getClass().getMethod("get"+MethodName);
        return method.invoke(obj);
    }
    public static void setMethod(Object obj,String MethodName,Class<?> type,Object value) throws Exception{
        Method method = obj.getClass().getMethod("set"+MethodName, type);
        method.invoke(obj, value);
}

　　这个和上面的做法差不多，只是将普通方法改为了set/get方法，在开源框架中也有许多利用这种方式来实例化对象。如：spring的“set注入”；struts的form表单；MyBatis的参数类型到SQL参数的映射和结果集到对象的映射等等。

　　12、通过反射操作属性

　　　　try {
            Person person = (Person)class1.newInstance();
            //java.lang.NoSuchFieldException: sex
            //Field field = class1.getField("sex");
            //java.lang.IllegalAccessException: Class reflecttest.ReflectTest can not access a member of class reflecttest.Person with modifiers "private"
            //Field field = class1.getDeclaredField("sex");
            Field field = class1.getDeclaredField("sex");
            field.setAccessible(true);
            field.set(person, "未知");
            System.out.println(field.get(person));
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

　　因为sex属性的修饰符是private，一般情况下是不允许外部类直接操作，除非调用其get/set方法，但是通过反射就可以直接操作。

　　class1.getDeclaredField("sex")这个是Class 对象所表示的类或接口的指定已声明字段，可以获取其全部的属性，不管其访问修饰符。class1.getField("sex")这个只能获取其对外公开的属性即public修饰的属性。

　　field.setAccessible(true);这个设置就是反射的对象在使用时应该取消 Java 语言访问检查，也就是说将属性暴力访问。

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

　　　　int [] temp = {1,2,3,4};
        Class<?> class2 = temp.getClass().getComponentType();
        System.out.println("数组类型："+class2.getName());
        System.out.println("数组长度："+Array.getLength(temp));
        System.out.println("数组第一个元素："+Array.get(temp, 0));
        Array.set(temp, 0, 10);
        System.out.println("修改数组第一个元素："+Array.get(temp, 0));
        Object newArr = arryinc(temp, 10);
        print(newArr);
        System.out.println("--------------------");
        String [] str = {"a","b","c","d"};
        Object newStr = arryinc(str, 8);
        print(newStr);
　　/**
     * 修改数组大小
     * */
    public static Object arryinc(Object object,int length){
        Class<?> class1 = object.getClass().getComponentType();
        Object newArr = Array.newInstance(class1, length);
        int ol = Array.getLength(object);
        System.arraycopy(object, 0, newArr, 0, ol);
        return newArr;
    }
    /**
     * 打印数组大小
     */
    public static void print(Object object){
        Class<?> class1 = object.getClass();
        if(!class1.isArray()){
            return;
        }
        System.out.println("数组大小"+Array.getLength(object));
        for (int i = 0; i < Array.getLength(object); i++) {
            System.out.println("数组元素:"+Array.get(object, i));
        }
    }

　　可以看出，反射也可以直接操作数组修改数组大小、修改数组内容等。

　　14、动态代理

　　被代理人授予代理人权限。然后由代理人实行被代理人的权限。

　　代理接口

public interface Target {
    public String say(String name,String age);
}

　　代理接口实现（被代理人）

public class TargetImpl implements Target {
    private String name;
    private String age;
    public TargetImpl() {
        super();
        // TODO Auto-generated constructor stub
    }
    public TargetImpl(String name, String age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String say(String name, String age) {
        return name+" "+age;
    }
}

　　动态代理

public class DProxy implements InvocationHandler{
    
    public Object target;
    
    public Object bing(Object object){
        this.target = object;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    } 
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = method.invoke(this.target, args);
        return object;
    }
}

　　测试代码：

DProxy proxy = new DProxy();
Target target = (Target)proxy.bing(new TargetImpl());
System.out.println(target.say("name", "age"));

　　可以看出，动态代理实现和前面的通过反射来执行对象方法十分类似，先将被代理对象注册，也就是实例化，然后通过反射调用其方法。

　　动态代理在框架中也是很有用，回想下我们使用过的hibernate，在其中有一个懒加载的概念，当通过懒加载获取的对象并不是真正的对象，而是代理对象，这个就是动态代理的一个典型应用。

　　15、工厂模式的应用

　　在以前的工厂模式中都是通过硬编码来实现其功能，在学习了反射以后就可以在配置文件中设置类，然后通过反射来实现工厂模式，这样就减少了对代码的修改了，增强了其可扩展性。

　　接口：

public interface Fruit {
    public void eat();
}

　　具体实现

public class Apple implements Fruit{
    public void eat() {
        System.out.println("eat apple");
    }
}
public class Orange implements Fruit{
    public void eat() {
        System.out.println("eat orange");
    }
}

　　工厂类：

public class FruitFactory {
    /**
     * 这样，当我们在添加一个子类的时候，就需要修改工厂类了。如果我们添加太多的子类的时候，改的就会很多。
     * @param fruitName
     * @return
     */
    public static Fruit getInstance(String fruitName){
        Fruit fruit = null;
        if("apple".equalsIgnoreCase(fruitName)){
            fruit = new Apple();
        }else if("orange".equals(fruitName)){
            fruit = new Orange();
        }
        return fruit;
    }
    /**
     * 利用反射来实例化对象，通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类
     * 所以我们通过属性文件的形式配置所需要的子类。
     * @param className
     * @return
     */
    public static Fruit getInstance1(String className){
        Fruit fruit = null;
        try {
            fruit = (Fruit)Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return fruit;
    }
    /**
    *加载配置文件
    */
    public static Properties loadPro(){
        Properties properties = new Properties();
        File file = new File("fruit.properties");
        if(file.exists()){
            try {
                properties.load(new FileInputStream(file));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            properties.setProperty("apple", "reflecttest.Apple");
            properties.setProperty("orange", "reflecttest.Orange");
            try {
                properties.store(new FileOutputStream(file), "fruit");
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return properties;
    }
}

　　配置文件信息：

apple=reflecttest.Apple
orange=reflecttest.Orange

　　测试代码：

　　　　Fruit fruit = FruitFactory.getInstance("apple");//普通方式实例化
        if(fruit != null){
            fruit.eat();
        }
        Fruit fruit1 = FruitFactory.getInstance1("reflecttest.Orange");//通过反射实例化，但是需要传入类的全路径
        if(fruit1 != null){
            fruit1.eat();
        }
        Fruit fruit2 = FruitFactory.getInstance1(FruitFactory.loadPro().getProperty("apple"));//通过配置文件实例化
        if(fruit2 != null){
            fruit2.eat();
        }

　　可以看出通过反射来实例化，当产品结构修改以后，工厂类是不需要修改的，只是在使用时硬编码传入产品类的全路径，而使用配置文件来实现只需要在配置文件中配置相关信息，比较清晰明了，易于扩展信息。

　　从上面对反射的介绍，其一般是在框架中使用，就是将固定的代码封装然后将动态的内容在配置文件中配置，方便使用，灵活扩展性强。另外，通过反射实例化对象的性能比直接实例化对象要差，所以一般在自己的代码中不用使用反射来实现，除非在对象性能和其他因素折中考虑，使用反射更利于实现才使用。