<dependency>
    <groupId>io.esastack</groupId>
    <artifactId>restclient</artifactId>
    <version>${esa-restclient.version}</version>
</dependency>

final RestClient client = RestClient.ofDefault();

final String entity = client.post("http://127.0.0.1:8081/")
        .entity("Hello Server")
        .execute()
        .toCompletableFuture()
        .get()
        .bodyToEntity(String.class);

final RestClient client = RestClient.ofDefault();
RestResponseBase response  = client.post("localhost:8080/aaa")
        .contentType(MediaType.APPLICATION_JSON)
        .entity(new Person("Bob","male"))
        .execute()
        .toCompletableFuture()
        .get();

<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
</dependency>

//将ProtoBufCodec加入到RestClient中
final RestClient client = RestClient.create()
        .addEncoder(new ProtoBufCodec())
        .build();

RestResponseBase response  = client.post("localhost:8080/aaa")
        .contentType(ProtoBufCodec.PROTO_BUF)
        .entity(message)
        .execute()
        .toCompletableFuture()
        .get();

final RestClient client = RestClient.ofDefault();
RestResponseBase response  = client.post("localhost:8080/aaa")
        .entity(new File("tem"))
        .execute()
        .toCompletableFuture()
        .get();

final RestClient client = RestClient.ofDefault();
RestResponseBase response  = client.post("localhost:8080/aaa")
        .entity("string")
        .execute()
        .toCompletableFuture()
        .get();

final RestClient client = RestClient.ofDefault();
RestResponseBase response = client.post("localhost:8080/aaa")
        .entity("bytes".getBytes())
        .execute()
        .toCompletableFuture()
        .get();

public class StringEncoder implements ByteEncoder {

    @Override
    public RequestContent<byte[]> doEncode(EncodeContext<byte[]> ctx) {
        if (MediaType.TEXT_PLAIN.isCompatibleWith(ctx.contentType())) {
            if (ctx.entity() != null) {
                return RequestContent.of(ctx.entity().toString());
            } else {
                return RequestContent.of("null");
            }
        }
        //该Encoder无法Encode这种类型，将Encode工作交给下一个Encoder
        return ctx.next();
    }
}

final RestClient client = RestClient.create()
        .addEncoder(ctx -> {
            //encode...
            return ctx.next();
        })
        .build();

public interface EncoderFactory {
    Collection<Encoder> encoders(RestClientOptions clientOptions);
}

final RestResponseBase response = client.post(url)
        .entity(new File("aaa"))
        .encoder(ctx -> {
            //encode...
            return ctx.next();
        })
        .execute()
        .toCompletableFuture()
        .get();

public class EncodeAdviceImpl implements EncodeAdvice {
    @Override
    public RequestContent<?> aroundEncode(EncodeAdviceContext ctx) throws Exception {
        //...before encode
        RequestContent<?> requestContent = ctx.next();
        //...after encode
        return requestContent;
    }
}

final RestClient client = RestClient.create()
        .addEncodeAdvice(ctx -> {
            //...before encode
            RequestContent<?> requestContent = ctx.next();
            //...after encode
            return requestContent;
        })
        .build();

public interface EncodeAdviceFactory {
    Collection<EncodeAdvice> encodeAdvices(RestClientOptions clientOptions);
}

final RestClient client = RestClient.ofDefault();
RestResponseBase response  = client.get("localhost:8080/aaa")
        .execute()
        .toCompletableFuture()
        .get();

//当 response.contentType() == MediaType.APPLICATION_JSON 时将自动使用Json Decoder
Person person = response.bodyToEntity(Person.class);

<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
</dependency>

//将ProtoBufCodec加入到RestClient中
final RestClient client = RestClient.create()
        .addDecoder(new ProtoBufCodec())
        .build();

RestResponseBase response = client.get("localhost:8080/aaa")
        .execute()
        .toCompletableFuture()
        .get();

//当 ProtoBufCodec.PROTO_BUF.isCompatibleWith(response.contentType())，且 Person 为 Message 的子类时，将自动使用ProtoBuf Decoder
Person person = response.bodyToEntity(Person.class);

final RestClient client = RestClient.ofDefault();
RestResponseBase response = client.get("localhost:8080/aaa")
        .execute()
        .toCompletableFuture()
        .get();

//当 !MediaType.APPLICATION_JSON.isCompatibleWith(response.contentType()) 时，自动使用String Decoder来进行Decode
String result = response.bodyToEntity(String.class);

final RestClient client = RestClient.ofDefault();
RestResponseBase response = client.get("localhost:8080/aaa")
        .execute()
        .toCompletableFuture()
        .get();

//当 !MediaType.APPLICATION_JSON.isCompatibleWith(response.contentType()) 时，自动使用byte[] Decoder来进行Decode
byte[] result = response.bodyToEntity(byte[].class);

public class StringDecoder implements ByteDecoder {

    @Override
    public Object doDecode(DecodeContext<byte[]> ctx) {
        if (String.class.isAssignableFrom(ctx.targetType())) {
            return new String(ctx.content().value());
        }
        return ctx.next();
    }
}

final RestClient client = RestClient.create()
        .addDecoder(ctx -> {
            //decode...
            return ctx.next();
        })
        .build();

public interface DecoderFactory {
    Collection<Decoder> decoders(RestClientOptions clientOptions);
}

final RestResponseBase response = client.post(url)
        .entity(new File("aaa"))
        .decoder(ctx -> {
            //decode...
            return ctx.next();
        })
        .execute()
        .toCompletableFuture()
        .get();

public class DecodeAdviceImpl implements DecodeAdvice {
    @Override
    public Object aroundDecode(DecodeAdviceContext ctx) throws Exception {
        //...before decode
        Object decoded = ctx.next();
        //...after decode
        return decoded;
    }
}

final RestClient client = RestClient.create()
        .addDecodeAdvice(ctx ->{
            //...before decode
            Object decoded = ctx.next();
            //...after decode
            return decoded;
        })
        .build();

public interface DecodeAdviceFactory {
    Collection<DecodeAdvice> decodeAdvices(RestClientOptions clientOptions);
}

final RestClient client = RestClient.create()
        .addInterceptor((request, next) -> {
            System.out.println("Interceptor");
            return next.proceed(request);
        }).build();

public interface RestInterceptorFactory {
    Collection<RestInterceptor> interceptors(RestClientOptions clientOptions);
}

final RestClient client = RestClient.create().resolver(new HostResolver() {
    @Override
    public CompletionStage<InetAddress> resolve(String inetHost) {
        // resolve inetHost
        return CompletableFuture.completedFuture(null);
    }
}).build();

final RestClient client = RestClient.ofDefault();
final String entity = client.post("http://127.0.0.1:8081/")
        .entity(new File("aaa"))
        .execute()
        .toCompletableFuture()
        .get()
        .bodyToEntity(String.class);

final RestClient client = RestClient.ofDefault();

File file = new File("xxxxx");
final RestMultipartRequest request = client.post("http://127.0.0.1:9997/file/upload")
        .multipart()
        .file("file", file)
        .attr("name", "Bob")
        .attr("address", "China");

RestResponseBase response = request
        .execute()
        .toCompletableFuture()
        .get();
System.out.println(response.status());
System.out.println(response.bodyToEntity(String.class));

final RestClient client = RestClient.create()
        .connectionPoolSize(512)
        .connectionPoolWaitingQueueLength(256)
        .readTimeout(6000L)
        .connectTimeout(3000)
        .build();

final RestClient client = RestClient.create().channelPoolOptionsProvider(new ChannelPoolOptionsProvider() {
    @Override
    public ChannelPoolOptions get(SocketAddress key) {
        // customize options
	return null;
    }
}).build();

final RestClient client = RestClient.create()
        .readTimeout(3000L)
        .build();

final RestClient client = RestClient.ofDefault();

final String entity = client.get("http://127.0.0.1:8081/")
        .readTimeout(3000L)
        .execute()
        .toCompletableFuture()
        .get()
        .bodyToEntity(String.class);

final RestClient client = RestClient.create()
        .retryOptions(RetryOptions.options()
                .maxRetries(3)
                .intervalMs(value -> value)
                .predicate((request, response, ctx, cause) -> cause != null)
                .build())
        .connectionPoolSize(2048)
        .build();

final RestClient client = RestClient.ofDefault();

final String entity = client.get("http://127.0.0.1:8081/")
        .maxRetries(3)
        .execute()
        .toCompletableFuture()
        .get()
        .bodyToEntity(String.class);

final RestClient client = RestClient.create()
        .maxRedirects(3)
        .build();

final RestClient client = RestClient.ofDefault();

final String entity = client.get("http://127.0.0.1:8081/")
        .maxRedirects(3)
        .execute()
        .toCompletableFuture()
        .get()
        .bodyToEntity(String.class);

final RestClient client = RestClient.create()
        .useExpectContinue(true)
        .build();

final String entity = client.get("http://127.0.0.1:8081/")
        .disableExpectContinue()
        .execute()
        .toCompletableFuture()
        .get()
        .bodyToEntity(String.class);

final RestClient client = RestClient.ofDefault();

ConnectionPoolMetricProvider connectionPoolMetricProvider = client.connectionPoolMetric();
ConnectionPoolMetric connectionPoolMetric = connectionPoolMetricProvider.get(InetSocketAddress.createUnresolved("127.0.0.1", 8080));

// 连接池配置
connectionPoolMetric.options();

// 等待获取连接的请求个数
connectionPoolMetric.pendingAcquireCount();

// 活跃连接个数
connectionPoolMetric.active();

// 等待获取连接队列最大值
connectionPoolMetric.maxPendingAcquires();

// 连接池最大值
connectionPoolMetric.maxSize();

IoThreadGroupMetric ioThreadGroupMetric = client.ioThreadsMetric();

for (IoThreadMetric ioThreadMetric : ioThreadGroupMetric.childExecutors()) {
    // 任务队列大小
    ioThreadMetric.pendingTasks();

    // 任务队列最大值
    ioThreadMetric.maxPendingTasks();

    // 线程状态
    ioThreadMetric.state();

    // 线程名称
    ioThreadMetric.name();
}

<dependency>
    <groupId>io.esastack</groupId>
    <artifactId>traffic-split-file-config</artifactId>
    <version>${esa-restclient.version}</version>
</dependency>

# 可以不配置，默认为false，为true时，自动关闭分流功能
close: 'false'
# 规则，数据结构为数组，用户可同时配置多条，当请求命中一条时，后续的规则将不再匹配
rules:
  # 规则名称
  - name: "aaa"
    # 多条conditions的match模式，all指所有condition匹配时才算匹配
    match: 'all'   
    # 规则的匹配条件，数据结构为数组，用户可设置多个condition
    conditions:
      # 第一条 condition
      - method: 'post'
        uriAuthority:
          exact: "localhost:8080"
        header:
          - name: 'name1'
            value: 
              exact: 'value1'
      # 第二条 condition
      - params:
          - name: 'name3'
            value:
              exact: 'value3'
    # 当 conditions 匹配上时，要执行的动作
    action:
      rewrite:
        uriAuthority: "localhost:8080"
        path: "/request/redefineSuccess"
      headers:
        add:
          a: "xxx"
          b: "aaa"