java 反射

反射：就是把Java类中的各种成分映射成一个个的Java对象。例如，一个类有：成员变量，成员方法，包等信息，利用反射技术可以对一个类进行解剖，把各个部分映射成一个个对象。

---

1. 先得到类的字节码对象：Class cl = Class.forName("类的全名");

                            或者：Class cl = 类名.class;

                            或者：Class cl = 类的对象.getClass();

2. 解剖类：

   Class对象提供了如下常用方法：

•    public Constructor getConstructor(Class<?>...parameterTypes)
•    public Method getMethod(String name, Class<?>...parameterTypes)
•    public Field getField(String name)
•    public Constructor getDeclaredConstructor(Class<?>...parameterTypes)
•    public Method getDeclaredMethod(String name, Class<?>...parameterTypes)
•    public Field getDeclaredField(String name)

 这些方法分别用于从类中解剖出构造函数、方法和成员变量（属性）。解剖出的成员分别使用Constructor、Method、Field对象表示。

先写一个简单的类

package javatext;

import java.util.Date;

public class Student {
    public String str = "hello";

    private int age = 18;

    public static Date time;
    
    public Student(){}

    public Student(String name){
        System.out.println("姓名：" + name);
    }

    public Student(String name, int age){
        System.out.println(name + " " + age);
    }

    private Student(int age){
        System.out.println("年龄：" + age);
    }

    public void m1(){
        System.out.println("m1");
    }

    public void m2(String name){
        System.out.println("m2 " + name);
    }

    public String m3(String name, int age){
        System.out.println("m3 " + name + " " + age);
        return "m3:OK";
    }

    private void m4(int age){
        System.out.println("m4 " + age);
    }

    public static void m5(){
        System.out.println("m5");
    }

    private static void m6(String[] str){
        System.out.println(str.length);
    }
}

反射

package javatext;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;

public class _1{
    
    public static void main(String[] args)throws Exception{
        Class cl = Class.forName("javatext.Student"); //Student类在内存中的字节码对象
        
        Student s = (Student)cl.newInstance();  //可以直接用类的字节码对象，建立该类新的实例，调用的是默认的构造方法
        System.out.println(s.str);
        
        Constructor c = cl.getConstructor(String.class);  //获取相应的构造方法，只能是public的方法
        c.newInstance("Chris"); //创建新实例
        
        Constructor cc = cl.getDeclaredConstructor(int.class); //获取相应的构造方法(所有，包括私有构造方法)
        cc.setAccessible(true);
        cc.newInstance(22);
        
        Constructor[] ccc = cl.getDeclaredConstructors();  //获取所有的构造方法（包括私有）
        System.out.println(ccc.length);
        
        Method m1 = cl.getMethod("m1", null); //获取名为m1，参数为null的方法
        m1.invoke(s, null);  //调用该方法，s为该类的一个实例，null为该方法的参数
        
        Method m2 = cl.getMethod("m2", String.class);
        m2.invoke(s, "Chris");
        
        Method m3 = cl.getMethod("m3", String.class, int.class);
        String str = (String)m3.invoke(s, "Chris", 22);
        System.out.println(str);
        
        Method m4 = cl.getDeclaredMethod("m4", int.class);
        m4.setAccessible(true);
        m4.invoke(s, 22);
        
        Method m5 = cl.getMethod("m5", null);
        m5.invoke(null, null);  //对于静态方法，对象可以为s，也可以为null
        
        Method m6 = cl.getDeclaredMethod("m6", String[].class);
        m6.setAccessible(true);
        m6.invoke(null, (Object)new String[]{"a", "b", "c"}); //参数中带有数组的，要将其转换成一个对象
        //注：由于要向下兼容，jdk1.5及以上版本要兼容jdk1.4。在1.4中，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给
        //invoke方法时，会出现参数数量错误的问题。
        //解决办法：invoke(null, new Object[]{new String[]{"xxx", "xx"}});
        //  或者：  invoke(null, (Object)new String[]{"XX", "XXX"});
        //这样编译器会做特殊处理，编译时不把参数当作数组看待，也就不会将数组打散成若干参数了。
        
        Field f1 = cl.getField("str");
        String string = (String)f1.get(s);
        System.out.println(string);
        
        f1.set(s, "hehe"); //更改类中的str字段
        System.out.println(s.str);
        
        Field f2 = cl.getDeclaredField("age");
        f2.setAccessible(true);
        int age = (Integer)f2.get(s);
        System.out.println(age);
        
        f2.set(s, 80);
        age = (Integer)f2.get(s);
        System.out.println(age);
        
        Field f3 = cl.getField("time");
        f3.set(null, new Date());
        System.out.println(Student.time);
    }    
} 

 结果：

hello
姓名：Chris
年龄：22
4
m1
m2 Chris
m3 Chris 22
m3:OK
m4 22
m5
3
hello
hehe
18
80
Sat Sep 17 20:38:34 GMT+08:00 2016

---

内省：开发框架时，经常需要使用java对象的属性来封装程序的数据，每次都使用反射技术完成此类操作过于麻烦，所以Sun公司开发了一套API，专门用于操作java对象的属性。

通过内省技术访问（java.beans包提供了内省的API）JavaBean的两种方式。

1. 通过Introspector类获得Bean对象的BeanInfo，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后通过反射机制来调用这些方法。

2. 通过PropertyDescriptor类操作Bean的属性。

写一个简单类：

package javatext;

public class Person {
    private String name = "Chris";
    private int age;
    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;
    }
}

内省：

package javatext;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class _1{
    public static void main(String[] args)throws Exception{
        Person p = new Person();
        
        //获取所有属性
        BeanInfo bi = Introspector.getBeanInfo(Person.class);//获取Person类中的属性，被封装到了BeanInfo中，若想获得（不包括Object类中的）属性，则参数为(Person.class, Object.class)
        PropertyDescriptor[] pds = bi.getPropertyDescriptors();//获取类中的所有的属性描述器
        System.out.println(pds.length); //显示3个属性，以为Object类中有getClass()方法，也算作1个属性
        for(PropertyDescriptor pd : pds){
            System.out.println(pd.getName()); //打印属性名称，即去掉get、set的名称
        }
        
        //操作Bean的指定属性
        PropertyDescriptor pd = new PropertyDescriptor("name", Person.class);
        Method m = pd.getReadMethod(); //获取getName()方法，即读方法
        String value = (String)m.invoke(p, null);
        System.out.println(value);
        
        Method m1 = pd.getWriteMethod(); //获取setName()方法，即写方法
        m1.invoke(p, "Lily");
        System.out.println(p.getName());
    }    
} 

 结果：

3
age
class
name
Chris
Lily

内省--beanutils工具包：

Beanutils是Apache开发的一套快速操作JavaBean getter/setter方法的API，目前比较流行。

准备包：commons-beanutils.jar, commons-logging.jar

语法：

 （1）设置：BeanUtils.setProperty(Object bean, String propertyName, String propertyValue);

 （2）获取：BeanUtils.getProperty(Object bean, String PropertyName);

注：BeanUtils可以进行类型的自动转换，但仅限基本类型。

继续用上面的Person类，额外添加了birthday属性。

package javatext;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;

public class _1{
    public static void main(String[] args)throws Exception{
        Person p = new Person();
        String str = BeanUtils.getProperty(p, "name"); //调用getName()方法
        System.out.println(str);
        
        BeanUtils.setProperty(p, "name", "Lily"); //设置值
        System.out.println(p.getName());
        
        //非基本类型的属性设置
        //给BeanUtils注册类型转换器
        ConvertUtils.register(new Converter(){
            //type:目标类型
            //value：当前传入的值
            public Object convert(Class type, Object value){
//                if(type.equals(Date.class)){
//                    //字符串转换为Date
//                }else{
//                    //Date转换为字符串
//                }
                DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
                if(value instanceof String){
                    //字符串转换为Date
                    String v = (String)value;
                    try{
                        Date d = df.parse(v);
                        return d;
                    }catch(Exception e){
                        throw new RuntimeException(e);
                    }
                }else{
                    //Date转换为字符串
                    Date d = (Date)value;
                    return df.format(d);
                }
            }
        }, Date.class);
        BeanUtils.setProperty(p, "birthday", "2016-09-17");
        System.out.println(p.getBirthday());

结果：

Chris
Lily
Sat Sep 17 00:00:00 GMT+08:00 2016

或者

ConvertUtils.register(new DateLocaleConverter(), Date.class);
BeanUtils.setProperty(p, "birthday", "1999-09-09");
System.out.println(p.getBirthday());

注：其中的DateLocalConverter()就是对上面代码的封装。

BeanUtils将Map属性自动放到Bean中

注：可以操作的原则是，Map的key必须要与Bean的属性一致。

Map m = new HashMap();
m.put("name", "Chris");
Person p = new Person();
BeanUtils.populate(p, m);
System.out.println(person);