richard mille replica
Together these kind of watches are called your "Dirty Dozen" by simply army view enthusiasts and amassing among just about richard mille replica all 14 is difficult as a few have been merely manufactured in modest numbers.
Optis | Our Blog

Feign is a framework developed by Netflix that lets you bind your Java to a HTTP client very quick and easy.

As stated on the OpenFeign Github page: Feign 10.x and above are built on Java 8 and should work on Java 9, 10, and 11. If you require JDK 6 compatibility, please use Feign 9.x

We will use the latest version of Feign's okhttp module and gson module to create a simple application for querying reservations.

Source code for the backend providing the mock data can be found here.

After cloning you can run it with mvn clean spring-boot:run

Getting started

Let's start by creating a new Maven project called my-app.

Afterwards we'll add the following dependencies to the pom.xml


If we go to http://localhost:8080/api/reservations or use curl in the terminal, you'll see that the data is served as seen below:


We'll continue with creating the model to hold the data that is queried from the api.

public class Reservation {
 private long reservationNumber;
 private LocalDate dateOfReservation;
 private LocalTime timeOfReservation;
 private int amountOfPeople;
 public Reservation(){}

Make sure to include the default constructor, because it is necessary for a JSON parser.

Transforming the data

Since the data we'll be receiving consists out of strings and integers, we'll need a DTO and a resource transformer to make the data fit the model.


Our DTO will look nearly identical to the model, except for the dateOfReservation and timeOfReservation types.

public class ReservationDto {
 private long reservationNumber;
 private String dateOfReservation;
 private String timeOfReservation;
 private int amountOfPeople;
 public ReservationDto() {

Resource transformer

Our resource transformer will have 2 methods: transformDtoToReservation and transformDtosToReservations.

public class ResourceTransformer {
 public static Reservation transformDtoToReservation(ReservationDto reservationDto) {
 Reservation reservation = new Reservation();
 return reservation;
 public static List<Reservation> transformDtosToReservations(List<ReservationDto> reservationDtos) {
 List<Reservation> result = new ArrayList<>();
 for (ReservationDto reservationDto : reservationDtos) {
 return result;

transformDtoToReservation will accept a DTO and transform it to a Reservation object (as the name says). Effectively parsing the LocalDate and LocalTime.

transformDtosToReservations uses the previously stated method in a loop to transform a list of DTOs to a list of Reservations.

  • NOTE: You don't always need a resource transformer, but in this example it is necessary because the client will not be able to automatically parse the strings to a LocalDate and LocalTime when fetching from the API.

Setting up the client

First we'll create the interface that will act as the client. Thanks to the @RequestLine annotation we can easily define the HTTP request method, along with the optional subpath and parameters with he @Param annotation .

public interface ReservationClient {
 List<ReservationDto> findAll();
 @RequestLine("GET /{reservationNumber}")
 ReservationDto findByReservationNumber(@Param("reservationNumber") long reservationNumber);
 @RequestLine("GET /filter?date={date}")
 List<ReservationDto> findAllByDateOfReservation(@Param("date") LocalDate date);
 @RequestLine("GET /filter?date={date}&time={time}")
 List<ReservationDto> findAllByDateAndTime(@Param("date") LocalDate date, @Param("time") LocalTime time);
 @Headers("Content-Type: application/json")
 void addReservation(ReservationDto reservation);
  • NOTE: Make sure your uri segment matches the required path of the API.

Next up, the client itself. The Feign.builder() is used to configure the interface-based client at runtime. It needs at least a decoder and a target, specifying the class of the interface and the base url of your API.

The decoder takes your entire JSON string and maps to your Java object(s).

The target requires your API type, I.E. your interface class, and your API base uri.

ReservationClient client = Feign.<em>builder</em>()
 .decoder(new GsonDecoder())
 .target(ReservationClient.class, "http://localhost:8080/api/reservations");

Et voilà! Your client is now setup!

Unit Test

Now let's write a little unit test for one of the methods we defined in the client interface to actually see the client do its work.

JUnit 5

We'll use the latest version of JUnit to test our sourcecode. To do this we need first to add the junit-jupiter-api and junit-jupiter-enginedepencencies to the pom.xml. And since we don't want to send requests to the actual api when writing a unit test, we'll use WireMock to mock our data.


Next we need to add the maven-surefire-plugin to the plugins section of the pom.xml . We need this version or higher in order to use JUnit 5, for more information visit the JUnit documentation.


Writing the test

Start by opening the MyAppTest class and create a setUp() method annotated by @BeforeEach so the client will be created when the testclass is instantiated.

We'll also create a setupStub() method, in which we will what data the mock server should return. This method will be called from within the setUp() method.

Each test must also be annotated with @Test and its signature must start with test.

public class MyAppTest
 private ReservationClient client;
 WireMockServer wireMockServer;
 public void setUp() throws Exception {
 wireMockServer = new WireMockServer(8089);
 this.client = Feign.<em>builder</em>()
 .decoder(new GsonDecoder())
 .target(ReservationClient.class, "http://localhost:8089/api/reservations");
 private void setupStub(){
 .willReturn(<em>aResponse</em>().withHeader("Content-Type", "application/json")
 public void testFindAll(){
 List<Reservation> reservations = ResourceTransformer.<em>transformDtosToReservations</em>(client.findAll());
 <em>assertEquals</em>(3, reservations.size());

If all goes well, your unit test should succeed and you now have proof of a working Feign implementation!


Feign allows you to easily connect your code to HTTP APIs with minimal overhead. It is very user friendly and is set up very fast.

You can find the code for the API and the app we just build on our GitHub.

buy the highest quality swiss replica watches. the most rapid logistics and the highest quality service.

Deze website maakt gebruik van cookies om ervoor te zorgen dat u de beste surfervaring op onze website krijgt. Meer info