How To Accept Json Object Fom Restful Web Service

Then far, I have not written much nearly Residue and RESTful spider web service, barring some interview questions like REST vs. Lather, which is thankfully very much appreciated by my readers, and some general suggestions about the best books to learn Residue in the by. Today I am going to write something near how to swallow JSON from a RESTful Web Service in Coffee using Bound Framework. I will also talk about how to convert the JSON to Java objects using Jackson. You will besides acquire about the RESTTemplate class from the Jump MVC framework, and how y'all can utilize information technology to create a REST client in Java in just a few lines of code.

Similar to its predecessors JdbcTemplate and JmsTemplate, the RestTemplate is another useful utility class that allows you lot to interact with RESTful web services from a Java application congenital using the Spring framework.

It's feature-rich and supports almost all REST methods like the GET, Mail, HEAD, PUT or DELETE, though we'll only employ the Go method in this article to eat a RESTful Spider web Service and convert the JSON response to Java objects. Information technology'southward one of the bones just interesting examples given yous will ofttimes find scenarios to eat a RESTful web service from a Coffee program.

I am also using Spring Kick to run my program as a master() method instead of edifice a WAR file and deploying it in Tomcat and so writing Servlet and JSP to demonstrate the example.

I really discover the convenience offered past Spring boot great as it embeds the Tomcat servlet container every bit the HTTP runtime, which is enough to run this program. If want to learn more well-nigh Leap Boot and REST APIs, I as well advise you check outPrimary RESTful API with Spring Boot course past young man blogger and Java architecture Ranga Karnam on Udemy. It's a keen grade to learn both Leap Kicking and Balance API development in Java.

Free RESTful Spider web Services on the Internet for Testing

To create a RESTful customer, you demand to accept a RESTful web service that tin provide JSON content you want to consume. Though you can develop a RESTful client in the Bound framework itself, for the testing purpose, it's better to use the existing costless RESTful web service on the internet.

Spring Boot + JSON + RestTemplate Example in Java

For example, http://jsonplaceholder.typicode.com has several useful RESTful APIs to return comments and posts related data similar http://jsonplaceholder.typicode.com/posts/1 will return post data with id= 1, which looks something like this:

{            "userId": 1,            "Id": 1,            "Title":            "a title "            "Body"            :            "the body of the content"            }

Though, I have used another free RESTful spider web service which returns the State'due south proper noun and their two and three-alphabetic character ISO codes as shown below:

{              "RestResponse"              : {              "messages"              : [              "More webservices are available at       http://www.groupkt.com/post/f2129b88/services.htm",                              "Country found matching code [IN]."              ],              "result"              : {              "name"              :              "India",              "alpha2_code"              :              "IN",              "alpha3_code"              :              "IND"              }   } }

Yous tin can apply any of these web services to build a RESTful client for testing. Though your domain class will change depending upon which RESTful spider web service you are consuming.

Here is the screenshot of this RESTful web service response in my browser:

Free RESTFul Web Services for Testing on Internet

Btw, I am expecting that you lot are familiar with the Jump framework here, particularly how to configure Jump, dependencies, and in general core Spring concepts like DI and IOC. If you are not then I suggest you offset become throughSpring Framework v: Beginner to Guru course to learn them. Information technology's not mandatory but it volition help you to utilize Leap better.

how to create REST client in Java using Spring

Java Program to consume JSON from RESTful WebService using Spring RestTemplate

Here is our complete Java programme to swallow a RESTful Web Service using the Leap framework and RestTemplate class. This program has 4 Coffee files:App.coffee, Response.coffee, RestResponse.coffee, and Outcome.coffee. The first class is the primary class which drives this application and others are classes respective to JSON response nosotros become from this RESTful API.

App.coffee

This is our principal class, which drives this RESTful Spring application. It uses Jump boot to set up and run the program. The grade App implements CommandLineRunner and calls the SpringApplication.run() method past passing this instance of class App.class. This will, in turn, telephone call the run method, where we accept lawmaking to phone call a RESTful Web Service and consume JSON response using RestTemplate form of Spring framework.

Merely like its predecessor or close cousins similarJmsTemplate and JdbcTemplate, the RestTemplate class likewise does everything for you. All you need to tell is the proper noun of the class yous want to map the incoming JSON response.

We have get-go created an instance of RestTemplate course and then called the getForObject() method. This accepts two parameters. First, a String URL to call the RESTful Spider web Service, and 2d, the name of the grade should return with the response. So, in just 1 line of code, it calls the RESTful spider web service, parses the JSON response, and returns the Java object to you.

If y'all are curious to learn more about the RestTemplate class, and then you can also join a course like RESTful Web Services, Java, Spring Kick, Bound MVC, and JPA class on Udemy, which covers all the things you should know about REST support in Leap. If you prefer a book, you tin also read the Leap Residual book. It explains all nitty-gritty of developing RESTful spider web services in the Bound framework.

Anyway, here are the Java classes required to call a RESTful Web Service from Java Program using Spring and RestTemplate utility:

package rest;            import            org.slf4j.Logger;            import            org.slf4j.LoggerFactory;            import            org.springframework.kicking.CommandLineRunner;            import            org.springframework.boot.SpringApplication;            import            org.springframework.spider web.client.RestTemplate;            public            grade            App            implements            CommandLineRunner {            private            static            final Logger            log            =            LoggerFactory.getLogger(App.class);            public            static            void            principal(String            args[]) {     SpringApplication.run(App.class);   }            public            void            run(Cord... args) throws Exception {     RestTemplate restTemplate            =            new            RestTemplate();     Response            response            =            restTemplate.getForObject(            "http://services.groupkt.com/country/become/iso2code/IN",               Response.class);            log.info("==== RESTful API Response using Spring      RESTTemplate START =======");            log.info(response.toString());            log.info("==== RESTful API Response using Spring RESTTemplate END =======");   } }

Response.java

This is the top-level course to convert JSON response to Java object you receive by consuming the RESTful spider web service response. I accept used@JSonProperty to annotate the RestResponse field to tell Jackson that this is the key field in the JSON certificate.

package remainder;            import            com.fasterxml.jackson.annotation.JsonProperty;            public            grade            Response            {    @JsonProperty            private            RestResponse RestResponse;            public            RestResponse getRestResponse() {            return            RestResponse;   }            public            void            setRestResponse(RestResponse restResponse) {     RestResponse            =            restResponse;   }            public            Response(){        }    @Override            public            Cord            toString() {            return            "Response [RestResponse="            +            RestResponse            +            "]";   }  }

RestResponse.java

This class contains two fields respective to theRestResponse section of the JSON response nosotros received from the RESTful Spider web service. The kickoff field is a String array, messages, and Jackson volition parse the JSON array to the String array and store the output for that property in this field.

The second field, the consequence, is again a custom-type Coffee object to store the information nosotros need, I mean, name and ISO code of the Country.

package residual;            import            java.util.Arrays;            import            com.fasterxml.jackson.annotation.JsonIgnoreProperties;            public            class            RestResponse            {            private            Cord[] letters;            individual            Result            event;            public            RestResponse(){       }            public            String[] getMessages() {            return            messages;   }            public            void            setMessages(String[] messages) {            this.messages            =            letters;   }            public            Upshot getResult() {            return            upshot;   }            public            void            setResult(Result            issue) {            this.event            =            result;   }    @Override            public            String            toString() {            return            "RestResponse [messages="            +            Arrays.toString(messages)                          +            ", result="            +            event            +            "]";   }   }

Result.coffee

This class has 3 fields, respective to iii properties for the upshot section in the JSON response. All 3 fields are String. Kickoff, the name is the name of the State, 2d, alpha2_code is the ii-digit ISO code for the Country, and third, alpha3_code is the three-digit ISO code of the Country.

package rest;            import            com.fasterxml.jackson.annotation.JsonIgnoreProperties;  @JsonIgnoreProperties(ignoreUnknown            =            true)            public            class            Upshot            {            private            String            proper name;            private            String            alpha2_code;            private            String            alpah3_code;            public            Result() {    }            public            String            getName() {            render            proper name;   }            public            void            setName(String            proper noun) {            this.proper noun            =            proper name;   }            public            Cord            getAlpha2_code() {            render            alpha2_code;   }            public            void            setAlpha2_code(String            alpha2_code) {            this.alpha2_code            =            alpha2_code;   }            public            String            getAlpah3_code() {            return            alpah3_code;   }            public            void            setAlpah3_code(Cord            alpah3_code) {            this.alpah3_code            =            alpah3_code;   }    @Override            public            String            toString() {            return            "Outcome [name="            +            name            +            ", alpha2_code="            +            alpha2_code            +            ", alpah3_code="            +            alpah3_code            +            "]";   }  }

Here is how our project setup looks like in Eclipse IDE, you can run across all the classes forth with Maven dependencies and JARs:

How to Consume JSON from RESTful Web Service and Convert to Java Object

Maven dependencies:

Here are the Maven dependencies used by this Spring boot application to telephone call the RESTful Spider web Services:

            <dependencies>            <dependency>            <groupId>junit</groupId>            <artifactId>junit</artifactId>            <version>iii.eight.1</version>            <scope>test</scope>            </dependency>            <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-kick-starter</artifactId>            <version>1.ii.7.RELEASE</version>            </dependency>            <dependency>            <groupId>com.fasterxml.jackson.cadre</groupId>            <artifactId>jackson-databind</artifactId>            <version>2.2.3</version>            </dependency>            <dependency>            <groupId>org.springframework</groupId>            <artifactId>leap-web</artifactId>            <version>4.0.0.RELEASE</version>            </dependency>            </dependencies>

JARs

Hither is the list of JAR files used by this application, I take directly copied information technology from Maven Dependencies referenced in Eclipse.

C:\.m2\org\springframework\kicking\spring-boot-starter\1.2.7.RELEASE\spring-kicking-starter-1.2.7.RELEASE.jar
C:\.m2\org\springframework\boot\spring-boot\1.2.7.RELEASE\jump-kick-1.ii.7.RELEASE.jar
C:\.m2\org\springframework\boot\spring-kick-autoconfigure\i.2.seven.RELEASE\spring-kick-autoconfigure-1.2.7.RELEASE.jar
C:\.m2\org\springframework\boot\spring-boot-starter-logging\one.2.vii.RELEASE\jump-boot-starter-logging-1.2.7.RELEASE.jar
C:\.m2\org\slf4j\jcl-over-slf4j\1.7.12\jcl-over-slf4j-one.7.12.jar
C:\.m2\org\slf4j\slf4j-api\ane.vii.12\slf4j-api-1.seven.12.jar
C:\.m2\org\slf4j\jul-to-slf4j\i.7.12\jul-to-slf4j-one.7.12.jar
C:\.m2\org\slf4j\log4j-over-slf4j\i.seven.12\log4j-over-slf4j-i.7.12.jar
C:\.m2\ch\qos\logback\logback-classic\1.i.three\logback-classic-1.one.3.jar
C:\.m2\ch\qos\logback\logback-cadre\ane.1.iii\logback-core-1.i.3.jar
C:\.m2\org\springframework\jump-core\4.one.viii.RELEASE\jump-cadre-4.i.8.RELEASE.jar
C:\.m2\org\yaml\snakeyaml\1.14\snakeyaml-1.fourteen.jar
C:\.m2\com\fasterxml\jackson\cadre\jackson-databind\2.2.3\jackson-databind-2.2.3.jar
C:\.m2\com\fasterxml\jackson\core\jackson-annotations\2.ii.3\jackson-annotations-2.2.3.jar
C:\.m2\com\fasterxml\jackson\core\jackson-core\2.2.3\jackson-cadre-2.ii.three.jar
C:\.m2\org\springframework\leap-web\four.0.0.RELEASE\leap-web-4.0.0.RELEASE.jar
C:\.m2\aopalliance\aopalliance\1.0\aopalliance-ane.0.jar
C:\.m2\org\springframework\spring-aop\4.0.0.RELEASE\spring-aop-4.0.0.RELEASE.jar
C:\.m2\org\springframework\spring-beans\4.0.0.RELEASE\spring-beans-4.0.0.RELEASE.jar
C:\.m2\org\springframework\jump-context\iv.0.0.RELEASE\spring-context-iv.0.0.RELEASE.jar
C:\.m2\org\springframework\leap-expression\4.0.0.RELEASE\bound-expression-4.0.0.RELEASE.jar

Here is the response, you will meet in Eclipse's panel when you run this program by correct-clicking on App form and choosing "Run as Java Application."

You can encounter that the response is correctly received and parsed from JSON to Java object by Jackson API automatically.

Btw, If you are someone who prefers training courses and coaching classes to books, and then you tin also check out Eugen'southwardREST with Spring course, information technology'due south currently one of the all-time courses to learn RESTful web services development using the Leap framework.

The form expects candidates to know Java and Spring. Hence, it's platonic for intermediate and experienced Java and Spider web developers.

Eugen has several options on his courses suited for unlike experience levels and needs like REST with Jump: The Intermediate class is good for essential knowledge while Remainder with Jump: The Masterclass is more than detail-oriented. Yous can check out all his class options here.

Important points

Here are a couple of essential points y'all should call back or learn by writing and running this Java program to call a RESTful Web service using Spring Kicking and RestTemplate

1. Since we are using the Jackson library in our CLASSPATH, RestTemplate class will use information technology (via a message converter like HttpMessageConverter to convert the incoming JSON response into a Result object.

2. We have used @JsonIgnoreProperties from the Jackson, a JSON processing library, to indicate that any properties not bound in any of the model classes like RestResponse or Event should exist ignored.

3. In order to directly bind your data from JSON response to your custom Java class, yous need to specify the field proper noun in the Java class precisely the same equally the key in the JSON response returned from the RESTful API.

iv. If field names in the Java class and key in JSON response are not matching, then y'all demand to use the @JsonProperty note to specify the exact key of the JSON document. You can see we accept used this notation to map the RestResponse key to theRestResponse field in our Response class.

4. Sometimes, when you run the application, and you see only nulls in the response, you lot can remove the@JsonIgnoreProperties to bank check what's happening behind the scene. In my case, the RestResponse field was not mapping correctly due to proper name mismatch, and that was revealed by the following exception when I removed the@JsonIgnoreProperties annotation. This is quite useful for debugging and troubleshooting.

Caused by: org.springframework.http.converter.HttpMessageNotReadableException: Could not read JSON: Unrecognized field "RestResponse" (class residue.instance.SpringJSONRestTest.Response), not marked as ignorable (ane known holding: "restResponse"])
at [Source: dominicus.internet.world wide web.protocol.http.HttpURLConnection$HttpInputStream@45af76e7; line: two, column: 21] (through reference chain: rest.example.SpringJSONRestTest.Response["RestResponse"]); nested exception is com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "RestResponse" (form rest.example.SpringJSONRestTest.Response), non marked as ignorable (one known belongings: "restResponse"])
at [Source: lord's day.net.world wide web.protocol.http.HttpURLConnection$HttpInputStream@45af76e7; line: ii, column: 21] (through reference chain: rest.example.SpringJSONRestTest.Response["RestResponse"])
at org.springframework.http.converter.json.MappingJackson2HttpMessageConverter.readJavaType(MappingJackson2HttpMessageConverter.java:185)
at org.springframework.http.converter.json.MappingJackson2HttpMessageConverter.read(MappingJackson2HttpMessageConverter.coffee:177)
at org.springframework.web.client.HttpMessageConverterExtractor.extractData(HttpMessageConverterExtractor.java:95)
at org.springframework.web.client.RestTemplate.doExecute(RestTemplate.java:535)
at org.springframework.spider web.client.RestTemplate.execute(RestTemplate.java:489)
at org.springframework.spider web.client.RestTemplate.getForObject(RestTemplate.java:226)
at rest.example.SpringJSONRestTest.App.run(App.java:20)
at org.springframework.boot.SpringApplication.runCommandLineRunners(SpringApplication.coffee:674)

5. When you use the Bound, you become the embedded Tomcat to run your Java application as a evidently old Java application by running the principal class. It uses Tomcat internally to brand the HTTP grade and parse HTTP response.

That's all nearly how to consume JSON data from a RESTful web service in Java using Bound'southward RestTemplate class. This grade is super useful and allows you to perform any Rest operations. In this example, we have but used RestTemplate to make an HTTP Become request, merely y'all tin also apply RestTemplate to execute HTTP Mail, PUT or DELETE method.

Other Java and Jump Articles you lot may like

15 Jump Kick Interview Questions for Coffee Developers (questions)
Top 5 Courses to Learn and Principal Spring Cloud (courses)
v Gratis Courses to Larn Spring Framework (free courses)
five Courses to Learn Bound Security (courses)
Pinnacle five Bound Kick Annotations Java Developers should know (read)
Elevation 5 Courses to larn Microservices in Coffee (courses)
@SpringBootApplication vs@EnableAutoConfiguration? (answer)
5 Spring Books Experienced Java Developer Should Read (books)
Top five Frameworks Java Programmer Should Know (frameworks)
10 Avant-garde Spring Kicking Courses for Coffee developers (courses)
ten Spring MVC annotations Java developer should learn (annotations)
5 Best React Spring Courses for Java developers (reactive spring courses)
Top 5 Spring Cloud annotations Java developer should learn (cloud)
5 Best Courses to learn Jump Cloud (courses)
Summit 5 Courses to learn Spring Data JPA (spring information jpa class)

Thanks a lot for reading this article so far. If you like this RESTful Web Service case with Leap Boot then delight share them with your friends and colleagues. If you have whatever questions or feedback and then please drop a note.

P. South. - If you lot desire to learn the Spring framework from scratch and looking for some free resources then yous can also check out this listing of free courses to learn Core Spring and Leap Boot online. It contains some free courses from Udemy, Pluralsight, and other online platforms.