Giới thiệu Feign – Tạo ứng dụng Java RESTful Client không thể đơn giản hơn

@Headers({
"Cache-Control: max-age=640000",
"Accept: application/vnd.github.v3.full+json",
"User-Agent: Retrofit-Sample-App"
})
@RequestLine("GET /api/v1/users?sort=desc")
List getUsers();

@RequestLine("DELETE /api/v1/users/{id}")
@Headers("Authentication: Bearer {token}")
void deleteUser(@Param("id") int id, @Param("token") String token);

package com.gpcoder.service;

import feign.Headers;
import feign.Param;
import feign.RequestLine;

public interface AuthService {

@RequestLine("POST /auth")
@Headers({
"Accept: application/json; charset=utf-8",
"Content-Type: application/x-www-form-urlencoded" })
String getToken(@Param("username") String username, @Param("password") String password);
}

package com.gpcoder.service;

import java.util.ArrayList;
import java.util.List;

import com.gpcoder.model.Order;

import feign.Headers;
import feign.Param;
import feign.RequestLine;

@Headers({
"Accept: application/json; charset=utf-8",
"Content-Type: application/json" })
public interface OrderService {

@RequestLine("GET /orders/{id}")
String getOrder(@Param("id") int id);

@RequestLine("POST /orders")
String createOrder(Order order);

@RequestLine("PUT /orders")
String updateOrder(Order order);

@RequestLine("DELETE /orders/{id}")
String deleteOrder(@Param("id") int id);

default List getOrders(int... ids) {
List orders = new ArrayList<>();
for (int id : ids) {
orders.add(this.getOrder(id));
}
return orders;
}
}

package com.gpcoder.interceptor;

import java.io.IOException;

import com.gpcoder.helper.FeignClientCreator;
import com.gpcoder.service.AuthService;

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

public class AuthInterceptor implements Interceptor {

private static String token = null;

@Override
public Response intercept(Chain chain) throws IOException {
/*
* chain.request() returns original request that you can work with(modify,
* rewrite)
*/
Request originalRequest = chain.request();

// Here we can rewrite the request
// We add an Authorization header if the request is not an authorize request and already had a token
Request authRequest = originalRequest;
if (!originalRequest.url().toString().contains("/auth") && getToken() != null) {
authRequest = originalRequest.newBuilder()
.header("Authorization", "Bearer " + getToken())
.build();
}

/*
* chain.proceed(request) is the call which will initiate the HTTP work. This
* call invokes the request and returns the response as per the request.
*/
Response response = chain.proceed(authRequest);

// Here we can rewrite/modify the response

return response;
}

private String getToken() throws IOException {
if (token != null) {
return token;
}

// Create an implementation of the API endpoints defined by the service interface
AuthService authService = FeignClientCreator.getService(AuthService.class);

// Sends a request to a webserver and return its response
return authService.getToken("gpcoder", "gpcoder");
}
}

package com.gpcoder.interceptor;

import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

public class LoggingInterceptor implements Interceptor {
@Override
public Response intercept(Interceptor.Chain chain) throws IOException {
Request request = chain.request();

long t1 = System.nanoTime();
System.out.println(
String.format("Sending request %s on %s%n%s", request.url(), chain.connection(), request.headers()));

Response response = chain.proceed(request);

long t2 = System.nanoTime();
System.out.println(String.format("Received response for %s in %.1fms%n%s", response.request().url(),
(t2 - t1) / 1e6d, response.headers()));

return response;
}
}

package com.gpcoder.helper;

import com.gpcoder.interceptor.AuthInterceptor;
import com.gpcoder.interceptor.LoggingInterceptor;
import com.gpcoder.service.OrderService;

import feign.Feign;
import feign.Logger;
import feign.form.FormEncoder;
import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;
import feign.okhttp.OkHttpClient;
import feign.slf4j.Slf4jLogger;

public class FeignClientCreator {

public static final String BASE_URL = "http://localhost:8080/RestfulWebServiceExample/rest/";

public static  T getService(Class clazz) {
okhttp3.OkHttpClient okHttpClient = new okhttp3.OkHttpClient.Builder()
.addInterceptor(new LoggingInterceptor())
.addInterceptor(new AuthInterceptor())
.addNetworkInterceptor(new LoggingInterceptor())
.build();

OkHttpClient feignOkHttp = new OkHttpClient(okHttpClient);

return Feign.builder()
.client(feignOkHttp)
.encoder(new FormEncoder(new GsonEncoder()))
.decoder(new GsonDecoder())
.logger(new Slf4jLogger(clazz))
.logLevel(Logger.Level.FULL)
.target(clazz, BASE_URL);
}
}

package com.gpcoder;

import java.io.IOException;

import com.gpcoder.helper.FeignClientCreator;
import com.gpcoder.model.Order;
import com.gpcoder.service.OrderService;

public class FeignClientExample {

private static OrderService orderService;

public static void main(String[] args) throws IOException {
orderService = FeignClientCreator.getOrderService(OrderService.class);

createOrder();
retrieveOrder();
updateOrder();
deleteOrder();
retrieveOrders();
}

/**
* @POST http://localhost:8080/RestfulWebServiceExample/rest/orders
*/
private static void createOrder() throws IOException {
System.out.println("createOrder: " + orderService.createOrder(new Order()));
}

/**
* @GET http://localhost:8080/RestfulWebServiceExample/rest/orders/1
*/
private static void retrieveOrder() throws IOException {
System.out.println("retrieveOrder: " + orderService.getOrder(1));
}

/**
* @PUT http://localhost:8080/RestfulWebServiceExample/rest/orders
*/
private static void updateOrder() throws IOException {
System.out.println("updateOrder: " + orderService.updateOrder(new Order()));
}

/**
* @DELETE http://localhost:8080/RestfulWebServiceExample/rest/orders/1
*/
private static void deleteOrder() throws IOException {
System.out.println("deleteOrder: " + orderService.deleteOrder(1));
}

private static void retrieveOrders() {
System.out.println("retrieveOrders: " + orderService.getOrders(1, 2));
}
}