How you can Settle for and Produce JSON as a response in Spring Boot? Instance Tutorial

Hey everybody, welcome to the weblog put up. On this quick article, we’re going to take an in-depth take a look at how one can eat and produce JSON responses utilizing a broadly appreciated Java framework i.e. Spring Boot. As everyone knows Spring Boot is a framework designed to construct a safe internet software, microservice, REST API, and production-ready spring software. Trendy-day software offers in a considerable amount of information, which they share in JSON format. A JSON is a normal plain text-based illustration of structured information. It is without doubt one of the well-liked codecs for information transmission over the web. Attributable to its user-friendly syntax and light-weight, it helps within the course of sooner. 

As we now have mentioned above, JSON is broadly processed over the community for sharing information between two nodes (ends). Therefore Internet companies and REST API desire information communication both in JSON or XML-based format.

package deal com.javarevisited.gettingstarted;



import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;



import java.io.IOException;



@SpringBootApplication

public class GettingStarted {

    public static void predominant(String[] args) throws IOException {

        SpringApplication.run(GettingStarted.class, args);

    }

}

package deal com.javarevisited.gettingstarted.mannequin;



import jakarta.persistence.Entity;

import jakarta.persistence.GeneratedValue;

import jakarta.persistence.GenerationType;

import jakarta.persistence.Id;

import jakarta.validation.constraints.Max;

import jakarta.validation.constraints.Min;

import jakarta.validation.constraints.NotNull;

import java.sql.Date;



public class Stadium {





@Id

    @GeneratedValue(technique = GenerationType.AUTO)

    personal int stadium_id;





    @NotNull(message = "Stadium identify is required")

    personal String identify;



    @Min(message = "Stadium ought to meet the min capability", worth = 50)

    @Max(worth = 100000, message = "Stadium ought to meet the max capability")

    personal String capability;

   



@NotNull(message = "Stadium should belongs to a rustic")

    personal String nation;

   



personal String constructedInYear;

    personal Date lastRennovation;



    public int getStadium_id() {

        return stadium_id;

    }

    public void setStadium_id(int stadium_id) {

        this.stadium_id = stadium_id;

    }

   



public String getName() {

        return identify;

    }



    public void setName(String identify) {

        this.identify = identify;

    }



    public String getCapacity() {

        return capability;

    }



    public void setCapacity(String capability) {

        this.capability = capability;

    }



    public String getCountry() {

        return nation;

    }



    public void setCountry(String nation) {

        this.nation = nation;

    }



    public String getConstructedInYear() {

        return constructedInYear;

    }



    public void setConstructedInYear(String constructedInYear) {

        this.constructedInYear = constructedInYear;

    }



    public Date getLastRennovation() {

        return lastRennovation;

    }



    public void setLastRennovation(Date lastRennovation) {

        this.lastRennovation = lastRennovation;

    }



    @Override

    public String toString() {

        return this.identify + " stadium has a complete capability of "
  + this.capability + " seats and was  constructed in yr " 
+ this.constructedInYear + " and was final renovated on date                                       " + this.lastRennovation;

    }

}

package deal com.javarevisited.gettingstarted.repo;



import com.javarevisited.gettingstarted.mannequin.Stadium;

import org.springframework.information.jpa.repository.JpaRepository;



import java.util.Listing;



public interface StadiumRepo extends JpaRepository<Stadium, Integer> {



}

package deal com.javarevisited.gettingstarted.controller;



import com.javarevisited.gettingstarted.mannequin.Stadium;

import com.javarevisited.gettingstarted.repo.StadiumRepo;

import jakarta.persistence.EntityNotFoundException;

import jakarta.validation.Legitimate;

import org.springframework.beans.manufacturing unit.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.internet.ErrorResponse;

import org.springframework.internet.bind.MethodArgumentNotValidException;

import org.springframework.internet.bind.annotation.*;

import java.util.HashMap;

import java.util.Listing;

import java.util.Map;

import java.util.Elective;





@RestController

@RequestMapping("/api/v1/stadiums")

public class StadiumController {





@Autowired

StadiumRepo stadiumRepo;



 



@RequestMapping(worth = "/", methodology = RequestMethod.GET)

public ResponseEntity<Listing<Stadium>> getAllStadiums(){

    return new ResponseEntity<>(stadiumRepo.findAll(), HttpStatus.OK);

}





   

    @PostMapping(

    worth = "/",

    consumes = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},

    produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})

    public ResponseEntity<Stadium> postNewStadium(@Legitimate @RequestBody Stadium stadium){

        return new ResponseEntity<Stadium>(stadiumRepo.save(stadium), HttpStatus.OK);

    }

}

Consuming JSON information

The above point out endpoint will eat APPLICATION_JSON_VALUE because the media sort. Spring Boot helps varied media sorts. Utilizing it one can tweak their software enter conduct. So as to attain the Spring Boot REST API straight, we now have to supply a JSON-encoded object that has all of the required arguments that match the Stadium entity.

consumes = {MediaType.APPLICATION_JSON_VALUE}
@RequestBody Stadium stadium

Under is the pattern information we are going to ship to our relaxation api.

{



"stadium_id": 5,



"identify": "Pallekele Worldwide Cricket Stadium",



"capability": "35000",



"nation": "SriLanka",



"constructedInYear": "2005",



"lastRennovation": "2022-08-28"



}

Consuming JSON information is straightforward and simple utilizing Spring Boot. Now let’s see how one can return JSON response utilizing Spring Boot.

Producing JSON information

It’s to notice right here that, Spring Boot by default has Jackson dependency as a part of spring-boot-starter-json. @RestController annotation on high of any Spring Boot class by default render JSON response so long as Jackson is residing within the classpath.

@RequestMapping(
worth = "/",
methodology = RequestMethod.GET,
produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE}
)
public ResponseEntity<Listing<Stadium>> getAllStadiums(){
        return new ResponseEntity<>(stadiumRepo.findAll(), HttpStatus.OK);
}

In our case, a response shall be serialized by the Jackson2 library first after which serves as a JSON object to the consumer.

Under is the response after making a GET request to

GET: http:{host_name}:{port_name}/api/v1/stadiums/

[

  {

    "stadium_id": 3,

    "name": "Lords Cricket Stadium",

    "capacity": "40000",

    "country": "England",

    "constructedInYear": "1890",

    "lastRennovation": "2013-02-17"

  },

  {

    "stadium_id": 5,

    "name": "Pallekele International Cricket Stadium",

    "capacity": "35000",

    "country": "SriLanka",

    "constructedInYear": "2005",

    "lastRennovation": "2022-08-28"

  }

]

Are you involved about, how this conversion passed off? with out explicitly parsing the stadium’s POJO class into JSON. The reply to your query is there isn’t a have to carry out an specific json conversion as a result of you might have annotated with @RestController. Simply return a POJO, and the Jackson serializer will deal with the JSON conversion by itself.

When used along with @Controller, it’s the similar as utilizing ResponseBody.

We use @RestController instead of the usual @Controller, and @ResponseBody is routinely utilized to all sources in that controller relatively than having to position it on every controller operate.

Modifying Jackson ObjectMapper

To deal with request and response physique conversion, Spring boot routinely configures mapping Jackson2HttpMessageConverter as one of many default converters. Utilizing property information or distinctive bean definitions, we might alter the default conversion conduct. 

 Property Customization

spring.jackson.date-format= specify date format right here, `yyyy-MM-dd HH:mm:ss`.



spring.jackson.default-property-inclusion= specify inclusion of properties right here.



spring.jackson.deserialization.*= on/off options for deserialization.



spring.jackson.locale= Locale used for formatting.



spring.jackson.mapper.*= Jackson common objective on/off options.



spring.jackson.parser.*= Jackson on/off options for parsers.



spring.jackson.property-naming-strategy= 



spring.jackson.time-zone= Specify time zone right here.



spring.jackson.visibility.*= Put restrict on strategies (and fields) for auto-detected.

Customization utilizing Bean

@Configuration
public class WebConfig
{
    @Bean
    public Jackson2ObjectMapperBuilder customJson() {
        return new Jackson2ObjectMapperBuilder()
            .indentOutput(true)
            .serializationInclusion(JsonInclude.Embrace.NON_NULL)
            .propertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
    }
}

 Conclusion

That is all about how one can settle for and produ e JSON response in Spring Boot software. With this, we attain the top of our quick article. Right here we now have realized, how Spring Boot consumes and produces JSON information and the underlying mechanism behind this conversion. Along with it, the article put some gentle on how one can customise the default conduct of Jackson2ObjectMapper.