4.注解，反射，动态代理-蒲公英云

学习目标

学习反射
学习动态代理
学习注解

这三块内容在一定程度上是密切相关的，因此就集中一起整理

反射

反射的执行过程就是先创建java,lang.Class对象，然后再对Class对象进行实例化，如果需要调用方法或者一些属性就可以从类对象中获取，然后挂到堆中的对象上执行，这个过程就和JVM通过类加载器子系统加载对象，然后再在具体的方法栈中实例化对象，调用方法的实际过程是相近的。是一种更接近底层的使用方式。

类所以的属性方法注解都在创建的class对象上获取（这和jvm的组织和类加载方式有关）
要调用方法或者获取一些属性的话就需要具体的对象挂在来执行

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
class Person{
    public final int a = 1;
    public void printa(){
        System.out.println("hello");
    }
    public static void print(){
        System.out.println("静态方法");
    }
}
public class fanshe {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        // 使用反射创建class对象,也就是对类进行初始化
        Class<?> aClass = Class.forName(Person.class.getName().toString());
        //打印类对象的相关信息
        Method[] methods = aClass.getMethods();
        for(int i=0;i<methods.length;i++){
            System.out.println(methods[i].toString());
        }
        //获得对象的字段信息
        Field[] fields = aClass.getFields();
        for(int i=0;i<fields.length;i++){
            System.out.println(fields[i].toString());
        }
        //获得类对象的一个方法
        Method print = aClass.getDeclaredMethod("printa");
        Method print1 = aClass.getDeclaredMethod("print");
        Field a = aClass.getField("a");
        System.out.println(a);
        //实例化class的一个对象
        Object o = aClass.newInstance();
        //获得对象的字段信息
        Object o1 = a.get(o);
        System.out.println(o1);
        //对象调用方法
        print.invoke(o);
        print1.invoke(o);
    }
}

动态代理

动态代理是一种设计模式，他的思想就是把这个类继承过来在保存原有类的功能的同时扩展一下类中的方法的功能
java中有两种动态代理的实现方式CGlib和java代理参考地址

JDK动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
CGLIB动态代理：利用ASM（开源的Java字节码编辑库，操作字节码）开源包，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

package src.TProxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Test {
    public static void main(String[] args) {
        // 不实现接口的类进行CGlib动态代理，可以直接转为被代理类的类型
        UserManagerImpl1 userManager = (UserManagerImpl1)new CGLibProxy().createProxyObject(new UserManagerImpl1());
        System.out.println("CGLibProxy：");
        userManager.addUser("tom", "root");
        // 实现接口的类型进行CGlib动态代理，可以转为接口类型或者被代理的类型
        UserManager userManager1 = (UserManager)new CGLibProxy().createProxyObject(new UserManagerImpl());
        System.out.println("CGLibProxy：");
        userManager1.addUser("tom", "root");
        System.out.println("JDKProxy：");
        // 实现接口的类，可以被jdk动态代理，但是只能转为接口类型
        JDKProxy jdkProxy = new JDKProxy();
        UserManagerImpl userManagerJDK = (UserManagerImpl)jdkProxy.newProxy(new UserManagerImpl());
        userManagerJDK.addUser("tom", "root");
        // 没实现接口的类，直接无法代理
        UserManager userManagerJDK1 = (UserManager)jdkProxy.newProxy(new UserManagerImpl1());
        userManagerJDK1.addUser("tom", "root");
    }
}
// 定义一个接口
interface UserManager {
    public void addUser(String id, String password);
    public void delUser(String id);
}
// 实现这个接口
class UserManagerImpl implements UserManager {
    @Override
    public void addUser(String id, String password) {
        System.out.println("调用了UserManagerImpl.addUser()方法！");
    }
    @Override
    public void delUser(String id) {
        System.out.println("调用了UserManagerImpl.delUser()方法！");
    }
}
// 不实现这个接口
class UserManagerImpl{
    public void addUser(String id, String password) {
        System.out.println("调用了UserManagerImpl.addUser()方法！");
    }
    public void delUser(String id) {
        System.out.println("调用了UserManagerImpl.delUser()方法！");
    }
}
// 使用JDK动态代理直接对接口进行扩展和重写
class JDKProxy implements InvocationHandler {
    // 需要代理的目标对象
    private Object targetObject;
    // 传入需要被代理对象的，
    public Object newProxy(Object targetObject) {
        // 将目标对象传入进行代理
        this.targetObject = targetObject;
        // 返回代理对象
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
    }
    // invoke方法,和反射里面的方法挂在一样，这里是对invoke扩展了，但是里面method.invoke就是在反射调用对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 进行逻辑处理的函数
        checkPopedom();
        Object ret = null;
        // 调用invoke方法
        ret = method.invoke(targetObject, args);
        return ret;
    }
    private void checkPopedom() {
        // 模拟检查权限
        System.out.println("检查权限：checkPopedom()!");
    }
}
class CGLibProxy implements MethodInterceptor {
    // CGlib需要代理的目标对象
    private Object targetObject;
    public Object createProxyObject(Object obj) {
        this.targetObject = obj;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(obj.getClass());
        enhancer.setCallback(this);
        Object proxyObj = enhancer.create();
        return proxyObj;
    }
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object obj = null;
        // 过滤方法
        if ("addUser".equals(method.getName())) {
            // 检查权限
            checkPopedom();
        }
        obj = method.invoke(targetObject, args);
        return obj;
    }
    private void checkPopedom() {
        System.out.println("检查权限：checkPopedom()!");
    }
}

从上面的代码可以看出，代理都需要传入一个对象，都需要实现一个类似invoke的方法来扩展方法和调用方法，代理之后生成一个新的代理类

JDK的动态代理只能对实现了接口的类生成代理，而且代理的对象类型必须转为接口的类型而不是被代理对象的类型，这种方式创建块，运行慢，因为用的反射
而CGLib可以对任何类生成代理对象，因为他在字节码水平上（用字节码处理框架asm，通过修改字节码生成子类）重新创建了一个类的子类（具体说被代理类和代理类是继承关系），子类作为代理对象，因此可以对任何类进行代理，而且可以类型转换为被代理的类型，这种方法创建慢，运行起来块，比境创建了一个独立的对象。

jdk动态代理函数参数说明：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

ClassLoader：ClassLoader会定义动态代理类的加载器，一般从被代理的类中获得即可
-Class<?>[] interfaces：动态代理类需要实现的接口,也就是被代理类实现的接口
-InvocationHandler：传递一个实现了InvokationHandler接口的类的实例，当一个方法被一个代理实例调用时, 将对该方法调用进行编码，并将其调度到invocation handler的 {@code invoke}方法

public Object invoke(Object proxy, Method method, Object[] args)

Object：实现方法的代理对象,也就是当前创建的代理对象
Method：代理实例激发的方法
Object[]：传递给方法的一系列参数

注解

注解在java中就是配置在类方法字段接口等位置上的一些属性，在访问这些内容前可以先看一下相关属性，在做操作，说白了就是一些配置信息，这些信息直接没有约束关系（不像类之间的继承关系那么严格，更像是注释，随便写），有的只是jvm读取的时候自定义的一些规则需要根据这些信息来完成，因此可以通过设置注解来调整jvm的行为，注解就是配置文件，这些配置文件通过反射被获得读取出来。掌握了注解就是注释一样的配置文件这个思路就可以灵活的使用注解了

注解的根: Annotation 接口

在 Java 中，Annotation 接口是所有元注解接口扩展的通用接口。所有的注解都隐式的扩展自该接口。但是需要注意的，继承和实现该接口并不能实现定义注解接口。并且该接口并没有定义成一个注解接口。
也就是说java规定Annotation为所有注解的基类，可以把所有的注解当成一个一个的接口，接口可以扩展接口，所以定义注解就是在定义一些接口，在注解上加注解就是在extends接口，就是换了种形式，这种形式的接口可以放置的位置更多。
此外注解不存在什么循环依赖，就是一个属性表，你可以把他放在任何地方（合法的地方）甚至它本身。就相当一种注释，提供额外信息的

元注解

@Target @Retention @Documented @Inherited 元注解是系统定义的几个注解，在自定义注解的时候必须加上，以规范注解的定义，就相当于规范信息格式一样。你也可以自己写个规范，不过jvm默认是不承认的哈。

@Target

Target注解规定注解可以放置的位置，他的取值如下：

public enum ElementType {
    TYPE,               /* 类、接口（包括注释类型）或枚举声明  */
    FIELD,              /* 字段声明（包括枚举常量）  */
    METHOD,             /* 方法声明  */
    PARAMETER,          /* 参数声明  */
    CONSTRUCTOR,        /* 构造方法声明  */
    LOCAL_VARIABLE,     /* 局部变量声明  */
    ANNOTATION_TYPE,    /* 注释类型声明  */
    PACKAGE             /* 包声明  */
}

一个注解可以取上面的多个值

@Retention

Retention规定这个注解的存活时间，可以取如下几个值

package java.lang.annotation;
public enum RetentionPolicy {
    SOURCE,            /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该Annotation信息了  */
    CLASS,             /* 编译器将Annotation存储于类对应的.class文件中。默认行为  */
    RUNTIME            /* 编译器将Annotation存储于class文件中，并且可由JVM读入 */
}

一个注解只能有一个Retion值

@Inherited

规定这个注解是否可以被注解的类的子类继承使用，本身没有取值，再次说明注解就是注释，下面调用注解的反射过程可以更清晰的说明这一切

@Documented

用来说明是否生成javadoc

其他内置注解

作用在代码的注解是

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告。

作用在其他注解的注解(或者说元注解)是:

@Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
@Documented - 标记这些注解是否包含在用户文档中。
@Target - 标记这个注解应该是哪种 Java 成员。
@Inherited - 标记这个注解是继承于哪个注解类(默认注解并没有继承于任何子类)

从 Java 7 开始，额外添加了 3 个注解:

@SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
@FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
@Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

自定义注解和使用

自定义注解使用 @interface
使用 @interface 定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。
定义 Annotation 时，@interface 是必须的。
注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他的注解或接口。

/**
 * Annotation在反射函数中的使用示例
 */
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String[] value() default "unknown";
}
/**
 * Person类。它会使用MyAnnotation注解。
 */
class PersonMy {
    /**
     * empty()方法同时被 "@Deprecated" 和 "@MyAnnotation(value={"a","b"})"所标注
     * (01) @Deprecated，意味着empty()方法，不再被建议使用
     * (02) @MyAnnotation, 意味着empty() 方法对应的MyAnnotation的value值是默认值"unknown"
     */
    @MyAnnotation
    @Deprecated
    public void empty(){
        System.out.println("\nempty");
    }
    /**
     * sombody() 被 @MyAnnotation(value={"girl","boy"}) 所标注，
     * @MyAnnotation(value={"girl","boy"}), 意味着MyAnnotation的value值是{"girl","boy"}
     */
    @MyAnnotation(value={
    "girl","boy"})
    public void somebody(String name, int age){
        System.out.println("\nsomebody: "+name+", "+age);
    }
}
public class AnnotationTest {
    public static void main(String[] args) throws Exception {
        // 新建Person
        PersonMy person = new PersonMy();
        // 获取Person的Class实例
        Class<PersonMy> c = PersonMy.class;
        // 获取 somebody() 方法的Method实例
        Method mSomebody = c.getMethod("somebody", new Class[]{
    String.class, int.class});
        // 执行该方法
        mSomebody.invoke(person, new Object[]{
    "lily", 18});
        iteratorAnnotations(mSomebody);
        // 获取 somebody() 方法的Method实例
        Method mEmpty = c.getMethod("empty", new Class[]{
    });
        // 执行该方法
        mEmpty.invoke(person, new Object[]{
    });
        iteratorAnnotations(mEmpty);
    }
    public static void iteratorAnnotations(Method method) {
        // 判断 somebody() 方法是否包含MyAnnotation注解
        if(method.isAnnotationPresent(MyAnnotation.class)){
            // 获取该方法的MyAnnotation注解实例
            MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
            // 获取 myAnnotation的值，并打印出来
            String[] values = myAnnotation.value();
            for (String str:values)
                System.out.printf(str+", ");
            System.out.println();
        }
        // 获取方法上的所有注解，并打印出来
        Annotation[] annotations = method.getAnnotations();
        for(Annotation annotation : annotations){
            System.out.println(annotation);
        }
    }
}