java之反射机制

就是通过class文件对象，去使用文件中的成员变量，构造方法，成员方法
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

类的加载
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载 :就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。

连接 :验证 是否有正确的内部结构，并和其他类协调一致
准备 负责为类的静态成员分配内存，并设置默认初始化值
解析 将类的二进制数据中的符号引用替换为直接引用

初始化 :就是我们以前讲过的初始化步骤，栈加载控件，类加载空间，初始化。

类初始化时机
创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

类加载器：负责将.class文件加载到内在中，并为之生成对应的Class对象

类加载器组成

1. Bootstrap ClassLoader 根类加载器
   也被称为引导类加载器，负责Java核心类的加载
   比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

2. Extension ClassLoader 扩展类加载器
   负责JRE的扩展目录中jar包的加载。
   在JDK中JRE的lib目录下ext目录

3. Sysetm ClassLoader 系统类加载器
   负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

三种获取Class对象的方式
1.

Person p = new Person();
  Class c = p.getClass();

2.任意数据类型都具备一个class静态属性,看上去要比第一种方式简单.

Class c2 = Person.class;

3:将类名作为字符串传递给Class类中的静态方法forName即可,参数是类全路径

Class c3 = Class.forName("com.example.Person");

第二种最方便，但 推荐使用第三种

第三种和前两种的区别
前两种你必须明确Person类型.
后面是你我这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了，类名是可以变化的。前两种类变化难修改。

1、通过反射获取构造方法
通过反射获取自定义Person类
获取多个构造方法

public Constructor[] getConstructors():所有公共构造方法
public Constructor[] getDeclaredConstructors():所有声明构造方法

获取单个构造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes);
   // 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
public T newInstance(Object... initargs);
   // 获取构造方法的对象，获取到实例对象。
constructor.setAccessible(true);
  //  值为true则指示反射的对象在使用时应该取消Java语言访问检查。

无参：

Class c = Class.forName("com.example.Person");
Constructor con = c.getConstructor();// 返回的是构造方法对象
Object obj = con.newInstance();//相当于获取了Person实例,可以Person p = (Person)obj;

有参：

Class c = Class.forName("com.example.Person");
// 获取带参构造方法对象,参数可以有多个
Constructor con = c.getConstructor(String.class, int.class, String.class);
// 通过带参构造方法对象创建对象,参数可以有多个
Object obj = con.newInstance("张飞", 27, "北京");
//相当于得到Person p = new Person("林青霞",27,"北京");    

私有(通过constructor.setAccessible()才可以获取)

// 获取字节码文件对象
Class c = Class.forName("com.example.Person");
// 获取私有构造方法对象 private Person(String name){}
Constructor con = c.getDeclaredConstructor(String.class);
// 暴力访问,值为true则指示反射的对象在使用时应该取消Java语言访问检查。
con.setAccessible(true);
Object obj = con.newInstance("张飞");

2、通过反射获取成员变量
Class

Field[] getFields():获取所有成员变量
Field getField(String name):获取单个成员变量,参数是成员变量名 
Field getDeclaredField(String name):获取单个成员变量(可以获取私有的)

Field:

setAccessible(true)
    私有方法需要取消访问检查
Object get(Object obj)
    获取此(obj)对象上Field标识的字段的(obj)的值,通常不用该方法
void set(Object obj, Object value)
    给obj(person,newInstance()得到)对象的field(getField()得到)字段设置一个value值。

// 获取字节码文件对象
Class c = Class.forName("com.example.Person");
// 通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
// 获取单个的成员变量
// 获取name并对其赋值
Field nameField = c.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(obj, "张飞");

3、通过反射获取成员方法
Class:
public Method getMethod(String name,Class<>… parameterTypes)
第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
Method:
public Object invoke(Object obj,Object… args)
返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数的class类型

// 获取字节码文件对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
//Person p = new Person();
 p.show();
Method m1 = c.getMethod("show");
m1.invoke(obj); 
// 调用obj对象的m1方
// private String getString(String s, int i)
Method m2 = c.getMethod("getString", String.class, int.class);
m2.setAccessible(true);
Object objString = m2.invoke(obj, "hello", 100);
System.out.println(objString);

自定义方法，将obj对象中名为propertyName的属性的值设置为value。例如：私有属性赋值

public void setProperty(Object obj, String propertyName, Object value)
            throws NoSuchFieldException, SecurityException,
            IllegalArgumentException, IllegalAccessException {
        // 根据对象获取字节码文件对象
        Class c = obj.getClass();
        // 获取该对象的propertyName成员变量
        Field field = c.getDeclaredField(propertyName);
        // 取消访问检查
        field.setAccessible(true);
        // 给对象的成员变量赋值为指定的值
        field.set(obj, value);
    }

4、动态代理
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。 举例：春季回家买票让人代买
动态代理：在程序运行过程中产生的这个对象 而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib

Proxy类中的方法创建动态代理类对象：
public static Object newProxyInstance(ClassLoader loader,Class<>[] interfaces,InvocationHandler h)
最终会调用InvocationHandler的方法
InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

public class Test {
    public static void main(String[] args) {
        UserDao ud = new UserDaoImpl();
        ud.add();
        ud.delete();
        ud.update();
        ud.find();
        System.out.println("-----------");
        // 我们要创建一个动态代理对象
        // Proxy类中有一个方法可以创建动态代理对象
        // public static Object newProxyInstance(ClassLoader loader,Class<?>[]
        // interfaces,InvocationHandler h)
        // 我准备对ud对象做一个代理对象
        MyInvocationHandler handler = new MyInvocationHandler(ud);
        UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass()
                .getClassLoader(), ud.getClass().getInterfaces(), handler);
        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.find();
        System.out.println("-----------");
        StudentDao sd = new StudentDaoImpl();
        MyInvocationHandler handler2 = new MyInvocationHandler(sd);
        StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass()
                .getClassLoader(), sd.getClass().getInterfaces(), handler2);
        proxy2.login();
        proxy2.regist();
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private Object target; // 目标对象
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("权限校验");
        Object result = method.invoke(target, args);
        System.out.println("日志记录");
        return result; // 返回的是代理对象
    }
}