Erstellen Sie einen sehr einfachen Jersey-REST-Dienst und senden Sie JSON-Daten vom Java-Client

Veröffentlicht: 2013-11-29

Crunchify-REST-Service-Beispiel

Kürzlich musste ich JSON-Daten an den REST-Dienst übergeben und hatte keinen einfachen Client zur Hand. Aber ein sehr einfaches Java-Programm erstellt, das JSON-Daten aus der Datei liest und an den REST-Dienst sendet.

Representational State Transfer (REST) ​​hat sich im Web als einfachere Alternative zu SOAP- und Web Services Description Language (WSDL)-basierten Webdiensten durchgesetzt. Ein wichtiger Beweis für diese Veränderung im Schnittstellendesign ist die Einführung von REST durch etablierte Web 2.0-Dienstanbieter – einschließlich Yahoo, Google und Facebook – die SOAP- und WSDL-basierte Schnittstellen zugunsten einer einfacher zu verwendenden, ressourcenorientiertes Modell, um ihre Dienste bereitzustellen. In diesem Artikel führt Sie Alex Rodriguez in die Grundprinzipien von REST ein.

Beginnen wir mit der Codierung:

  1. Erstellen Sie einen RESTFul-Webdienst
    • Java-Datei: CrunchifyRESTService.java
    • web.xml-Datei
  2. Erstellen Sie den RESTService-Client
    1. CrunchifyRESTServiceClient.java-Datei

Ein weiteres Muss ist: Spring MVC Example/Tutorial: Hello World – Spring MVC 3.2.1

Schritt 1

In Eclipse => File => New => Dynamic Web Project . Benennen Sie es als „ CrunchifyTutorials “. Das folgende Tutorial funktioniert auch mit Tomcat 8 .

Erstellen Sie ein dynamisches Webprojekt

Neues dynamisches Webprojekt für RESTServiceClient- Crunchify

Schritt-2 Bereitstellungsdeskriptordatei erstellen

Wenn web.xml (Bereitstellungsdeskriptor) nicht unter WebContent\WEB-INF\ wird, führen Sie diese Schritte aus.

Öffnen web.xml und ersetzen Sie den Inhalt durch den folgenden Inhalt:

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 >

Schritt-3 Konvertieren Sie das Projekt in ein Maven-Projekt

Folgen Sie diesem Tutorial: https://crunchify.com/how-to-convert-existing-java-project-to-maven-in-eclipse/. Hier ist meine pom.xml-Datei.

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 >

Schritt 4

Erstellen Sie einen RESTFul-Dienst: CrunchifyRESTService.java . Hier erstellen wir zwei Dienste:

  1. /api/crunchifyService – POST-Aufruf – wir werden dies mit unserem Test verwenden
  2. /api/verify – GET-Aufruf – nur um sicherzustellen, dass der Dienst erfolgreich gestartet wurde

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 ( ) ;
}
 
}

Schritt-5

Stellen Sie das Projekt CrunchifyTutorials auf Tomcat bereit. Das Webprojekt sollte ausnahmslos bereitgestellt werden.

  1. Klicken Sie mit der rechten Maustaste auf Servers tab in Eclipse
  2. Klicken Sie auf Add and Remove... Projekt
  3. Projekt CrunchifyTutorials zur rechten Configured: Seite hinzufügen.
  4. Klicken Sie auf Publish
  5. Klicken Sie auf Start

Schritt-6 Überprüfen Sie den REST-Dienst

Der Rest-Service sollte über diese URL zugänglich sein: http://127.0.0.1:8080/CrunchifyTutorials/api/verify

Der CrunchifyREST-Dienst wurde erfolgreich gestartet

Wenn Sie versuchen, auf http://127.0.0.1:8080/CrunchifyTutorials/api/crunchifyService zuzugreifen, sehen Sie den Fehlercode 405 - Method not allowed – was eine gültige Antwort ist. Wie Sie sehen können, ist es ein POST-Aufruf und Sie sollten einige Daten mit der Anfrage erwarten.

404 Methode nicht erlaubt - Erwartet Daten mit POST-Aufruf

Lass uns weitermachen.

Schritt-7

Kopieren Sie den JSON-Inhalt unten und legen Sie ihn unter C:\\CrunchifyJSON.txt -Datei für Windows oder /Users/<username>/Documents/CrunchifyJSON.txt für Macbook ab.

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

Schritt-8

Erstellen Sie einen REST-Aufrufclient: CrunchifyRESTServiceClient.java.

Bitte change path to CrunchifyJSON.txt im untenstehenden Programm.

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 ( ) ;
}
}
}

Schritt-9

Lassen Sie uns nun das Client-Programm ausführen, indem Sie mit der rechten Maustaste auf CrunchifyRESTServiceClient.java klicken, und Sie sollten unten zwei Ausgaben sehen

1) in der Tomcat-Konsole

REST-Dienst Tomcat-Seitenprotokoll – Vollständiges JSON

2) in der lokalen Client-Konsole

Crunchify-REST-Dienst erfolgreich aufgerufen