Rose博客

@ConfigurationProperties(prefix = "spring.flyway")
public class FlywayProperties { 
    /**
     * 是否开启flyway, 默认开启
     */
    private boolean enabled = true;

    /**
     * sql脚本的位置，默认在db/migration目录下
     */
    private List<String> locations = new ArrayList<>(Collections.singletonList("classpath:db/migration"));

    /**
     * flyway history表名， 默认是flyway_schema_history
     * 支持占位符
     */
    private String table = "flyway_schema_history";

    /**
     * 基线版本，默认是1 
     * 即从V1开始，低于1的版本会忽略（前提是数据库已经存在schame）
     */
    private String baselineVersion = "1";

    /**
     * 基线版本的描述，用于插入基线行的 description 字段
     */
    private String baselineDescription = "<< Flyway Baseline >>";

    /**
     * 当 schame 非空时，是否自动调用 baseline
     * 如果配置为了 false，发现非空schame且找不到 flyway table 会直接报错
     */
    private boolean baselineOnMigrate;

    /**
     * 是否禁用清除数据库，默认禁用
     */
    private boolean cleanDisabled = true;

    /**
     * 是否允许不按顺序迁移
     */
    private boolean outOfOrder;
      
}

public class PrintApp {
    private final Printer printer;              // 打印机
    private final PrintDriver printDriver;      // 打印机驱动
    
    @Inject   // 注入依赖
    PrintApp(PrintDriver printDriver, Printer printer) {
        this.printDriver = printDriver;
        this.printer = printer;
    }
}

public interface Printer {
    /**
     * 打印
     */
    void print(Connection connect);
}

public interface PrintDriver {
    /**
     * 连接打印机
     */
    Connection connect();

}

public class PrintApp {
    @Inject
    Printer printer;

    @Inject
    PrintDriver printDriver;
}

@Module(injects = PrintApp.class, library = true)  // <1> injects表示注入类型， library表示可在外部依赖
public class PrintModule {

    @Provides       // <2> 方法注解，方法的返回值可用于满足依赖
    @Singleton      // 单例， 在所有注入的地方dagger都不会重新创建
    Printer providerPrinter() {
        return new ZebraPrinter();
    }

    @Provides
    PrintDriver providerDriver() {
        return new ZebraPrintDriver();
    }

}

public class ZebraPrinter implements Printer {
    @Override
    public void print(Connection connect) {
        if(connect.connected) {
            System.out.println("开始打印");
        } else {
            throw new RuntimeException("打印机未连接");
        }
    }
}

public class ZebraPrintDriver implements PrintDriver {
    @Override
    public Connection connect() {
        // 随机失败
        if(System.currentTimeMillis() % 2 > 0) {
            System.out.println("打印机连接失败");
            return new Connection(false);
        }
        System.out.println("打印机连接成功");
        return new Connection(true);
    }
}

// 通过打印模块来构造一个依赖图
ObjectGraph objectGraph = ObjectGraph.create(new PrintModule());

// 通过打印模块来构造一个依赖图
ObjectGraph objectGraph = ObjectGraph.create(new PrintModule());
PrintApp printApp = objectGraph.get(PrintApp.class);

public class PrintApp {
    @Inject Printer printer;
    @Inject PrintDriver printDriver;
    
    void print() {
        Connection connect = printDriver.connect();
        printer.print(connect);
    }

    public static void main(String[] args) {
        // 通过打印模块来构造一个依赖图
        ObjectGraph objectGraph = ObjectGraph.create(new PrintModule());
        PrintApp printApp = objectGraph.get(PrintApp.class);
        printApp.print();
    }
}

public interface GitHub {
    @GET
    @Path("/repos/{owner}/{repo}/contributors")
    List<Contributor> contributors(@PathParam("owner") String owner, @PathParam("repo") String repo);
}

public class Contributor {
    public String login;
    public int contributions;
}

public class GitHubExample {

    public static void main(String... args) {
        // <1> 新建代理接口
        GitHub github = Feign.create(GitHub.class, "https://api.github.com", new GsonModule());

        // <2> 调用代理方法（获取netflix的feign项目的贡献者列表）
        List<Contributor> contributors = github.contributors("netflix", "feign");
        for (Contributor contributor : contributors) {
            // 打印输出
            System.out.println(contributor.login + " (" + contributor.contributions + ")");
        }
    }

    @Module(overrides = true, library = true)  
    static class GsonModule {                       // <3> GsonModule 模块
        @Provides       // 方法的返回可作为注入实例
        @Singleton      // 单例，全局唯一
        Map<String, Decoder> decoders() {   // 提供http响应解码器 
            return ImmutableMap.of("GitHub", jsonDecoder);
        }
    
        //  gson实现的json解码器
        final Decoder jsonDecoder = new Decoder() {
            Gson gson = new Gson();

            @Override
            public Object decode(String methodKey, Reader reader, TypeToken<?> type) {
                return gson.fromJson(reader, type.getType());
            }
        };
    }
}

public abstract class Feign {

  /**
   * 新建代理实例
   */
  public abstract <T> T newInstance(Target<T> target);

  /**
   * 创建一个代理类实例
   * @param apiType  实例类型
   * @param url      域名地址(直接合方法上的地址拼接)
   * @param modules  dagger模块（使用门槛还是比较高，提供了 GsonModule
   */
  public static <T> T create(Class<T> apiType, String url, Object... modules) {
    return create(new HardCodedTarget<T>(apiType, url), modules);    
  }

  public static <T> T create(Target<T> target, Object... modules) {
    return create(modules).newInstance(target);
  }

  public static Feign create(Object... modules) {
    Object[] modulesForGraph = ImmutableList.builder() 
        .add(new Defaults())                    // 默认模块实现
        .add(new ReflectiveFeign.Module())      // 反射实现模块
        .add(Optional.fromNullable(modules).or(new Object[]{}))
        .build().toArray();
    return ObjectGraph.create(modulesForGraph).get(Feign.class);  // dagger 对象依赖图
  }
}

@dagger.Module(complete = false, injects = Feign.class, library = true)
  public static class Defaults {

    @Provides SSLSocketFactory sslSocketFactory() {
      return SSLSocketFactory.class.cast(SSLSocketFactory.getDefault());
    }

    @Provides Client httpClient(Client.Default client) { return client; }

    @Provides Retryer retryer() { return new Retryer.Default(); }

    @Provides Wire noOp() { return new NoOpWire(); }

    @Provides Map<String, Options> noOptions() { return ImmutableMap.of(); }

    @Provides Map<String, BodyEncoder> noBodyEncoders() { return ImmutableMap.of(); }

    @Provides Map<String, FormEncoder> noFormEncoders() { return ImmutableMap.of(); }

    @Provides Map<String, Decoder> noDecoders() { return ImmutableMap.of(); }

    @Provides Map<String, ErrorDecoder> noErrorDecoders() { return ImmutableMap.of();}
  }

public class ReflectiveFeign extends Feign {

  @dagger.Module(complete = false,// Config
      injects = Feign.class, library = true// provides Feign
  )
  public static class Module {

    @Provides Feign provideFeign(ReflectiveFeign in) {
      return in;
    }
  }
}

public interface Target<T> extends Function<RequestTemplate, Request> {
    /**
     * 保存代理类类型
     */
    Class<T> type();

    /* 配置实例的名字，无特殊要求 */
    String name();

    /* 返回实例对象的http url */
    String url();

    /** 从请求模板生成一个请求 */
    @Override
    public Request apply(RequestTemplate input);

    // 内部类，硬编码Target，只是保存了代理类类型
    public static class HardCodedTarget<T> implements Target<T> {
        private final Class<T> type;
        private final String name;
        private final String url;

        public HardCodedTarget(Class<T> type, String url) {
            this(type, url, url);
        }

        public HardCodedTarget(Class<T> type, String name, String url) {
            this.type = checkNotNull(type, "type");
            this.name = checkNotNull(Strings.emptyToNull(name), "name");
            this.url = checkNotNull(Strings.emptyToNull(url), "url");
        }

        @Override
        public Class<T> type() {
            return type;
        }

        @Override
        public String name() {
            return name;
        }

        @Override
        public String url() {
            return url;
        }

        @Override
        public Request apply(RequestTemplate input) {
            if (input.url().indexOf("http") != 0)
                input.insert(0, url());
            return input.request();
        }
    }
}

public final class Contract {   
    // 解析method
    public static MethodMetadata parseAndValidatateMetadata(Method method) {
        MethodMetadata data = new MethodMetadata();
        // 保存方法返回的泛型类型
        data.returnType(TypeToken.of(method.getGenericReturnType()));
        // 解析方法的javadoc方法串
        data.configKey(Feign.configKey(method));

        // 方法解析
        for (Annotation methodAnnotation : method.getAnnotations()) {
          Class<? extends Annotation> annotationType = methodAnnotation.annotationType();
          HttpMethod http = annotationType.getAnnotation(HttpMethod.class);
          if (http != null) {
            data.template().method(http.value());
          } else if (annotationType == RequestTemplate.Body.class) {
            String body = RequestTemplate.Body.class.cast(methodAnnotation).value();
            if (body.indexOf('{') == -1) {
              data.template().body(body);
            } else {
              data.template().bodyTemplate(body);  // 请求body模板
            }
          } else if (annotationType == Path.class) {
            // http 请求path, 追加到url
            data.template().append(Path.class.cast(methodAnnotation).value());
          } else if (annotationType == Produces.class) {
            // 解析http请求头  Content-Type
            data.template().header(CONTENT_TYPE, Joiner.on(',').join(((Produces) methodAnnotation).value()));
          } else if (annotationType == Consumes.class) {
            // 解析http请求头 Accept
            data.template().header(ACCEPT, Joiner.on(',').join(((Consumes) methodAnnotation).value()));
          }
        }

        Class<?>[] parameterTypes = method.getParameterTypes();
        
         // 参数注解
        Annotation[][] parameterAnnotationArrays = method.getParameterAnnotations();
        int count = parameterAnnotationArrays.length;  // 参数个数
        for (int i = 0; i < count; i++) {
          boolean hasHttpAnnotation = false;

          Class<?> parameterType = parameterTypes[i];
          Annotation[] parameterAnnotations = parameterAnnotationArrays[i];
          if (parameterAnnotations != null) {
            for (Annotation parameterAnnotation : parameterAnnotations) {
                // 省略处理参数注解的代码
            }
    
          }

          if (parameterType == URI.class) {
            data.urlIndex(i);   // 表示url参数的下标（方法的url参数优先级最高）
          } else if (!hasHttpAnnotation) {
            data.bodyIndex(i);     // json body的参数下标
          }
        }

        return data;
    }
}

public final class MethodMetadata implements Serializable {
  MethodMetadata() {}

  private String configKey;    // 方法全限定名称

  private transient TypeToken<?> returnType;  // 方法的返回类型

  private Integer urlIndex;  // url参数的下标，没有则为空

  private Integer bodyIndex;   // json实体类的下标，没有则为空
 
  private RequestTemplate template = new RequestTemplate();  // 请求模板

  private List<String> formParams = Lists.newArrayList();  //表单参数字段名

  /**
   * 存储请求方法的一些参数的位置下标（顺序）和名称，蚕例如path或query
   * key表示位置下标，value表示 PathParam 的name 或 PathParam 的name
   */
  private SetMultimap<Integer, String> indexToName = LinkedHashMultimap.create();

  // 省略getter setter
}

final class MethodHandler {
  private final MethodMetadata metadata;  // 方法元数据，通过Contract层解析得到
  private final Target<?> target;   // 代理类实例
  private final Client client;   // http客户端接口
  /**
   * 重试组件，因为组件的实现是有状态的，每次请求都需要重新生成，
   * 所以使用Provider方式注入
   */
  private final Provider<Retryer> retryer;
  private final Wire wire;   // 日志扩展
  private final Function<Object[], RequestTemplate> buildTemplateFromArgs;  // 处理方法参数
  private final Options options;   // http请求配置
  private final Decoder decoder;   // 解码器
  private final ErrorDecoder errorDecoder;    // 错误解码器
}

/**
 * 将代理类解析成MethodHandler映射
 */
@Override
public Map<String, MethodHandler> apply(Target key) {
  // 将代理类的方法解析成MethodMetadata元数据
  Set<MethodMetadata> metadata = parseAndValidatateMetadata(key.type());
  ImmutableMap.Builder<String, MethodHandler> builder = ImmutableMap.builder();
  // 将MethodMetadata转换成MethodHandler
  for (MethodMetadata md : metadata) {
    // options 是 http 一些配置
    Options options = forMethodOrClass(this.options, md.configKey());
    if (options == null) {
      options = new Options();
    }
    // 解码器
    Decoder decoder = forMethodOrClass(decoders, md.configKey());
    if (decoder == null
            && (md.returnType().getRawType() == void.class
            || md.returnType().getRawType() == Response.class)) {
      // 方法返回类型是 Void或者Response，使用默认ToStringDecoder解析器
      decoder = new ToStringDecoder();
    }
    if (decoder == null) {
      throw noConfig(md.configKey(), Decoder.class);
    }
    // 错误解码器
    ErrorDecoder errorDecoder = forMethodOrClass(errorDecoders, md.configKey());
    if (errorDecoder == null) {
      errorDecoder = ErrorDecoder.DEFAULT;
    }
    Function<Object[], RequestTemplate> buildTemplateFromArgs;
    if (!md.formParams().isEmpty() && !md.template().bodyTemplate().isPresent()) {
      FormEncoder formEncoder = forMethodOrClass(formEncoders, md.configKey());
      if (formEncoder == null) {
        throw noConfig(md.configKey(), FormEncoder.class);
      }
      // 表单编码模板
      buildTemplateFromArgs = new BuildFormEncodedTemplateFromArgs(md, formEncoder);
    } else if (md.bodyIndex() != null) {
      BodyEncoder bodyEncoder = forMethodOrClass(bodyEncoders, md.configKey());
      if (bodyEncoder == null) {
        throw noConfig(md.configKey(), BodyEncoder.class);
      }
      // body编码模板
      buildTemplateFromArgs = new BuildBodyEncodedTemplateFromArgs(md, bodyEncoder);
    } else {
      buildTemplateFromArgs = new BuildTemplateFromArgs(md);
    }
    // 用工程创建MethodHandler
    builder.put(md.configKey(),
        factory.create(key, md, buildTemplateFromArgs, options, decoder, errorDecoder));
  }
  return builder.build();
}

static final class ParseHandlersByName {
   @Inject
    ParseHandlersByName(Map<String, Options> options,
                        Map<String, BodyEncoder> bodyEncoders,
                        Map<String, FormEncoder> formEncoders,
                        Map<String, Decoder> decoders,
                        Map<String, ErrorDecoder> errorDecoders,
                        Factory factory) {
      this.options = options;
      this.bodyEncoders = bodyEncoders;
      this.formEncoders = formEncoders;
      this.decoders = decoders;
      this.factory = factory;
      this.errorDecoders = errorDecoders;
    }
}

public Object invoke(Object[] argv) throws Throwable {
    // 通过方法参数构建请求模板
    RequestTemplate template = buildTemplateFromArgs.apply(argv);
    // 重试器是有状态的，所以这里需要重新get (内部是new)
    Retryer retryer = this.retryer.get();  
    while (true) {
      try {
        // 执行http请求并解码响应
        return executeAndDecode(metadata.configKey(), template, metadata.returnType());
      } catch (RetryableException e) {
        retryer.continueOrPropagate(e);
        continue;
      }
    }
}

/**
 * 执行请求并解码
 */
public Object executeAndDecode(String configKey, RequestTemplate template, TypeToken<?> returnType)
      throws Throwable {
    // 经过target包一层，其实RequestTemplate就内置一个Request
    Request request = target.apply(new RequestTemplate(template));
    // 日志扩展
    wire.wireRequest(target, request);
    // http 请求
    Response response = execute(request);
    try {
      response = wire.wireAndRebufferResponse(target, response);
      // 正常http响应
      if (response.status() >= 200 && response.status() < 300) {
        if (returnType.getRawType().equals(Response.class)) {
            // 直接返回原生
          return response;
        } else if (returnType.getRawType() == URI.class && !response.body().isPresent()) {
          ImmutableList<String> location = response.headers().get(LOCATION);
          if (!location.isEmpty())
            return URI.create(location.get(0));
        } else if (returnType.getRawType() == void.class) {
          return null;
        }
        // 解码器
        return decoder.decode(configKey, response, returnType);
      } else {
        // 错误解码器
        return errorDecoder.decode(configKey, response, returnType);
      }
    } catch (Throwable e) {
      ensureBodyClosed(response);  // 关闭响应流
      if (IOException.class.isInstance(e))
        throw errorReading(request, response, IOException.class.cast(e));
      throw e;
    }
  }

public interface Client {
  /**
   * 执行http请求
   */
   Response execute(Request request, Options options) throws IOException;
}

public final class Request {
  private final String method;      // 请求方法, 例如 GET/POST/PUT/DELETE 等
  private final String url;         // 请求地址, 完整链接，包含参数等
  private final ImmutableListMultimap<String, String> headers;  // http 请求头
  private final Optional<String> body;   // http request body
}

public static class Options {
    private final int connectTimeoutMillis;  // 连接超时
    private final int readTimeoutMillis;     // 响应超时  
}

HttpURLConnection convertAndSend(Request request, Options options) throws IOException {
  // 连接实例
  final HttpURLConnection connection = (HttpURLConnection) new URL(request.url()).openConnection();
  if (connection instanceof HttpsURLConnection) {
    HttpsURLConnection sslCon = (HttpsURLConnection) connection;
    sslCon.setSSLSocketFactory(sslContextFactory.get());   // http 支持
  }
  // 一些http请求参数
  connection.setConnectTimeout(options.connectTimeoutMillis());
  connection.setReadTimeout(options.readTimeoutMillis());
  connection.setAllowUserInteraction(false);
  connection.setInstanceFollowRedirects(true);
  connection.setRequestMethod(request.method());

  Integer contentLength = null;
  for (Entry<String, String> header : request.headers().entries()) {
    if (header.getKey().equals(CONTENT_LENGTH))
      contentLength = Integer.valueOf(header.getValue());
    connection.addRequestProperty(header.getKey(), header.getValue());
  }

  if (request.body().isPresent()) {
    if (contentLength != null) {
      connection.setFixedLengthStreamingMode(contentLength);
    } else {
      connection.setChunkedStreamingMode(8196);
    }
    connection.setDoOutput(true);
    // 将输出流写入到body中
    new ByteSink() {
      public OutputStream openStream() throws IOException {
        return connection.getOutputStream();
      }
    }.asCharSink(UTF_8).write(request.body().get());
  }
  return connection;
}

Response convertResponse(HttpURLConnection connection) throws IOException {
    int status = connection.getResponseCode();
    String reason = connection.getResponseMessage();

    ImmutableListMultimap.Builder<String, String> headers = ImmutableListMultimap.builder();
    for (Map.Entry<String, List<String>> field : connection.getHeaderFields().entrySet()) {
      // response message
      if (field.getKey() != null)
        headers.putAll(field.getKey(), field.getValue());
    }

    Integer length = connection.getContentLength();
    if (length == -1)
      length = null;
    InputStream stream;
    if (status >= 400) {
      stream = connection.getErrorStream();
    } else {
      // 获取响应输入流
      stream = connection.getInputStream();
    }
    Reader body = stream != null ? new InputStreamReader(stream) : null;
    // 从reader中创建Response
    return Response.create(status, reason, headers.build(), body, length);
  }