反射机制概述

反射是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

java语言是静态语言，在很多时候其实在编译器就已经静态的确定好了所需要的构造器和方法，但是有了反射机制，Java就可以通过准动态的去获得：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

反射机制使得java更为灵活，通过概念理解可能有点晕，下列我举个例子。

反射的作用：

反射可以反编译java源码。
将java类中映射成一个个的对象，
通过反射机制访问java对象的属性，方法，构造方法等；

反射动态性具体通俗理解：

在后台已经写好了代码，注入服务器运行起来了。在浏览器中要访问后台，用户可能要登录，可能要注册信息等，不确定用户需要使用什么。
有了反射，比如在前台有登录和注册功能，表明需要登录或注册，要是用户点击登录，则登录的信息就传到后台中，java就获取了需要登录的请求，此时的服务器是运行中的，通过用户点击的登录让java接受到了请求，接下来java就根据造需要登录的某个类的对象，方法等，让用户去执行登录的命令。在运行期间不知道该造什么对象，根据需要的请求造相应的对象，这就是动态性请求。

反射相关主要的API

java.lang.Class：代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器

反射具体使用：

创建Class类的实例有四种方法：

//提供的简单的Person类
public class Person{

    private String name;
    private int id;
    private static int UID;
    
 	private String show(String nation){
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

}


 		//方式一：调用运行时类的属性：.class
        Class clazz1 = Person.class;
        
        //方式二：通过运行时类的对象,调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();//通过对象获得class

        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("com.demo.java.Person");
        
        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true

        //方式四：使用类的加载器：ClassLoader  (了解)
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.demo.java.Person");

通过反射创建对应的运行时类的对象

//一般使用newInstance（）创建空参的
 Class c = Class.forName("com.demo.java.Person");
 Person p = (Person)c.newInstance();

//调用指定参数结构的构造器，生成Constructor的实例
Constructor con = clazz.getConstructor(String.class,Integer.class);
//通过Constructor的实例创建对应类的对象，并初始化类属性
 Person p2 = (Person) con.newInstance("Peter",20);

通过反射操作运行时类中的指定的属性

 Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");

        //2.保证当前属性是可访问的
        name.setAccessible(true);
        //3.获取、设置指定对象的此属性值
        name.set(p,"Tom");

        System.out.println(name.get(p));
        System.out.println("**************调用静态属性**************");

        Field uid = clazz.getDeclaredField("UID");

        uid.setAccessible(true);

        uid.set(null,1234);//静态属性赋值
        System.out.println(uid.get(p));

通过反射操作运行时类中的指定的方法

 @Test
    public void testMethod() throws Exception {

        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        /*
        1.获取指定的某个方法
        getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2.保证当前方法是可访问的
        show.setAccessible(true);

        /*
        3. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
        invoke()的返回值即为对应类中调用的方法的返回值。
         */
        Object returnValue = show.invoke(p,"CHN"); //String nation = p.show("CHN");
        System.out.println(returnValue);

        System.out.println("*************如何调用静态方法*****************");

        // private static void showDesc()

        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
//        Object returnVal = showDesc.invoke(null);
        Object returnVal = showDesc.invoke(Person.class);
        System.out.println(returnVal);//null

    }

动态代理模式：

interface Human {

    String getBelief();

    void eat(String food);

}

//被代理类
class SuperMan implements Human {

    //要吃东西
    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    //要吃什么东西
    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

class HumanUtil {

    public void method1() {
        System.out.println("====================通用方法一====================");

    }

    public void method2() {
        System.out.println("====================通用方法二====================");
    }

}

/*
要想实现动态代理，需要解决的问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。


 */

class ProxyFactory {
    //调用此方法，返回一个代理类的对象。根据加载到内存中的被代理类，动态的创建一个代理类及其对象。：解决问题一
    public static Object getProxyInstance(Object obj) {//obj:被代理类的对象


        //实例化此类，提供需要使用的被代理类让代理类的对象赋值
        MyInvocationHandler handler = new MyInvocationHandler();

        //代理类对象赋值进去初始化
        handler.bind(obj);

        //返回一个被代理类实例对象，（获得当前被代理类的类加载器，得到被代理类实现的全部接口，得到接口实现类的实例）
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }

}

class MyInvocationHandler implements InvocationHandler {


    private Object obj;//需要使用被代理类的对象进行赋值

    public void bind(Object obj) {
        this.obj = obj;
    }

    //解决问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()，
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        HumanUtil util = new HumanUtil();
        util.method1();

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj, args);//反射机制

        util.method2();

        //上述方法的返回值就作为当前类中的invoke()的返回值。
        return returnValue;

    }
}

public class ProxyTest {

    public static void main(String[] args) {
        //被代理类的对象
        SuperMan superMan = new SuperMan();

        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);//代理superMan

        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法

        String belief = proxyInstance.getBelief();

        System.out.println(belief);

        proxyInstance.eat("麻辣烫");//麻辣烫就是invoke中的实参 eat方法是invoke里的方法动态调用

        System.out.println("*****************************");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();

        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);

        proxyClothFactory.produceCloth();

    }
}