什么是注解

注解是一种元数据, 可以添加到java代码中. 类、方法、变量、参数、包都可以被注解，注解对注解的代码没有直接影响.

定义注解用的关键字是 @interface

为什么要引入注解

在Annotation之前，XML被广泛的应用于描述元数据。但是XML是松耦合的而且维护比较麻烦。有时使用一些和代码紧耦合的东西更加合适(比如一些服务)，Annotation应运而生,而且它更加方便维护。

目前，许多框架将XML和Annotation两种方式结合使用，平衡两者之间的利弊。例如ButterKnife, EventBus, Retrofit, Dagger等

注解是如何工作的

Annotations仅仅是元数据，和业务逻辑无关。也就是说Annotations只是指定了业务逻辑,它的用户来完成其业务逻辑,JVM便是它的用户,它工作在字节码层面.

当然,前端编译生成字节码阶段,编译器针对注释做了处理,如果有注解错误等,无法正常编译成字节码.只有成功编译生成字节码后.在运行期JVM就可以进行业务逻辑处理.

元注解

java内置的注解有Override, Deprecated, SuppressWarnings等, 作用相信大家都知道.
元注解就是用来定义注解的注解.其作用就是定义注解的作用范围, 使用在什么元素上等等

JDK5.0版本开始提供注解支持: @Documented、@Retention、@Target、@Inherited

@Documented : 是否会保存到 Javadoc 文档中。

@Retention : 定义该注解的生命周期。它有三个枚举类型: RetentionPolicy.SOURCE(只在源码中可用)、 RetentionPolicy.CLASS(在源码和字节码中可用,注解默认使用这种方式)、 RetentionPolicy.RUNTIME(在源码,字节码,运行时均可用,我们自定义的注解通常使用这种方式) Tips : RetentionPolicy.SOURCE – 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。 @Override, @SuppressWarnings都属于这类注解

@Target : 表示该注解用于什么地方。如果不明确指出，该注解可以放在任何地方。以下是一些可用的参数。 Tips : 属性的注解是兼容的，你可以添加多个属性。 ElementType.TYPE:用于描述类、接口或enum声明 ElementType.FIELD:用于描述实例变量 ElementType.METHOD:方法 ElementType.PARAMETER参数 ElementType.CONSTRUCTOR构造器 ElementType.LOCAL_VARIABLE本地变量 ElementType.ANNOTATION_TYPE 另一个注释 ElementType.PACKAGE 用于记录java文件的package信息

@Inherited : 是否可以被继承,默认为false

以下代码全部通过Idea开发

一个简单的例子

创建一个注解类

@Retention(RetentionPolicy.RUNTIME)
public @interface SingleAnno {
    String value() default "shy";
}

引用它

public class MyClass {

    @SingleAnno("single")
    public void run(){ }
}

通过反射获取值

public class TestDemo {

    @Test
    public void test(){
        Class<MyClass> myClass = MyClass.class;

        for (Method method : myClass.getDeclaredMethods()){
            SingleAnno anno = method.getAnnotation(SingleAnno.class);
            if(anno != null){
                System.out.println(method.getName());//打印方法名
                System.out.println(anno.value());//打印注解值
            }
        }
    }
}

控制台可以看到,输出的是single

run
single

注解定义规则

Annotations只支持基本类型、String及枚举类型。注释中所有的属性被定义成方法，并允许提供默认值。

自定义注解以及使用

①定义注解类型(称为A),最好给A加上运行Retention的RUNTIME注解.默认应该是SOURCE类型. ②定义属性,其实是方法表示.提供默认值. ③在其他类方法(称为M)等添加A注解,并给A指定属性值. ④可以在其他地方获取M方法,然后获取M的注解,并获取注解值等.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MultiAnno {
   
   enum Priority{HIGH,MID,LOW}
   enum Status {START,PAUSE,STOP}
   
   String name() default "TheShy";
   Priority priority() default Priority.HIGH;
   Status status() default Status.START;
}

关于代理模式:

静态代理:

核心: 通过聚合来实现,让代理类持有委托类的引用即可.

一个小例子: 我们用一个随机睡眠时间模拟火车运行的时间。如果我要计算运行时间,并且这个类无法改动.

public interface Runnable {
    void running();
}

public class Train implements Runnable {

    public void running() {
        System.out.println("Train is running......");
        int ranTime = new Random().nextInt(1000);
        try {
            Thread.sleep(ranTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里有很多解决方案: 例如在调用方法地方的前后记录,继承(继承Train调用父类方法),聚合(新建Train2,构造方法传入Train对象,然后调用running).

但是如果再增加需求:在running方法前后打印日志,并控制执行顺序,当然是用继承还是可以实现,但是要继续创建新的子类,导致无限扩展......

这时候修改聚合,使其成为静态代理就可以完美解决这个问题: 将构造方法改传入Runnable接口:

//代理-在方法前后打印日志
public class TrainLogProxy implements Runnable {

    private Runnable runnable;

    public TrainLogProxy(Runnable runnable) {
        this.runnable = runnable;
    }

    public void running() {
        System.out.println("Train running start...");
        runnable.running();
        System.out.println("Train running end...");
    }
}

//代理-计算执行时间
public class TrainTimeProxy implements Runnable {

    private Runnable runnable;

    public TrainTimeProxy(Runnable runnable) {
        this.runnable = runnable;
    }

    public void running() {

        long start = System.currentTimeMillis();

        runnable.running();

        long end = System.currentTimeMillis();

        System.out.println("run time = " + (end - start));
    }
}

接下来:

        Train train = new Train();
        //想先计算执行时间,后打印log
//        TrainTimeProxy trainTimeProxy = new TrainTimeProxy(train);
//        TrainLogProxy trainLogProxy = new TrainLogProxy(trainTimeProxy);
//        trainLogProxy.running();

        //想先打印log,后计算执行时间
        TrainLogProxy trainLogProxy = new TrainLogProxy(train);
        TrainTimeProxy trainTimeProxy = new TrainTimeProxy(trainLogProxy);
        trainTimeProxy.running();

继承和聚合的区别:

接下来，观察上面的类TimeProxy，在它的fly方法中我们直接调用了Runable->run()方法。换而言之，TrainTimeProxy其实代理了传入的Runnable对象，这就是典型的静态代理实现。从表面上看，静态代理已经完美解决了我们的问题。可是，试想一下，如果我们需要计算SDK中100个方法的运行时间，同样的代码至少需要重复100次，并且创建至少100个代理类。往小了说，如果Train类有多个方法，我们需要知道其他方法的运行时间，同样的代码也至少需要重复多次。因此，静态代理至少有以下两个局限性问题：

如果同时代理多个类，依然会导致类无限制扩展
如果类中有多个方法，同样的逻辑需要反复实现

那么，我们是否可以使用同一个代理类来代理任意对象呢？我们以获取方法运行时间为例，是否可以使用同一个类（例如：TrainProxy）来计算任意对象的任一方法的执行时间呢？甚至再大胆一点，代理的逻辑也可以自己指定。比如，获取方法的执行时间，打印日志，这类逻辑都可以自己指定。

动态代理

核心原理 :

首先通过Proxy.newProxyInstance方法获取代理类实例，而后可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。

委托类:委托类必须实现某个接口，这里我们实现的是Runnable接口.
代理类:动态生成,调用Proxy类的newProxyInstance方法来获取一个代理类实例.
中介类:中介类必须实现InvocationHandler接口，作为调用处理器”拦截“对代理类方法的调用步骤 :
Proxy->newProxyInstance(infs, handler) 用于生成代理对象
InvocationHandler：这个接口主要用于自定义代理逻辑处理
为了完成对被代理对象的方法拦截，我们需要在InvocationHandler对象中传入被代理对象实例。

        Runnable runnable = (Runnable) Proxy.newProxyInstance(Runnable.class.getClassLoader(), new Class[]{Runnable.class}, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("before");
                Object invoke =  method.invoke(new Train(), args);
                System.out.println("after");
                return invoke;
            }
        });
        runnable.running();

以上我们就成功的通过不修改Train类在执行running()前后打印了日志.

代理模式

代理模式最大的特点就是代理类和实际业务类实现同一个接口（或继承同一父类），代理对象持有一个实际对象的引用，外部调用时操作的是代理对象，而在代理对象的内部实现中又会去调用实际对象的操作

Java动态代理其实内部也是通过Java反射机制来实现的，即已知的一个对象，然后在运行时动态调用其方法，这样在调用前后作一些相应的处理

仿写Retrofit

通过动态代理+注解,完成类似retrofit效果,在InvocationHandler的Invoke方法处获取方法、方法注解、方法参数注解、方法参数等信息,根据情况设置adapter,完成业务逻辑. (当然,这里省略了adapter的动作)

总体思路 :通过注解中使用的参数，动态的生成Request然后由OKHttp去调用

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Get {
    public String value();
}

public interface ServerAPI {

    @Get("https://www.baidu.com/")
    public String getBaiduHome(@Query("type") String type);

    @Post("https://www.baidu.com/update")
    public String getBaiduUser(@Field("name") String name, @Field("age") String age);

}

public class APICreater {

    public static ServerAPI create(Class<ServerAPI> api){

        ServerAPI serverAPI = (ServerAPI) Proxy.newProxyInstance(api.getClassLoader(), new Class[]{api}, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                getMethodMsg(method, args);

                if ("getBaiduHome".equals(method.getName())) {
                    return "I am getBaiduHome return by proxy";
                }
                if ("getBaiduUser".equals(method.getName())) {
                    return "I am getBaiduUser return by proxy";
                }
                ServerAPI obj = getAPI();
                return method.invoke(obj, args);
            }
        });
        return serverAPI;
    }

    private static ServerAPI getAPI() {
        return new ServerAPI() {
            @Override
            public String getBaiduHome(String type) {
                return null;
            }

            @Override
            public String getBaiduUser(String name, String age) {
                return null;
            }
        };
    }


    // 获取了注解信息和参数信息,结合起来就可以实现自己的自定义方法.
    private static void getMethodMsg(Method method, Object[] args) {
        AnnoBean bean = new AnnoBean();
        bean.setMethodName(method.getName());

        Annotation[] annotations = method.getAnnotations();
        for (Annotation annotation : annotations) {
            if (annotation instanceof Get) {
                Get getAnni = (Get) annotation;
                String value = getAnni.value();
                bean.setMethodAnniType("Get");
                bean.setMethodAnniValue(value);
            }
            if (annotation instanceof Post) {
                Post getAnni = (Post) annotation;
                String value = getAnni.value();
                bean.setMethodAnniType("Post");
                bean.setMethodAnniValue(value);
            }
        }

        bean.setMethodArgs(Arrays.asList(args));

        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        for (Annotation[] annotation : parameterAnnotations) {
            for (Annotation annotation1 : annotation) {
                if (annotation1 instanceof Field) {
                    List<String> list = bean.getParamAnniList();
                    if (list == null) {
                        list = new ArrayList<String>();
                    }
                    list.add("paramAnniType: field   " + " value: " + ((Field) annotation1).value());
                    bean.setParamAnniList(list);
                }
                if (annotation1 instanceof Query) {
                    List<String> list = bean.getParamAnniList();
                    if (list == null) {
                        list = new ArrayList<String>();
                    }
                    list.add("paramAnniType: query   " + " value: " + ((Query) annotation1).value());
                    bean.setParamAnniList(list);
                }
            }
        }
        System.out.println(bean.toString());
    }
}

public class TestRetrofitDemo {

    @Test
    public void testRetrofit(){

        ServerAPI serverAPI = APICreater.create(ServerAPI.class);
        String homeeeeee = serverAPI.getBaiduHome("Homeeeeee");
        System.out.println("-----" + homeeeeee);

    }
}

最后测试一下输出结果:

AnniBean{methodName='getBaiduHome', methodArgs=[Homeeeeee], methodAnniType='Get', methodAnniValue='https://www.baidu.com/', paramAnniList=[paramAnniType: query    value: type]}
-----I am getBaiduHome return by proxy

github地址 : https://github.com/saurylip/AnnoDemo