Feign.Builder的常用方法

最新推荐文章于 2024-06-20 17:00:23 发布

路西法98

最新推荐文章于 2024-06-20 17:00:23 发布

阅读量895

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_42594143/article/details/134163961

版权

Feign是一个声明式、模板化的HTTP客户端，它使得编写Web服务客户端变得更加容易。Feign.Builder是Feign的构建器，用于构建Feign客户端实例。下面是Feign.Builder的一些常用方法：

1. target(Class<T> apiType, String url)：设置要调用的API接口类型和URL地址。

2. encoder(Encoder encoder)：设置请求参数编码器。

3. decoder(Decoder decoder)：设置响应结果解码器。

4. logger(Logger logger)：设置日志输出器。

5. logLevel(Level level)：设置日志输出级别。

6. retryer(Retryer retryer)：设置重试机制。

7. options(Request.Options options)：设置请求配置项。

8. requestInterceptor(RequestInterceptor interceptor)：设置请求拦截器。

9. decode404()：设置当响应状态码为404时，是否抛出异常。

10. target(Target<T> target)：设置目标对象。

这些方法可以根据实际需求进行调用，以构建出符合要求的Feign客户端实例。

target(Class apiType, String url)：设置要调用的API接口类型和URL地址。

Feign.Builder的target(Target target)方法用于设置Feign客户端的目标对象，该方法需要传入一个Target类型的参数，其中Target是一个接口，用于定义Feign客户端的目标对象的基本信息，例如请求协议、请求地址、请求端口等。

下面是一个示例代码：

MyApi myApi = Feign.builder()
        .target(new Target.HardCodedTarget<>(MyApi.class, "http://localhost:8080"));

在上面的代码中，我们创建了一个MyApi接口的实例对象myApi，并通过Feign.builder()方法来构建Feign客户端。然后，我们调用target方法，并传入一个Target.HardCodedTarget对象作为参数，该对象表示一个硬编码的目标对象，其中MyApi.class表示目标对象的接口类型，"http://localhost:8080"表示目标对象的请求地址和端口。

除了使用Target.HardCodedTarget对象来设置目标对象，我们还可以自定义一个Target对象，例如：

public class MyTarget<T> implements Target<T> {
 
    private final Class<T> type;
    private final String url;
 
    public MyTarget(Class<T> type, String url) {
        this.type = type;
        this.url = url;
    }
 
    @Override
    public Class<T> type() {
        return type;
    }
 
    @Override
    public String name() {
        return url;
    }
 
    @Override
    public String url() {
        return url;
    }
 
    @Override
    public RequestTemplate requestTemplate() {
        return new RequestTemplate();
    }
}

在上面的代码中，我们定义了一个MyTarget类，实现了Target接口，并重写了其中的方法。在构造方法中，我们传入了目标对象的接口类型和请求地址，然后在重写的方法中，返回了对应的值。

使用自定义的MyTarget对象来设置目标对象的示例代码如下：

MyApi myApi = Feign.builder()
        .target(new MyTarget<>(MyApi.class, "http://localhost:8080"));

在上面的代码中，我们创建了一个MyApi接口的实例对象myApi，并通过Feign.builder()方法来构建Feign客户端。然后，我们调用target方法，并传入一个自定义的MyTarget对象作为参数，该对象表示一个自定义的目标对象，其中MyApi.class表示目标对象的接口类型，"http://localhost:8080"表示目标对象的请求地址和端口。

总之，Feign.Builder的target(Target target)方法用于设置Feign客户端的目标对象，其中Target是一个接口，用于定义Feign客户端的目标对象的基本信息。我们可以使用Target.HardCodedTarget对象来设置目标对象，也可以自定义一个Target对象来设置目标对象。

encoder(Encoder encoder)：设置请求参数编码器。

方法示例代码：

public interface UserService {
    @RequestLine("POST /user/add")
    @Headers("Content-Type: application/json")
    void addUser(User user);
}

public class User {
    private String name;
    private int age;
    // getter and setter
}

public class CustomEncoder implements Encoder {
    private final ObjectMapper objectMapper;

    public CustomEncoder(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    @Override
    public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
        try {
            String json = objectMapper.writeValueAsString(object);
            template.body(json, Charset.defaultCharset());
        } catch (JsonProcessingException e) {
            throw new EncodeException("Failed to encode object", e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        Feign.Builder builder = Feign.builder()
                .encoder(new CustomEncoder(objectMapper))
                .target(UserService.class, "http://localhost:8080");
        UserService userService = builder.build();
        User user = new User();
        user.setName("Tom");
        user.setAge(18);
        userService.addUser(user);
    }
}

自定义请求参数编码器示例代码：

public class CustomEncoder implements Encoder {
    private final ObjectMapper objectMapper;

    public CustomEncoder(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    @Override
    public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
        try {
            if (object instanceof Map) {
                Map<String, Object> map = (Map<String, Object>) object;
                StringBuilder sb = new StringBuilder();
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    sb.append(entry.getKey()).append("=").append(URLEncoder.encode(entry.getValue().toString(), "UTF-8")).append("&");
                }
                sb.deleteCharAt(sb.length() - 1);
                template.body(sb.toString(), Charset.defaultCharset());
            } else {
                String json = objectMapper.writeValueAsString(object);
                template.body(json, Charset.defaultCharset());
            }
        } catch (JsonProcessingException | UnsupportedEncodingException e) {
            throw new EncodeException("Failed to encode object", e);
        }
    }
}

上述示例代码中，自定义了一个请求参数编码器CustomEncoder，它实现了Feign的Encoder接口，主要作用是将请求参数编码成指定格式的字符串，然后设置到RequestTemplate中的body中。

在CustomEncoder的encode方法中，首先判断传入的对象是否是Map类型，如果是，则将其转换为key=value&key=value的形式，并进行URL编码，最后设置到RequestTemplate的body中；如果不是Map类型，则将其转换为JSON字符串，并设置到RequestTemplate的body中。

在使用Feign.Builder的encoder方法时，可以将自定义的编码器传入，使得Feign在发送请求时能够按照自定义的方式对请求参数进行编码。

decoder(Decoder decoder)：设置响应结果解码器。
方法的示例代码：

public interface MyApi {
  @RequestLine("GET /users/{id}")
  User getUser(@Param("id") Long id);
}

Decoder myDecoder = new MyDecoder();
MyApi myApi = Feign.builder()
                   .decoder(myDecoder)
                   .target(MyApi.class, "http://localhost:8080");

User user = myApi.getUser(123);

该示例代码中，我们首先定义了一个MyApi接口，其中包含了一个getUser方法，该方法使用@RequestLine注解指定了请求方法和路径，并使用@Param注解指定了请求参数。接着，我们定义了一个MyDecoder类，该类实现了Feign的Decoder接口，用于自定义响应结果的解码器。最后，我们使用Feign.builder().decoder(myDecoder).target()方法来构建一个Feign客户端，并调用getUser方法获取用户信息。

自定义响应结果解码器的示例代码：

public class MyDecoder implements Decoder {
  @Override
  public Object decode(Response response, Type type) throws IOException, FeignException {
    if (response.status() == 200) {
      String json = response.body().asString();
      Gson gson = new Gson();
      return gson.fromJson(json, type);
    } else {
      throw new FeignException(response.status(), "Failed to decode response");
    }
  }
}

该示例代码中，我们定义了一个MyDecoder类，该类实现了Feign的Decoder接口，重写了decode方法。在decode方法中，我们首先判断响应状态是否为200，如果是，则将响应体转换为字符串，并使用Gson库将其转换为指定类型的对象，并返回该对象；如果不是，则抛出FeignException异常。这样，我们就可以使用自定义的响应结果解码器来处理Feign客户端的响应结果了。

总之，Feign.Builder的decoder(Decoder decoder)方法用于设置Feign客户端的响应结果解码器，我们可以通过实现Feign的Decoder接口来自定义响应结果的解码器，以便更好地处理Feign客户端的响应结果。

retryer(Retryer retryer)：设置重试机制。

Feign.Builder的retryer(Retryer retryer)方法用于设置Feign客户端的重试策略。其中，Retryer是一个接口，用于定义重试策略，Feign提供了多个默认的实现类，如：

Retryer.Default：默认的重试策略，最多重试5次，每次重试的间隔时间依次为100ms、200ms、400ms、800ms、1600ms。
Retryer.NEVER_RETRY：不进行重试。
Retryer.Default100：最多重试100次，每次重试的间隔时间依次为100ms、200ms、400ms、800ms、1600ms、3200ms、6400ms、12800ms、25600ms、51200ms。

如果以上默认的重试策略不能满足需求，可以通过实现Retryer接口来自定义重试策略。自定义重试策略需要实现Retryer接口中的retry方法，该方法接收一个RetryableException类型的异常，返回一个boolean类型的值，表示是否需要进行重试。示例代码如下：

public class CustomRetryer implements Retryer {
    private final int maxAttempts;
    private final long backoff;
    private int attempt;

    public CustomRetryer() {
        this(5, 100);
    }

    public CustomRetryer(int maxAttempts, long backoff) {
        this.maxAttempts = maxAttempts;
        this.backoff = backoff;
        this.attempt = 1;
    }

    @Override
    public void continueOrPropagate(RetryableException e) {
        if (attempt++ >= maxAttempts) {
            throw e;
        }
        try {
            Thread.sleep(backoff);
        } catch (InterruptedException ignored) {
            Thread.currentThread().interrupt();
            throw e;
        }
    }

    @Override
    public Retryer clone() {
        return new CustomRetryer(maxAttempts, backoff);
    }
}

上述代码实现了一个自定义的重试策略，最多重试5次，每次重试的间隔时间为100ms。如果重试次数达到5次仍然失败，则抛出RetryableException异常。如果重试过程中线程被中断，则抛出RetryableException异常。

使用自定义的重试策略可以通过以下代码进行设置：

Feign.Builder builder = Feign.builder();
builder.retryer(new CustomRetryer());

上述代码将Feign客户端的重试策略设置为自定义的重试策略。

options(Request.Options options)：设置请求配置项。

Feign.Builder的options(Request.Options options)方法是用来设置Feign客户端的请求配置项的方法，其中Request.Options是Feign客户端请求配置项的封装类。

以下是Feign.Builder的options(Request.Options options)方法的详细示例代码：

Feign.Builder builder = Feign.builder()
    .options(new Request.Options(5000, 10000));

上面的代码中，设置了Feign客户端的请求超时时间为5000毫秒，连接超时时间为10000毫秒。

此外，我们还可以自定义请求配置项，例如：

Request.Options options = new Request.Options(
    3000,  // 连接超时时间为3秒
    5000   // 请求超时时间为5秒
);
Feign.Builder builder = Feign.builder().options(options);

上面的代码中，我们自定义了Feign客户端的请求超时时间和连接超时时间。

总之，Feign.Builder的options(Request.Options options)方法是用来设置Feign客户端的请求配置项的方法，可以通过该方法设置请求超时时间、连接超时时间等配置项。

requestInterceptor(RequestInterceptor interceptor)：设置请求拦截器。

Feign.Builder的requestInterceptor方法用于添加请求拦截器，可以在发送请求之前对请求进行修改或添加自定义的请求头信息等操作。以下是详细示例代码：

public class MyRequestInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        // 添加自定义请求头信息
        template.header("Authorization", "Bearer token");
    }
}

public class MyFeignClient {

    public MyApi createClient() {
        return Feign.builder()
                .requestInterceptor(new MyRequestInterceptor())
                .target(MyApi.class, "http://localhost:8080");
    }
}

上述代码中，我们定义了一个名为MyRequestInterceptor的自定义请求拦截器，实现了Feign的RequestInterceptor接口，并在apply方法中添加了一个自定义请求头信息。然后在MyFeignClient类中，使用Feign.builder()创建了一个Feign客户端，并通过requestInterceptor方法添加了MyRequestInterceptor拦截器。

自定义请求拦截器的示例代码如下：

public class MyRequestInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        // 添加自定义请求头信息
        template.header("Authorization", "Bearer token");

        // 修改请求体内容
        String requestBody = template.body();
        if (requestBody != null) {
            requestBody = requestBody.replaceAll("foo", "bar");
            template.body(requestBody);
        }
    }
}