java反射机制学习

java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助

1、什么是反射

只要提供引用对象或者代表类的字符串信息，就可以得到该对象或者该字符串对应的类型信息，利用这些信息，在运行时候动态去调用类里面的各种方法和各种属性；换句话说只要有类的实例对象或者类的完整路径信息，就可以通过反射获得该类所有的属性、方法、构造方法，并使用；所以，反射就会突出下面两个特点：

1）灵活性高：编译的时候都不清楚会生成哪个类的对象，直到运行调用的时候，才知道哪个类；

2）牺牲效率：一般正常的jvm工作是将.java编译成.class运行，反射则是将.class变成.java，读取相关信息后，再编译运行；

2、反射的实现

第一步：首先获得class类对象：有两种方法

　　①通过对象：class类对象.getClass()

　　②通过类名（路径）：Class.forName(String className)

第二步：通过获得的class类对象获取属性、方法

　　获得private属性：class类对象. getDeclaredFields()

　　获得普通属性：class类对象. getFields()

　　获得构造方法组：Constructor[] 数组名 = class类对象.getConstructors()

　　获得方法组：Method[] 数组名 = class类对象.getMethods()

第三步：通过构造方法创建对象

　　1）调用无参构造方法（下面c代表Class类对象）

　　　　先通过Class类对象获得无参构造方法对象（只要对象就可以，不要数组）：

　　　　　　Constructor constructor=c.getConstructor();

　　　　再利用构造方法对象的newInstance（）创建出实例

　　　　　　Object obj = constructor.newInstance();

　　2） 调用有参构造方法创建对象（指定参数类型、个数、顺序）

　　　　先通过class类对象获得有参构造方法对象，还要知道有参参数类型、个数：

　　　　　　Constructor constructor = c.getConstructor(包装类1.class, 包装类2.class,...)

   　　　　再利用构造方法对象的newInstance（对应类型赋值）创建出实例

　　　　　　Object obj = constructor.newInstance(赋值);

另外：在获得对象的基础上，可以调用里面任意方法

如下一个简单例子：

新建一个User类，这边我是放在fanshe包下面（反射的一般都要是包装类型，即UserInfo里面属性及方法参数类型）

package fanshe;

public class User {
    private Integer id; // 包装类
    private String name;
    public Integer age;

    public Integer getId() {
        return id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 无参构造
    public User() {
        // TODO Auto-generated constructor stub
    }

    // 有参构造
    public User(Integer id, String name) { // 参数包装类
        this.id = id;
        this.name = name;
    }

    public String toString() {
        System.out.println("重写toString");
        return "id:" + this.id + ":" + "用户名：" + this.name;
    }

    public void show() {
        System.out.println(this.toString());
    }

    public Double getSalary() {
        System.out.println("无参有返回值");
        return (double) (100 * id);
    }

    public Double getSalay(int year, double baseSalary) {
        System.out.println("有参有返回值");
        return year * baseSalary;
    }
}

1）获取属性、方法、构造方法 java代码

package fanshe;

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

import org.junit.Test;

public class FansheTest {
    @Test
    public void getInfo() {
        // 已知类，先获得实例对象
        User user = new User();
        // 获得class类对象
        Class c = user.getClass();
        // 利用 class类对象 得到属性数组
        Field[] fieldArr = c.getDeclaredFields();// 这个属性可以得到包括访问权限为
        for(Field field : fieldArr) {
            System.out.println("所有属性：" + field.getName());
        }
        Field[] fields = c.getFields();// 这个属性可以得到公有属性
        for(Field field : fields) {
            System.out.println("public属性：" + field.getName());
        }
        // 利用 class类对象 得到构造方法（每个类至少有一个默认的无参构造方法）
        Constructor[] constructorArr = c.getConstructors();
        System.out.println("有" + constructorArr.length + "个构造方法：");
        // 利用 class类对象 得到普通方法
        Method[] methodArr = c.getMethods();
        for(Method method : methodArr) {
            System.err.println("方法名：" + method.getName());
        }

    }

}

执行结果

所有属性：id
所有属性：name
所有属性：age
public属性：age
有2个构造方法：
方法名：toString
方法名：getName
方法名：getId
方法名：setName
方法名：getAge
方法名：getSalay
方法名：show
方法名：setAge
方法名：getSalary
方法名：setId
方法名：wait
方法名：wait
方法名：wait
方法名：equals
方法名：hashCode
方法名：getClass
方法名：notify
方法名：notifyAll

2）利用反射得到实例对象：已知类的路径信息：fanshe.User，

分析无参：获得class类对象→通过class类对象获得无参构造方法→利用构造方法的newInstance方法创建出实例

java代码

// 反射获得实例对象
    @Test
    public void getObject() throws Exception {
        String className = "fanshe.User";
        // 得到class对象
        Class clazz = Class.forName(className);

        // 先得到无参构造方法对象，不是构造方法数组
        // Constructor constructor = clazz.getConstructor();
        // 利用构造方法对象的newInstance（）创建出user实例
        // Object user = constructor.newInstance();//无参默认就有

        // 也可以用有参构造（前提是User里面要有这个构造方法）
        Constructor constructor = clazz.getConstructor(Integer.class, String.class, Integer.class);
        Object user = constructor.newInstance(1, "zm", 25);
        System.out.println(user);
    }

执行结果

重写toString
id:1:用户名：zm

3）利用反射调用类里面的普通方法

3.1）利用反射调用无参无返回值的普通方法

已知：已知类的路径信息：fanshe.User，要调用的方法名：show

java代码

// 利用反射调用普通方法
    @Test
    public void getMethod() {
        // 通过反射调用无参无返回值的普通方法
        // 已知含有类名字符串、方法名
        String className = "fanshe.User";
        String methodName = "show";
        try {
            // 通过含有类名字符串得到class对象
            Class clazz = Class.forName(className);
            // 通过class对象创建出有参的构造方法Constructor对象
            Constructor constructor = clazz.getConstructor(Integer.class, String.class,Integer.class);
            // 通过有参构造方法对象创建出实例对象
            Object user = constructor.newInstance(2, "hzm",26);
            // 通过class对象创建出方法Method对象
            // 提供方法名，要调用无参所以没有参数
            Method method = clazz.getMethod(methodName);
            // 调用指定的对象要执行指定的无参方法:
            // user是根据字符串实例出对象，method是根据方法名实例出的对象
            Object object = method.invoke(user);
            System.out.println(object);
        } catch(Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

执行结果

重写toString
id:2:用户名：hzm

3.2）利用反射调用有参有返回值的普通方法（这个主要是展示另外一种创建实例对象的方式）

java代码

package fanshe;

import java.lang.reflect.Method;

import org.junit.Test;

public class FansheTest {

    @Test
    public void getMethod1() {
        // 已知含有类名字符串、方法名
        String className = "fanshe.User";
        String methodName = "getSalay";
        try {
            // 通过含有类名字符串得到class对象
            Class clazz = Class.forName(className);
            // 创建实例对象的另外一种方式
            // 利用class对象直接clazz.newInstance()（默认无参构造）
            Object user = clazz.newInstance();
            // 通过class对象创建出方法Method对象
            // 提供方法名，要调用无参所以没有参数
            Method method = clazz.getMethod(methodName, int.class, double.class);
            // 调用指定的对象要执行指定的无参方法:
            // user是根据字符串实例出对象，method是根据方法名实例出的对象
            Object object = method.invoke(user, 3, 1000);
            System.out.println(object);
        } catch(Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

执行结果

有参有返回值
3000.0

4）反射得到get/set方法

java代码

// 反射得到get/set方法
    @Test
    public void getOrSet() {
        // 首先用反射生成UserInfo实例对象，调用的是有参的构造方法

        // 已知含有类名字符串、方法名
        String className = "fanshe.User";
        try {
            // 通过含有类名字符串得到class对象
            Class clazz = Class.forName(className);
            // 得到类名：User
            System.out.println(clazz.getSimpleName());
            // 通过class对象创建出有参构造方法
            Constructor con = clazz.getConstructor(Integer.class, String.class,Integer.class);
            Object user = con.newInstance(3, "hong",27);
            // 通过get方法显示出所有属性的值
            // 得到所有属性对象
            Field[] fields = clazz.getDeclaredFields();
            // 遍历fields
            for(Field field : fields) {
                // PropertyDescriptor(属性名,class对象)
                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                // 利用pd对象得到get对象方法getReadMethod()
                Method getMethod = pd.getReadMethod();
                System.out.println(getMethod);
                // invoke(实例对象)可以获得属性值
                System.out.println("属性名：" + field.getName() + " 属性值:" + getMethod.invoke(user));
            }
        } catch(Exception e) {

        }

    }

执行结果

User
public java.lang.Integer fanshe.User.getId()
属性名：id 属性值:3
public java.lang.String fanshe.User.getName()
属性名：name 属性值:hong
public java.lang.Integer fanshe.User.getAge()
属性名：age 属性值:null

反射的应用 

处理数据新增：实现通用版本的新增处理，默认约定：类名与表名一致，属性与列名一致，最大多是大小写区别，默认自增列为id，仅适用于类与表结构完全一致；

package fanshe;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class TransaSql {
    /***
     * 实现通用版本的新增处理 该方法使用注意事项：默认的约定：类名与表名一致，最多就是大小写区别， 属性名与列名一致，自增列默认名称为id
     * 目前仅适用于类与表结构完全一致的情况
     * 
     * @param obj——就是要保存到数据库的对象
     * @return >0表示新增成功，<=0表示没有新增成功
     * 
     */
    public static int doAdd(Object object) {
        int i = 0;
        // 关键点是sql语句的构造
        // 构造的关键点1表名/2列名/3值
        Class clazz = object.getClass();
        // 得到表名
        String tableName = clazz.getSimpleName();
        String sql = " insert into " + tableName + "(";
        String colStr = "";// 保存列名
        String valStr = "";// 保存值
        // 接下来遍历得到列名，就先要得到属性名
        Field[] fields = clazz.getDeclaredFields();
        Object[] objArr = new Object[fields.length - 1];
        // 增加一个变量用来指示数组下标
        int arrIndex = 0;
        try {
            for(Field field : fields) {
                String colName = field.getName();// 保存字段名
                if("id".equals(colName.toLowerCase()) == false) {
                    colStr += colName + ",";// 构造列名
                    valStr += "?,";// 构造值
                    // 得到相应的值
                    PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                    // 利用pd对象得到get对象
                    Method getMethod = pd.getReadMethod();
                    objArr[arrIndex] = getMethod.invoke(object);
                    arrIndex++;
                }
            }
            // 遍历完毕，构造出sql
            colStr = colStr.substring(0, colStr.length() - 1);
            valStr = valStr.substring(0, valStr.length() - 1);
            sql += colStr + ")";
            sql += " values(" + valStr + ")";
            System.out.println(sql);
            // 省略数据jdbc部分
        } catch(Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return i;
    }
}