什么是注解
注解是一种元数据, 可以添加到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反射机制来实现的，即已知的一个对象，然后在运行时动态调用其方法，这样在调用前后作一些相应的处理
agent
仿写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
