Spring Rest Interview Questions

Top 15 Spring Rest Interview Questions every developer should know

int a = 4; //is idempotent
a++; //is not idempotent

public String getStudentDetails(
 @RequestParam(value="param1", required=true) String param1,
        @RequestParam(value="param2", required=false) String param2){
...
}

@RequestMapping("/students/{id}")
public String getStudentDetails(@PathVariable(value="id") String id){

...
}

8. How to validate the input data in Spring Rest?

Most of the time we need to create the validations on input model of the rest. To customize the validation, we will use Hibernate Validator, which is one of the implementations of the bean validation API. Refer below URL is know more about it :
https://www.onlyfullstack.com/spring-rest-input-validations/

9. How to document the Rest API?How you share the Rest API documentation?

Swagger UI allows to visualize and interact with the API’s resources without having any of the implementation logic in place. It’s automatically generated from your OpenAPI (formerly known as Swagger) Specification, with the visual documentation making it easy for back end implementation and client side consumption.
The Swagger 2 specification, which is known as OpenAPI specification, has several implementations. Currently, Springfox that has replaced Swagger-SpringMVC (Swagger 1.2 and older) is popular for Spring Boot applications. Springfox supports both Swagger 1.2 and 2.0.
To know more about Spring swagger – Rest API documentation : 
https://www.onlyfullstack.com/rest-documentation-swagger-2/

10. What is REST versioning?How to implement versioning Spring Rest?

Make the API Version mandatory and do not release an unversioned API. There are 4 techniques to version your API and you can choose as per your convenience.
Different types of Spring Rest Versioning ?

Refer below link to know more about each strategy and its pros and cons:
https://www.onlyfullstack.com/spring-rest-versioning/

11. How to implement the asynchronous Rest endpoint?

We can send the immediate response to the client and defer the execution later on the server. In this approach we speed up the server and client interaction and executes the remaining processing in an asynchronous way where a new thread is created to handle the execution.
With Asynchronous code we defer the execution part in another thread and close the incoming HTTP rest connection by responding back.
We can implement the asynchronous implementation with @Async annotation.
Refer below link to know more :
https://www.onlyfullstack.com/asynchronous-processing-in-spring/

12. What is the need of @ResponseBody?

@ResponseBody means that the controller’s return value should be used as the body of the response. That is, the HTTP response should be whatever is stated in the return value in the format specified by the Produces variable(JSON ? XML). Without the annotation, Spring would try to use the find the template with view resolver to render the view.

@GetMapping(value = "/connections", produces = {MediaType.APPLICATION_JSON_VALUE.                                       , MediaType.APPLICATION_ATOM_XML_VALUE})
public @ResponseBody FinalResponse getDataBaseConnectionDetails() {

return new FinalResponse(configServer.setup(), mailSettings);
}

13. How does @ResponseBody Works ?

On the other end, you have a RESTful architecture. In this case, there is no View. The Controller only sends back the model (or resource representation, in more RESTful terms). The client can be a JavaScript application, a Java server application, any application in which we expose our REST API to. With this architecture, the client decides what to do with this model. Take for instance Twitter. Twitter as the Web (REST) API, that allows our applications to use its API to get such things as status updates, so that we can use it to put that data in our application. That data will come in some format like JSON.

Depending on your configuration, spring has a list of HttpMessageConverters registered in the background. A HttpMessageConverters responsibility is to convert the request body to a specific class and back to the response body again, depending on a predefined mime type. Every time an issued request is hitting a @RequestBody or @ResponseBody annotation spring loops through all registered HttpMessageConverters seeking for the first that fits the given mime type and class and then uses it for the actual conversion.

14. How to change the response type dynamically in Spring Rest?How to write a web service which returns json and xml as response?

@GetMapping(value= "/connections", produces = { MediaType.APPLICATION_JSON_VALUE                                        , MediaType.APPLICATION_ATOM_XML_VALUE})
public @ResponseBody FinalResponse getDataBaseConnectionDetails() {

return new FinalResponse(configServer.setup(), mailSettings);
}

Spring supports a couple of conventions for selecting the format required: URL suffixes and/or a URL parameter. These work alongside the use of Accept headers. As a result, the content-type can be requested in any of three ways. By default they are checked in this order:
Ways to change the response type dynamically
1. Path Extension
Add a path extension (suffix) in the URL. So, if the incoming URL is something like http://localhost:8080/connections.json then the spring will return the response in JSON format. http://localhost:8080/connections.json then the spring will return the response in XML format.

2. URL parameter 
like this: http://myserver/myapp/accounts/list?format=xls. The name of the parameter is format by default, but this may be changed. Using a parameter is disabled by default, but when enabled, it is checked second.
http://localhost:8080/connections?format=json then the spring will return the response in JSON format.
http://localhost:8080/connections.json?format=xml then the spring will return the response in XML format.

3. Accept HTTP Header
Finally the Accept HTTP header property is checked. If Spring finds any Accept in header then it will convert the response accordingly.
Accept: application/json – the spring will return the response in JSON format.

@RequestMapping(value = "/matches/{matchId}", produces = "application/json")
public String match(@PathVariable String matchId, @RequestBody String body,
            HttpServletRequest request, HttpServletResponse response) {
    String json = matchService.getMatchJson(matchId);
    if (json == null) {
        response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
    }
    return json;
}

@RequestMapping(value = "/sth")
@ResponseStatus(HttpStatus.OK)
public void name(HttpServletResponse response) throws Exception{
    boolean lever = service.doSomethingAndReturnTrueIfSucceedOrFalseIfNot();
    if(!lever){

throw new SomethingWentWrongCustomException("Not okay..");
     }
}

@ControllerAdvice
public class SomethingControllerAdvice{
    @ExceptionHandler(value = SomethingWentWrongCustomException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public void someName(){
    }
}

@RequestMapping(value="/customer/{id}" ,headers = "Accept=application/json","application/xml")
public ResponseEntity<Customer> getCustomerById(@PathVariable String id)
{
    Customer customer;
    try
    {
        customer = customerService.getCustomerDetail(id);

    }
    catch (CustomerNotFoundException e)
    {
        return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);

    }
    return new ResponseEntity<Customer>(customer,HttpStatus.OK);
}