Welcome to the second lesson in our journey of interacting with APIs using Java. In the previous lesson, we laid a strong foundation by understanding RESTful APIs and how HTTP requests facilitate interactions with them. We used curl to manually craft and send a GET request to an endpoint. Now, we are transitioning to automating this process using Java. This lesson introduces the HttpClient from the java.net.http package, which allows us to send HTTP requests effortlessly in our Java applications. Alongside, we'll use the Gson library for parsing JSON responses, making these tools invaluable in the realm of web development and API integration.

To make HTTP requests in Java, we leverage the HttpClient, which is part of the core java.net.http package starting from Java 11. For JSON parsing, we use the Gson library. To integrate these tools into your Java project, ensure your environment is set up properly.

1. Java Development Kit (JDK):

   • Ensure you have JDK version 11 or higher installed on your machine.

2. Gson Library:

   • Include Gson in your project by adding it to your pom.xml if you are using Maven:
   • Or if you are using gradle:

But you don't have to worry about that here, we've set it all up for you!

When interacting with an API, it's helpful to define a base URL for the service you're communicating with. This design choice makes your code more modular and easy to maintain, allowing you to change the root of your API URL in one place without modifying each request.

By setting this base URL, we can easily concatenate endpoints for different services within the API, making our code cleaner and more adaptable.

Let's dive into the process of fetching data from an API using Java's HttpClient. Our goal is to retrieve a list of to-do items from the /todos endpoint using the GET method.

By using the HttpClient, we send a GET request to the constructed full URL. The response from the server, stored in the variable response, is then printed, providing us with the raw response body as a string.

HTTP status codes are grouped into categories based on their first digit, providing insight into the outcome of the request:

• 2xx Success: These codes indicate that the request was successfully received, understood, and accepted. For example, a 200 status code signifies a successful interaction.

• 4xx Client Errors: These codes indicate that there was an error with the request, often due to incorrect syntax or missing information. For instance, a 400 status code means a bad request, while a 401 indicates unauthorized access.

• 5xx Server Errors: These codes indicate that the server encountered an error while processing the request. A 500 status code reflects an internal server error, suggesting the server faced an unexpected situation.

To determine the outcome of an HTTP request, we use the statusCode() method from the HttpResponse object to check the status code returned by the server. When the server responds with a status code of 200, it signifies a successful interaction. In such cases, we can confidently parse the body in the desired format, which is JSON in our case, using the Gson library.

First we define the Todo class as a POJO (Plain Old Java Object):

Then we parse the response with Gson:

To be able to deserialize JSON data into a Java object, Gson needs to know the expected Type of that object. For non-generic types, such as a Todo a simple Todo.class will suffice. For generic types, such as List<>, a TypeToken is required.

Errors can happen on either the client or server side, so it's important to handle them properly. A 400 status code means there was a mistake in the request, often due to incorrect syntax. We can print the response to understand the error and rectify it.

The JsonParser.parseString(...).getAsJsonObject() parses the response JSON string into a JsonObject which can be useful for accessing error data in a more structured manner.

A 401 status code indicates an unauthorized request, often due to missing or invalid credentials. This requires the user to address authentication problems to proceed.

When encountering a 404 status code, it means the requested resource is not found, often indicating an incorrect endpoint.

A 500 status code reflects an internal server error, indicating the server encountered an unexpected situation.

For responses falling outside the common codes, a generic approach captures these cases, ensuring all responses are analyzed for potential issues.

By handling these various status codes, we ensure robust API interactions and better understand the server's communication.

In this lesson, we've explored the powerful capability of Java's HttpClient to make GET requests to an API. We've seen how to retrieve and handle responses effectively, interpreting HTTP status codes to understand the server's communication. This knowledge is crucial for creating reliable interactions with APIs. As you move on to practice exercises, focus on experimenting with the code snippets and handling various status codes to solidify your understanding. In future lessons, we will build on this foundation, unlocking the potential to perform more complex tasks like updating and manipulating API data. Keep up the great work as you advance through the course!