•  03-07-2019
  •  | 
  •  

Frage

Mit JSR 311 und Ihrer Implementierungen, wir haben einen leistungsfähigen standard für die Aufdeckung von Java-Objekten über REST.Aber auf der client-Seite, es scheint etwas fehlt, dass ist vergleichbar mit Apache Axis-for-SOAP - etwas versteckt, dass der web-service und Streckenposten, die Daten transparent zu Java-Objekten.

Wie erstellen Sie Java-RESTful-clients?Mit HTTPConnection und manuelle Parsen von dem Ergebnis?Oder spezielle clients für z.B.Jersey-oder Apache-CXR?

War es hilfreich?

Lösung

Dies ist eine alte Frage (2008), so gibt es viel mehr Optionen jetzt als gab es dann:

UPDATE circa 2014:

Das neue Kind auf den block, der enthält NIO-Unterstützung (obwohl ehrlich ich glaube nicht, dass dies wirklich verbessert die Leistung für Kunden wie es funktioniert-Server).

UPDATE 2016:

  • OkHttp - Unterstützt neuere HTTP-Protokolle (SPDY und HTTP2).Funktioniert auf Android.Leider ist es nicht eine wahre Reaktor-loop-basierte async-option (siehe Ning und HTTP-Komponenten oben).Allerdings, wenn Sie die neuere Version verwenden HTTP2-Protokoll ist das weniger ein problem (vorausgesetzt Anzahl von verbindungen ist ein problem).
  • Retrofit - Auto erstellen, die Kunden auf der Grundlage Schnittstelle stubs ähnlich wie Jersey und CXF-Erweiterungen.Verwendet OkHttp.
  • Apache HttpComponents 5 wird angeblich haben HTTP2-Unterstützung

Eine Einschränkung auf die Kommissionierung von HTTP/REST-clients.Stellen Sie sicher, zu überprüfen, was Ihre framework-stack für ein HTTP-client, wie es funktioniert, threading, und verwenden Sie idealerweise den gleichen client, wenn es bietet.Wenn Ihr mit so etwas wie Vert.x oder Spielen, möchten Sie vielleicht zu versuchen, seine Unterstützung client teilnehmen in welcher bus-oder Reaktor-loop-framework bietet...anders vorbereitet sein, die möglicherweise interessant threading Probleme.

Andere Tipps

Wie ich in diesen Thread erwähnt ich verwenden neigen Jersey die JAX-RS implementiert und kommt mit einem netten REST-Client. Das Schöne daran ist, wenn Sie Ihre RESTful Ressourcen JAX-RS implementieren kann das Jersey-Client die Einheit Anbieter wiederverwenden wie für JAXB / XML / JSON / Atom und so weiter - so können Sie die gleichen Objekte auf der Server-Seite, wie Sie wiederverwenden verwenden, um auf dem Client-Seite Unit-Test.

Zum Beispiel: hier ist eine Einheit Testfall aus dem Apache Camel Projekt die XML-Nutzlasten von einer RESTful Ressource sucht (unter Verwendung der JAXB Objekt Endpunkte). Die Ressource (uri) Methode wird in diese Basisklasse , welche die Jersey-Client-API nur verwendet.

z. 

    clientConfig = new DefaultClientConfig();
    client = Client.create(clientConfig);

    resource = client.resource("http://localhost:8080");
    // lets get the XML as a String
    String text = resource("foo").accept("application/xml").get(String.class);

BTW hoffe ich, dass zukünftige Version von JAX-RS eine schöne Client-Seite API hinzufügen entlang der Linien von der in Jersey

Sie können die Standard-Java SE APIs verwenden: 

private void updateCustomer(Customer customer) { 
    try { 
        URL url = new URL("http://www.example.com/customers"); 
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 
        connection.setDoOutput(true); 
        connection.setInstanceFollowRedirects(false); 
        connection.setRequestMethod("PUT"); 
        connection.setRequestProperty("Content-Type", "application/xml"); 

        OutputStream os = connection.getOutputStream(); 
        jaxbContext.createMarshaller().marshal(customer, os); 
        os.flush(); 

        connection.getResponseCode(); 
        connection.disconnect(); 
    } catch(Exception e) { 
        throw new RuntimeException(e); 
    } 
}

Sie können auch die REST-Client-APIs von JAX-RS-Implementierungen wie Jersey vorgesehen verwenden. Diese APIs sind einfacher zu bedienen, benötigen aber zusätzliche Gläser auf dem Classpath. 

WebResource resource = client.resource("http://www.example.com/customers"); 
ClientResponse response = resource.type("application/xml");).put(ClientResponse.class, "<customer>...</customer."); 
System.out.println(response);

Weitere Informationen finden Sie unter:

Wenn Sie nur einen REST-Dienst aufrufen wollen und analysieren, um die Antwort können Sie versuchen, Seien Assured 

// Make a GET request to "/lotto"
String json = get("/lotto").asString()
// Parse the JSON response
List<String> winnderIds = with(json).get("lotto.winners.winnerId");

// Make a POST request to "/shopping"
String xml = post("/shopping").andReturn().body().asString()
// Parse the XML
Node category = with(xml).get("shopping.category[0]");

Sie können auch Restlet die volle clientseitige Fähigkeiten, mehr REST ausgerichtet, dass untergeordnete Bibliotheken wie zum als HttpURLConnection oder Apache HTTP-Client (die wir als Anschlüsse nutzen können).

Mit freundlichen Grüßen, Jerome Louvel

Sie könnten versuchen, Rapa . Lassen Sie uns Ihr Feedback über das gleiche wissen. Und fühlen sich frei, Fragen oder erwartete Funktionen zu protokollieren.

Ich habe vor kurzem versucht, Retrofit Bibliothek von Platz, Seine große und Sie können Ihre Rest-API aufrufen sehr leicht. Annotation-basierte Konfiguration ermöglicht es uns loswerden viel Kesselblech Codierung zu erhalten.

Ich möchte 2 weitere Möglichkeiten hinweisen:

Ich verwende Apache Httpclient alle HTTP-Seite der Dinge zu behandeln.

schreibe ich XML SAX-Parser für die XML-Inhalte, die die XML-Daten in Ihr Objektmodell analysiert. Ich glaube, dass Axis2 macht auch XML -> Modellverfahren (Achse 1 diesen Teil versteckt, annoyingly). XML-Generatoren sind trivial einfach.

Es dauert nicht lange, um Code, und ist sehr effizient, meiner Meinung nach.

OkHttp ist leicht und leistungsstark, wenn auch mit Retrofit kombiniert. Das funktioniert gut für die allgemeine Java Verwendung sowie auf Android.

OkHttp : http://square.github.io/okhttp/ 

public static final MediaType JSON
    = MediaType.parse("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(JSON, json);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  Response response = client.newCall(request).execute();
  return response.body().string();
}

Retrofit : http://square.github.io/retrofit/ 

public interface GitHubService {
  @GET("/users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

Versuchen JdkRequest von jcabi-http (Ich bin ein Entwickler). Dies ist, wie es funktioniert: 

String body = new JdkRequest("http://www.google.com")
  .header("User-Agent", "it's me")
  .fetch()
  .body()

Überprüfen Sie dieses Blog-Post für weitere Informationen: http: // www.yegor256.com/2014/04/11/jcabi-http-intro.html

Da niemand erwähnt, hier ist ein anderes: Feign , die von Frühling Wolke .

Für eine Weile jetzt, ich habe mit Resty :

JSONResource jsonResource = new Resty().json(uri);

Man kann einige Beispiele finden hier .

Obwohl seine einfach, ein HTTP-Client zu erstellen und eine reuest machen. Aber wenn Sie die Verwendung einiger automatisch generierten Kunden machen möchten, können Sie den Einsatz von WADL machen zu beschreiben und Code zu generieren.

Sie können mit RestDescribe WSDL generieren und zu kompilieren, können Kunden generieren in pHP, ruby, python, Java und C # mit diesem. Es erzeugt sauberen Code und es gibt eine gute Änderung, die Sie haben es nach dem Code-Generierung ein wenig zu optimieren, können Sie eine gute Dokumentation und die zugrunde liegenden Gedanken hinter dem Werkzeug hier .

Es gibt einige interessante und nützliche WADL Tools auf winter erwähnt.

Ich schrieb eine Bibliothek, die eine Java-Schnittstelle zu einem Remote-JSON REST-Service-Karten:

https://github.com/ggeorgovassilis/spring-rest-invoker 

public interface BookService {
   @RequestMapping("/volumes")
   QueryResult findBooksByTitle(@RequestParam("q") String q);

   @RequestMapping("/volumes/{id}")
   Item findBookById(@PathVariable("id") String id);
}

Versuchen Blick auf http-rest-Client

https://github.com/g00dnatur3/http-rest-client

Hier ist ein einfaches Beispiel: 

RestClient client = RestClient.builder().build();
String geocoderUrl = "http://maps.googleapis.com/maps/api/geocode/json"
Map<String, String> params = Maps.newHashMap();
params.put("address", "beverly hills 90210");
params.put("sensor", "false");
JsonNode node = client.get(geocoderUrl, params, JsonNode.class);

Die Bibliothek übernimmt json Serialisierung und verbindlich für Sie.

Hier ist ein weiteres Beispiel: 

RestClient client = RestClient.builder().build();
String url = ...
Person person = ...
Header header = client.create(url, person);
if (header != null) System.out.println("Location header is:" + header.value());

Und ein letztes Beispiel: 

RestClient client = RestClient.builder().build();
String url = ...
Person person = client.get(url, null, Person.class); //no queryParams

Cheers!

Beispiele für Jersey Ruhe Client:
Hinzufügen Abhängigkeit: 

         <!-- jersey -->
    <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-json</artifactId>
        <version>1.8</version>
    </dependency>
   <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-server</artifactId>
        <version>1.8</version>
    </dependency>

<dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-client</artifactId>
    <version>1.8</version>
</dependency>

    <dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20090211</version>
</dependency>

ForGetMethod und Leiten zwei Parameter: 

          Client client = Client.create();
           WebResource webResource1 = client
                        .resource("http://localhost:10102/NewsTickerServices/AddGroup/"
                                + userN + "/" + groupName);

                ClientResponse response1 = webResource1.get(ClientResponse.class);
                System.out.println("responser is" + response1);

GetMethod vorbei einen Parameter und Abrufen einer Respone der Liste: 

       Client client = Client.create();

        WebResource webResource1 = client
                    .resource("http://localhost:10102/NewsTickerServices/GetAssignedUser/"+grpName);    
    //value changed
    String response1 = webResource1.type(MediaType.APPLICATION_JSON).get(String.class);

    List <String > Assignedlist =new ArrayList<String>();
     JSONArray jsonArr2 =new JSONArray(response1);
    for (int i =0;i<jsonArr2.length();i++){

        Assignedlist.add(jsonArr2.getString(i));    
    }

Above It eine Liste zurück, die wir als eine Liste akzeptieren und Umwandlung es dann zu Json Array und dann JSON-Array zur Liste.

Wenn Post-Anforderung JSON-Objekt als Parameter übergeben: 

   Client client = Client.create();
    WebResource webResource = client
            .resource("http://localhost:10102/NewsTickerServices/CreateJUser");
    // value added

    ClientResponse response = webResource.type(MediaType.APPLICATION_JSON).post(ClientResponse.class,mapper.writeValueAsString(user));

    if (response.getStatus() == 500) {

        context.addMessage(null, new FacesMessage("User already exist "));
    }
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top