final class RequestFactory {
    static final class Builder {
        Builder(Retrofit retrofit, Method method) {
              this.retrofit = retrofit;
              this.method = method;//这个方法
              this.methodAnnotations = method.getAnnotations();// 这个方法被标记的所有注解
              this.parameterTypes = method.getGenericParameterTypes();//这个方法所有的泛型参数类型
              this.parameterAnnotationsArray = method.getParameterAnnotations();//这个方法的参数的所有注解信息
            }
     }
 }
/**
*	以上面ApiSerice这个接口为例子：
*	this.methodAnnotations = [@retrofit2.http.Get(value=),@retrofit2.http.Streaming()]
*	this.parameterTYpes = [String,Continuation<Response<REsponseBody>>]
*	this.parameterAnnotationsArray = [@retrofit2.http.Url()]
*/

// Retrofit.java
public <T> T create(final Class<T> service) {
  validateServiceInterface(service);
  return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
      new InvocationHandler() {
          return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
        }
      });
}

// HttpSercieMethod.java
@Override final @Nullable ReturnT invoke(Object[] args) {
  Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
  return adapt(call, args);
}

ServiceMethod<?> loadServiceMethod(Method method) {
  ServiceMethod<?> result = serviceMethodCache.get(method);
  if (result != null) return result;

  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = ServiceMethod.parseAnnotations(this, method);
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

abstract class ServiceMethod<T> {
  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
    Type returnType = method.getGenericReturnType();
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
        if (isKotlinSuspendFunction) {
              Type[] parameterTypes = method.getGenericParameterTypes();
              Type responseType = Utils.getParameterLowerBound(0,
                  (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
              if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
                // Unwrap the actual body type from Response<T>.
                responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
                continuationWantsResponse = true;
              } else {
              }

              adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
              annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);// 这一步就是自动往我们的注解数组里面手动调价一个SkipCallbackExecutor的注解，用来实现跳过手动执行call.execu的方法。
            } else {
              adapterType = method.getGenericReturnType();// 获取方法的返回值类型。
            }
    
    // 返回正真的HttpServiceMethod对象
        if (!isKotlinSuspendFunction) {
          return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
        } else if (continuationWantsResponse) {
          //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
          return (HttpServiceMethod<ResponseT, ReturnT>) new SuspendForResponse<>(requestFactory,
              callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
        } else {
          //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
          return (HttpServiceMethod<ResponseT, ReturnT>) new SuspendForBody<>(requestFactory,
              callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
              continuationBodyNullable);
        }
}

// Retrofit.java
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
  return nextResponseBodyConverter(null, type, annotations);
}

//HttpSerciceMethod.java
okhttp3.Call.Factory callFactory = retrofit.callFactory;

// HttpSerciveMethod.java
CallAdapter<ResponseT, ReturnT> callAdapter =
    createCallAdapter(retrofit, method, adapterType, annotations);
// HttpServicemethod.java
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
      Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
      return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
    }
  }

// Retrofit.java
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
  return nextCallAdapter(null, returnType, annotations);
}

// Retrofit.java
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
    Annotation[] annotations) {
  Objects.requireNonNull(returnType, "returnType == null");
  Objects.requireNonNull(annotations, "annotations == null");

  int start = callAdapterFactories.indexOf(skipPast) + 1;
  for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
    CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
    if (adapter != null) {
      return adapter;
    }
  }
}

addConverterFactory(GsonConverterFactory.create(new GsonBuilder().create()))

addCallAdapterFactory(RxJava2CallAdapterFactory.createAsync())

if (isKotlinSuspendFunction) {
  adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
  annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
} else {
  // getGenericReturnType();用来返回一个方法的返回具体类型。
  adapterType = method.getGenericReturnType();
  // 比如 Call<String> getName();
  // 那么这时候的adapterType就是Call<String>
}

// Utils.java
static final class ParameterizedTypeImpl implements ParameterizedType {
        private final @Nullable Type ownerType;
        private final Type rawType;
        private final Type[] typeArguments;
        ParameterizedTypeImpl(@Nullable Type ownerType, Type rawType, Type... typeArguments) {
      // Require an owner type if the raw type needs it.
      if (rawType instanceof Class<?>
          && (ownerType == null) != (((Class<?>) rawType).getEnclosingClass() == null)) {
        throw new IllegalArgumentException();
      }

      for (Type typeArgument : typeArguments) {
        Objects.requireNonNull(typeArgument, "typeArgument == null");
        checkNotPrimitive(typeArgument);
      }

      this.ownerType = ownerType;
      this.rawType = rawType;
       this.typeArguments = typeArguments.clone();
      }
}

// Retrofit.java
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
    Annotation[] annotations) {
  Objects.requireNonNull(returnType, "returnType == null");
  Objects.requireNonNull(annotations, "annotations == null");

  int start = callAdapterFactories.indexOf(skipPast) + 1;
  for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
    CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
    if (adapter != null) {
      return adapter;
    }
  }
}

// DefaultCallAdapterFactory.java
@Override public @Nullable CallAdapter<?, ?> get(
    Type returnType, Annotation[] annotations, Retrofit retrofit) {
  if (getRawType(returnType) != Call.class) {
    return null;
  }
  if (!(returnType instanceof ParameterizedType)) {
    throw new IllegalArgumentException(
        "Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
  }
  final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);

  final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
      ? null
      : callbackExecutor;

  return new CallAdapter<Object, Call<?>>() {
    @Override public Type responseType() {
      return responseType;
    }

    @Override public Call<Object> adapt(Call<Object> call) {
      return executor == null
          ? call
          : new ExecutorCallbackCall<>(executor, call);
    }
  };
}

// HttpServiceMethod.java
new SuspendForBody<>(requestFactory,
    callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
    continuationBodyNullable);

// HttpServiceMethod
@Override final @Nullable ReturnT invoke(Object[] args) {
  Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
  return adapt(call, args);
}

// SuspendForBody.java
SuspendForBody(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
        Converter<ResponseBody, ResponseT> responseConverter,
        CallAdapter<ResponseT, Call<ResponseT>> callAdapter, boolean isNullable) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
      this.isNullable = isNullable;
    }
@Override protected Object adapt(Call<ResponseT> call, Object[] args) {
  call = callAdapter.adapt(call);//对于协程这个callAdappter就是上面讲了创建了一个匿名接口的匿名内部类。

  //noinspection unchecked Checked by reflection inside RequestFactory.
  Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];
  // 获取最后一个参数信息。
  // 我们使用 suspend fun getMyName() 的时候经过编译后，这个suspend就被编译成了Continuation这个对象。也就是说这个方法实际上就是 Continuation fun getMyName();
  try {
    return isNullable
        ? KotlinExtensions.awaitNullable(call, continuation)
        : KotlinExtensions.await(call, continuation);
  } catch (Exception e) {
    return KotlinExtensions.suspendAndThrow(e, continuation);
  }
}

new CallAdapter<Object, Call<?>>() {
    @Override public Type responseType() {
      return responseType;
    }
  final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
      ? null
      : callbackExecutor;
// 这个executor为null。因为在解析方法的时候，他判断了这个方法是不是协程，是的话就会代码里面自动给他添加上一个SkipCallbackExecutor的注释，意思就是告诉程序，协程的网络请求又程序自动进行。所以在调用adapt方法的时候返回的是call
    @Override public Call<Object> adapt(Call<Object> call) {
      return executor == null
          ? call
          : new ExecutorCallbackCall<>(executor, call);
    }
  };

// HttpServiceMethod 
static final class SuspendForBody<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
    private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;
    private final boolean isNullable;

    SuspendForBody(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
        Converter<ResponseBody, ResponseT> responseConverter,
        CallAdapter<ResponseT, Call<ResponseT>> callAdapter, boolean isNullable) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
      this.isNullable = isNullable;
    }

    @Override protected Object adapt(Call<ResponseT> call, Object[] args) {
      call = callAdapter.adapt(call);
      Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];
      try {
        return isNullable
            ? KotlinExtensions.awaitNullable(call, continuation)
            : KotlinExtensions.await(call, continuation);// 执行网络请求
      } catch (Exception e) {
        return KotlinExtensions.suspendAndThrow(e, continuation);
      }
    }
  }

executation(@注解? 修饰符匹配？ 返回值类型 类路径？方法名匹配 异常类型匹配？)
// 带问号的是不必须参数

package com.javacode2018.aop.demo9.test2;

public class C1 {
    public void m1() {
        System.out.println("我是m1");
    }

    public void m2() {
        System.out.println("我是m2");
    }
}
public class C2 extends C1 {
    @Override
    public void m2() {
        super.m2();
    }

    public void m3() {
        System.out.println("我是m3");
    }
}
@Aspect
public class AspectTest2 {

    @Pointcut("within(C1)") //@1
    public void pc() {
    }

    @Before("pc()") //@2
    public void beforeAdvice(JoinPoint joinpoint) {
        System.out.println(joinpoint);
    }

}
// 输出结果：我是m1 我是m2 我是m3  
// 看结果可知并没有走到切面里面去
//	修改
@Pointcut("within(C1+)") 
@Pointcut("within(C2)") 

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

public class Service2 {
    @note2(value = "我是权限")
    public String m3(int num){
        System.out.println("我是m3方法");
        return "我是返回值";
    }
}

@Aspect
public class Aspect1 {
    //找到被note2标记的方法 并获得注解的值
    @Pointcut("execution(@main.note2 String *(..)) && @annotation(noValue)&&args(num)")
    public void logPoint(note2 noValue,int num){
    }

    @Around(value = "logPoint(noValue,num)")
    public void aopFour(JoinPoint joinPoint,note2 noValue,int num)  {
        System.out.println(noValue.value()+"  "+num);
    }
}

public class Test {
    public static void main(String[] args) {
        Service2 service2 = new Service2();
        service2.m3(90);
    }
}
// 执行结果：
// 我是权限  90  

@Aspect
public class Aspect1 {
    //找到被note2标记的方法 并获得注解的值
    @Pointcut("execution(@main.note2 String *(..)) && @annotation(noValue)&&args(num)")
    public void logPoint(note2 noValue,int num){
    }

    @AfterReturning(value = "logPoint(noValue,num)",returning = "rvt")
    public void aopFour(JoinPoint joinPoint,note2 noValue,int num,String rvt)  {
        System.out.println(noValue.value()+"  "+num+"   "+rvt);
    }
}

@ModelView(autoLayout = Size.MATCH_WIDTH_WRAP_HEIGHT)
public class HeaderView extends LinearLayout {
  @TextProp
  public void setTitle(CharSequence text) {
    titleView.setText(text);
  }
}

@EpoxyModelClass(layout = R.layout.header_view)
public abstract class HeaderModel extends EpoxyModelWithHolder<Holder> {
  @EpoxyAttribute String title;

  @Override
  public void bind(Holder holder) {
    holder.header.setText(title);
  }

  static class Holder extends BaseEpoxyHolder {
    @BindView(R.id.text) TextView header;
  }
}

class MyPlugin implements Plugin<Project>{
    @Override
    void apply(Project target) {
        println('MyPlugin执行了')
        target.task("mytask"){
            doLast {
                println('MyPlugin中的task执行了')
            }
        }
    }
}

> Configure project :app
MyPlugin执行了

> Task :app:mytask
MyPlugin中的task执行了

class MyPlugin implements Plugin<Project> {
    @Override
    void apply(Project target) {
        println('buildSrc中MyPlugin执行了')
        target.task("mytask"){
            doLast {
                println('buildSrc中MyPlugin中的task执行了')
            }
        }
    }
}