Making HTTP GET Requests with Query Parameters in Spring Boot

In Spring Boot, making HTTP GET requests with query parameters is a common requirement when interacting with external APIs or retrieving data from a server. Query parameters allow us to pass additional information to the server to customize the requested data. This tutorial will guide you through the process of making HTTP GET requests with query parameters in a Spring Boot application.

Here's an example code snippet that demonstrates how to make an HTTP GET request to a target URL with query parameters in Spring Boot:

RestTemplate restTemplate = new RestTemplate();

String targetUrl = "";

UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(targetUrl).queryParam("param1", "value1").queryParam("param2", "value2");

HttpHeaders headers = new HttpHeaders();
headers.set("Accept", MediaType.APPLICATION_JSON_VALUE);
HttpEntity httpEntity = new HttpEntity<>(headers);

ResponseEntity response =, HttpMethod.GET, httpEntity, MyResponse.class);

if (response.getStatusCode().is2xxSuccessful()) {
   // success
   MyResponse myResponse = response.getBody();
} else {
   // fail

In this example, we are using RestTemplate class from org.springframework.web.client package of Springframework to make an HTTP GET request. It is a client-side HTTP communication library that simplifies the process of making HTTP requests and handling responses from external services or APIs. RestTemplate offers a variety of methods to perform different types of HTTP operations, such as GET, POST, PUT, DELETE, etc. It handles the low-level details of creating and managing HTTP connections, serializing and deserializing request and response bodies, handling request headers, and processing response status codes.

Here's is an explanation of the above code:

  1. The example code starts by creating an instance of the RestTemplate class, which is a tool provided by the Spring framework for making HTTP requests.
  2. We define the target URL of the API endpoint we want to send the request to. In this case, the URL is set to "".
  3. We use UriComponentsBuilder to build the complete URL with query parameters. We add query parameters such as param1 and param2 to the target URL using the queryParam() method.
  4. We create an instance of HttpHeaders, which is used to set headers for the HTTP request. In this code, we set the "Accept" header to indicate that we expect the API to respond with JSON data.
  5. We create an HttpEntity object, which represents the complete request, including the headers. We pass the headers object to the HttpEntity constructor.
  6. Using the RestTemplate instance exchange method, we send an HTTP GET request to the complete URL obtained from builder.toUriString(). We also provide the httpEntity object (containing the headers) and specify that we expect the response to be of type MyResponse (another custom class).
  7. After sending the request to the API, we need to check the response's status code to determine if the request was successful. The getStatusCode() method retrieves the status code from the response, and is2xxSuccessful() checks if the status code falls within the 2xx range (indicating success).
  8. If the response is successful, we enter the if block. Here, you can perform actions to handle the successful response. In this code, we retrieve the response body using response.getBody() and assign it to a variable called myResponse. This variable will contain the data sent back by the API, which should correspond to the structure defined in the MyResponse class.
  9. If the response is not successful (i.e., it has a status code outside the 2xx range), we enter the else block. This is where you can handle the failed response, such as logging an error message or taking appropriate actions based on the error code or response content.

In summary, this code example uses RestTemplate to send an HTTP GET request to an API endpoint with query parameters and headers. It checks the response's status code to determine if the request was successful and handles the response accordingly, either by extracting the response body or handling the failure.