Creați un serviciu Jersey REST foarte simplu și trimiteți date JSON de la clientul Java

Publicat: 2013-11-29

Exemplu de serviciu REST Crunchify

Recent, trebuie să transmit date JSON către Serviciul REST și nu am avut la îndemână niciun client simplu. Dar a creat un program Java foarte simplu care citește datele JSON din fișier și le trimite la serviciul REST.

Transferul de stat reprezentativ (REST) ​​a câștigat acceptarea pe scară largă pe web ca o alternativă mai simplă la serviciile web bazate pe SOAP și Web Services Description Language (WSDL). Dovada cheie a acestei schimbări în designul interfeței este adoptarea REST de către furnizorii de servicii web 2.0 de bază, inclusiv Yahoo, Google și Facebook, care au depreciat sau au transferat interfețele bazate pe SOAP și WSDL în favoarea unei interfețe mai ușor de utilizat, model orientat către resurse pentru a-și expune serviciile. În acest articol, Alex Rodriguez vă prezintă principiile de bază ale REST.

Să începem să codificăm asta:

  1. Creați serviciul web RESTFul
    • Fișier Java: CrunchifyRESTService.java
    • fișier web.xml
  2. Creați clientul RESTService
    1. Fișier CrunchifyRESTServiceClient.java

Un alt trebuie citit: Spring MVC Exemplu/Tutorial: Hello World – Spring MVC 3.2.1

Pasul 1

În Eclipse => File => New => Dynamic Web Project . Numiți-o drept „ CrunchifyTutorials ”. Tutorialul de mai jos funcționează și cu Tomcat 8 .

Creați un proiect web dinamic

Noul proiect web dinamic pentru RESTServiceClient- Crunchify

Pasul 2 Creați fișierul descriptor de implementare

Dacă nu vedeți web.xml (descriptor de implementare) sub WebContent\WEB-INF\ , urmați acești pași.

Deschideți web.xml și înlocuiți conținutul cu conținutul de mai jos:

web.xml file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<? xml version = "1.0" encoding = "UTF-8" ?>
< web - app xmlns = "http://java.sun.com/xml/ns/javaee" xmlns : xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi : schemaLocation = "http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version = "3.0" >
< display - name > CrunchifyRESTJerseyExample < / display - name >
< welcome - file - list >
< welcome - file > index . html < / welcome - file >
< welcome - file > index . htm < / welcome - file >
< welcome - file > index . jsp < / welcome - file >
< welcome - file > default . html < / welcome - file >
< welcome - file > default . htm < / welcome - file >
< welcome - file > default . jsp < / welcome - file >
< / welcome - file - list >
 
< servlet >
< servlet - name > Jersey Web Application < / servlet - name >
< servlet - class > com . sun . jersey . spi . container . servlet . ServletContainer < / servlet - class >
< load - on - startup > 1 < / load - on - startup >
< / servlet >
< servlet - mapping >
< servlet - name > Jersey Web Application < / servlet - name >
< url - pattern > / api /* < / url - pattern >
< / servlet - mapping >
< / web - app >

Pasul 3 Convertiți proiectul în proiectul Maven

Urmați acest tutorial: https://crunchify.com/how-to-convert-existing-java-project-to-maven-in-eclipse/. Aici este fișierul meu pom.xml.

pom.xml file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
< project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns : xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi : schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" >
< modelVersion > 4.0.0 < / modelVersion >
< groupId > CrunchifyTutorials < / groupId >
< artifactId > CrunchifyTutorials < / artifactId >
< version > 0.0.1 - SNAPSHOT < / version >
< packaging > war < / packaging >
< build >
< sourceDirectory > src < / sourceDirectory >
< plugins >
< plugin >
< artifactId > maven - compiler - plugin < / artifactId >
< version > 3.1 < / version >
< configuration >
< source > 1.8 < / source >
< target > 1.8 < / target >
< / configuration >
< / plugin >
< plugin >
< artifactId > maven - war - plugin < / artifactId >
< version > 2.4 < / version >
< configuration >
< warSourceDirectory > WebContent < / warSourceDirectory >
< failOnMissingWebXml > false < / failOnMissingWebXml >
< / configuration >
< / plugin >
< / plugins >
< / build >
< dependencies >
< dependency >
< groupId > asm < / groupId >
< artifactId > asm - all < / artifactId >
< version > 3.3.1 < / version >
< / dependency >
< dependency >
< groupId > com . sun . jersey < / groupId >
< artifactId > jersey - bundle < / artifactId >
< version > 1.14 < / version >
< / dependency >
< dependency >
< groupId > org . json < / groupId >
< artifactId > json < / artifactId >
< version > 20090211 < / version >
< / dependency >
< / dependencies >
< / project >

Pasul-4

Creați serviciu RESTFul: CrunchifyRESTService.java . Aici vom crea două servicii:

  1. /api/crunchifyService – apel POST – vom folosi acest lucru cu testul nostru
  2. /api/verify – GET apel – doar pentru a vă asigura că serviciul a început cu succes

CrunchifyRESTService.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*
*/
 
import java . io . BufferedReader ;
import java . io . InputStream ;
import java . io . InputStreamReader ;
 
import javax . print . attribute . standard . Media ;
import javax . ws . rs . Consumes ;
import javax . ws . rs . GET ;
import javax . ws . rs . POST ;
import javax . ws . rs . Path ;
import javax . ws . rs . Produces ;
import javax . ws . rs . core . MediaType ;
import javax . ws . rs . core . Response ;
 
@Path ( "/" )
public class CrunchifyRESTService {
@POST
@Path ( "/crunchifyService" )
@Consumes ( MediaType . APPLICATION_JSON )
public Response crunchifyREST ( InputStream incomingData ) {
StringBuilder crunchifyBuilder = new StringBuilder ( ) ;
try {
BufferedReader in = new BufferedReader ( new InputStreamReader ( incomingData ) ) ;
String line = null ;
while ( ( line = in . readLine ( ) ) ! = null ) {
crunchifyBuilder . append ( line ) ;
}
} catch ( Exception e ) {
System . out . println ( "Error Parsing: - " ) ;
}
System . out . println ( "Data Received: " + crunchifyBuilder . toString ( ) ) ;
 
// return HTTP response 200 in case of success
return Response . status ( 200 ) . entity ( crunchifyBuilder . toString ( ) ) . build ( ) ;
}
 
@GET
@Path ( "/verify" )
@Produces ( MediaType . TEXT_PLAIN )
public Response verifyRESTService ( InputStream incomingData ) {
String result = "CrunchifyRESTService Successfully started.." ;
 
// return HTTP response 200 in case of success
return Response . status ( 200 ) . entity ( result ) . build ( ) ;
}
 
}

Pasul-5

Implementați proiectul CrunchifyTutorials pe Tomcat. Proiectul web ar trebui implementat fără nicio excepție.

  1. Faceți clic dreapta pe Servers tab din Eclipse
  2. Faceți clic pe Add and Remove... Proiect
  3. Adaugă Project CrunchifyTutorials în partea dreaptă Configured:
  4. Faceți clic pe Publish
  5. Faceți clic pe Start

Pasul 6 Verificați serviciul REST

Serviciul de odihnă ar trebui să fie accesibil folosind această adresă URL: http://127.0.0.1:8080/CrunchifyTutorials/api/verify

Serviciul CrunchifyREST a început cu succes

Dacă încercați să accesați http://127.0.0.1:8080/CrunchifyTutorials/api/crunchifyService, atunci veți vedea codul de eroare 405 - Method not allowed - care este un răspuns valid. După cum puteți vedea, este un apel POST și ar trebui să așteptați câteva date cu cererea.

404 Metoda nu este permisă - Se așteaptă date cu apelul POST

Să mergem mai departe.

Pasul-7

Copiați conținutul JSON de mai jos și puneți-l sub fișierul C:\\CrunchifyJSON.txt pentru Windows sau fișierul /Users/<username>/Documents/CrunchifyJSON.txt dacă este Macbook.

CrunchifyJSON.txt
1
2
3
4
5
6
7
{
     "tutorials" : {
         "id" : "Crunchify" ,
         "topic" : "REST Service" ,
         "description" : "This is REST Service Example by Crunchify."
     }
}

Pasul-8

Creați clientul de apel REST: CrunchifyRESTServiceClient.java.

Vă rugăm change path to CrunchifyJSON.txt în programul de mai jos.

CrunchifyRESTServiceClient.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com . crunchify . tutorials ;
 
import java . io . BufferedReader ;
import java . io . FileInputStream ;
import java . io . InputStream ;
import java . io . InputStreamReader ;
import java . io . OutputStreamWriter ;
import java . net . URL ;
import java . net . URLConnection ;
 
import org . json . JSONObject ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyRESTServiceClient {
public static void main ( String [ ] args ) {
String string = "" ;
try {
 
// Step1: Let's 1st read file from fileSystem
// Change CrunchifyJSON.txt path here
InputStream crunchifyInputStream = new FileInputStream ( "/Users/<username>/Documents/CrunchifyJSON.txt" ) ;
InputStreamReader crunchifyReader = new InputStreamReader ( crunchifyInputStream ) ;
BufferedReader br = new BufferedReader ( crunchifyReader ) ;
String line ;
while ( ( line = br . readLine ( ) ) ! = null ) {
string += line + "\n" ;
}
 
JSONObject jsonObject = new JSONObject ( string ) ;
System . out . println ( jsonObject ) ;
 
// Step2: Now pass JSON File Data to REST Service
try {
URL url = new URL ( "http://localhost:8080/CrunchifyTutorials/api/crunchifyService" ) ;
URLConnection connection = url . openConnection ( ) ;
connection . setDoOutput ( true ) ;
connection . setRequestProperty ( "Content-Type" , "application/json" ) ;
connection . setConnectTimeout ( 5000 ) ;
connection . setReadTimeout ( 5000 ) ;
OutputStreamWriter out = new OutputStreamWriter ( connection . getOutputStream ( ) ) ;
out . write ( jsonObject . toString ( ) ) ;
out . close ( ) ;
 
BufferedReader in = new BufferedReader ( new InputStreamReader ( connection . getInputStream ( ) ) ) ;
 
while ( in . readLine ( ) ! = null ) {
}
System . out . println ( "\nCrunchify REST Service Invoked Successfully.." ) ;
in . close ( ) ;
} catch ( Exception e ) {
System . out . println ( "\nError while calling Crunchify REST Service" ) ;
System . out . println ( e ) ;
}
 
br . close ( ) ;
} catch ( Exception e ) {
e . printStackTrace ( ) ;
}
}
}

Pasul-9

Acum să rulăm programul client făcând clic dreapta pe CrunchifyRESTServiceClient.java și ar trebui să vedeți mai jos două rezultate

1) în Consola Tomcat

Serviciul REST Tomcat Side Log - JSON complet

2) în Consola client local

Serviciul Crunchify REST a fost invocat cu succes