JavaWeb_反射

反射之中包含了一个【反】字，所以想要解释反射就必须先从【正】开始解释。

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。

Person p1 = new Person();
p1.setName("zhangsan");

上面这个样子进行类对象的初始化，我们可以理解为【正】。

而反射则是一开始并不知道我们要初始化的类对象是什么，自然也无法使用new关键字来创建对象了。

这时候，我们使用JDK提供的反射API进行反射调用：

Class clz = Class.forName("com.study.reflect.Person");
Method method = clz.getMethod("setName",String.class);
Constructor constructor = clz.getConstructor();
Person p1 = (Person) constructor.newInstance();
method.invoke(p1,"zhangsan");
System.out.println(p1.getName());

上面两端代码的执行结果，其实是完全一样的。但是其思路完全不一样，第一段代码在未运行时就已经确定了要运行的类（Person），而第二段代码则是在运行时通过字符串值才得知要运行的类（com.study.reflect.Person）。

所以说什么是反射？

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。

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

编程时什么情况下才需要加载类，并解剖出类的各个组成部分呢？

反射是用来做框架的。

从配置文件中解读类的方法等。

Java中有一个Class类用于代表某一个类的字节码。

Class类既然代表某个类的字节码，它当然就要提供加载某个类字节码的方法：forName().

forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装。

另外两种得到class对象的方式

类名.class

对象.getClass()

因此类的加载方法公有三种：

1、Class.forName("com.xx.xx")

2、类名.class

3、对象.getClass()

下面看三种类的加载方法

package cn.itcast.reflect;

public class Demo1 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        //加载类的字节码1，常用
        Class clazz1 = Class.forName("cn.itcast.reflect.Person");
        
        //加载类的字节码2
        Class clazz2 = Person.class;
        
        //加载类的字节码3
        Class clazz3 = new Person().getClass();

    }

}

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对象表示。

思考：假设你是一个框架的设计者，出这些成员后你会干什么？

先看反射类的构造方法。

//Demo1.java
package cn.itcast.reflect;
import java.lang.reflect.Constructor;
import org.junit.Test;
public class Demo1 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        //加载类的字节码1，常用
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Constructor c = clazz.getConstructor(null);
        
        Object obj = c.newInstance(null);
        
        System.out.println(obj);
        

    }
    
    //反射无参的构造函数
    @Test
    public void test1() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Constructor c = clazz.getConstructor(null);
        
        Object obj = c.newInstance(null);
        
        System.out.println(obj);
    }
    
    
    //反射有参的构造函数
    @Test
    public void test2() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Constructor c = clazz.getConstructor(String.class);
        
        Person p = (Person) c.newInstance("fix");
        System.out.println(p);
    }
    
    //反射私有的，有参的构造函数
    @Test
    public void test3() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Constructor c = clazz.getDeclaredConstructor(int.class);
        c.setAccessible(true);//暴力反射
        Person p = (Person) c.newInstance(1);
        System.out.println(p);
    }
}

下面看反射类的方法

package cn.itcast.reflect;

import java.lang.reflect.Method;

import org.junit.Test;

public class Demo2 {
    //反射方法
    
    //反射不带参数的方法
    @Test
    public void test1() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getMethod("eat", null);
        
        method.invoke(clazz.newInstance(), null);
    }
    
    //反射带参数的方法
    @Test
    public void test2() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getMethod("run", String.class);
        
        method.invoke(clazz.newInstance(), "上海");
    }
    
    //反射带多个参数的方法
    @Test
    public void test3() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getMethod("run", String.class,int[].class,String[].class);
        
        method.invoke(clazz.newInstance(), "上海",new int[]{1,2,3},new String[]{"a","b","c"});
    }
    
    
    //反射带返回值的方法
    @Test
    public void test4() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getMethod("test", String.class);
        
        String result = (String) method.invoke(clazz.newInstance(), "上海");
        System.out.println(result);
    }
    
    
    //反射私有方法
    @Test
    public void test5() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getDeclaredMethod("test2", String.class);
        method.setAccessible(true);//暴力反射
        String result = (String) method.invoke(clazz.newInstance(), "上海");
        System.out.println(result);
    }
    
    
    //反射静态方法
    @Test
    public void test6() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getMethod("test3", String.class);
        String result = (String) method.invoke(null, "上海");
        System.out.println(result);
    }
        
    //反射main方法
    //通过反射调用带数组的方法，要注意处理
    @Test
    public void test7() throws Exception{
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Method method = clazz.getMethod("main", String[].class);
        //method.invoke(null, (Object)new String[]{"1","2"});
        method.invoke(null, new Object[]{new String[]{"1","2"}});
    }
}

利用Field访问属性

Field对象提供了如下方法，用于设置、获取对象属性的值：

public void set(Object obj,Object value)

public Object get(Object obj)

package cn.itcast.reflect;

import java.lang.reflect.Field;

import org.junit.Test;

public class Demo3 {

    /**
     * 反射类的字段
     * @throws Exception 
     */
    //反射公有成员变量
    @Test
    public void test1() throws Exception{
        
        Person p = new Person();
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        
        Field f = clazz.getField("name");
        
        f.set(p, "flx");
        System.out.println(p.getName());
        
    }
    
    
    //反射公有成员变量
    @Test
    public void test2() throws Exception{
        
        Person p = new Person();
        p.setName("xxx");
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Field f = clazz.getField("name");
        String result = (String)f.get(p);
        System.out.println(result);
        
    }
    
    //反射final成员变量
    @Test
    public void test3() throws Exception{
        
        Person p = new Person();
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Field f = clazz.getField("password");
        String result = (String)f.get(p);
        System.out.println(result);
        
    }
    
    //反射私有成员变量
    @Test
    public void test4() throws Exception{
        Person p = new Person();
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        Field f = clazz.getDeclaredField("age");
        f.setAccessible(true);
        f.set(p, 123);
        int result = (Integer)f.getInt(p);
        System.out.println(result);
    }
}

Person类如下：

package cn.itcast.reflect;

public class Person {
    
    public String name;//字段或成员变量
    private int age;
    
    public final String password="123";
    
    
    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;
    }

    public Person(){
        System.out.println("person");
    }
    
    public Person(String name){
        System.out.println(name);
    }
    
    private Person(int name){
        System.out.println(name);
    }
    
    public void eat(){
        System.out.println("eat!!!");
    }
    
    public void run(String address){
        System.out.println("跑到"+address);
    }
    
    public void run(String address,int num[],String ss[]){
        System.out.println("跑到"+address+"," +num);
    }
    
    public String test(String str){
        return str+"aaaaaa";
    }
    
    private String test2(String str){
        return str+"aaaaaa";
    }
    
    public static String test3(String str){
        return str+"aaaa";
    }
    
    
    public static void main(String[] args) {
        System.out.println(args[0]);
    }

}

如上就是反射所有常用的一些方法。