Chiamata RESTful in Java

Sto per fare una chiamata RESTful in Java. Tuttavia, non so come effettuare la chiamata. Devo usare l’URLConnection o altri? Qualcuno può aiutarmi. grazie.

Se chiami un servizio RESTful da un fornitore di servizi (ad esempio Facebook, Twitter), puoi farlo con qualsiasi gusto di tua scelta:

Se non si desidera utilizzare librerie esterne, è ansible utilizzare java.net.HttpURLConnection o javax.net.ssl.HttpsURLConnection (per SSL), ma questa è la chiamata incapsulata in un modello di tipo factory in java.net.URLConnection . Per ricevere il risultato, dovrai connection.getInputStream() che ti restituisce un InputStream . Dovrai quindi convertire il tuo stream di input in stringa e analizzare la stringa nel suo object rappresentativo (ad es. XML, JSON, ecc.).

In alternativa, Apache HttpClient (la versione 4 è l’ultima). È più stabile e robusto rispetto URLConnection predefinito di URLConnection e supporta la maggior parte (se non tutti) il protocollo HTTP (e può anche essere impostato in modalità Strict). La tua risposta sarà ancora in InputStream e potrai utilizzarla come menzionato sopra.


Documentazione su HttpClient: http://hc.apache.org/httpcomponents-client-ga/tutorial/html/index.html

Aggiornamento: sono passati quasi 5 anni da quando ho scritto la risposta qui sotto; oggi ho una prospettiva diversa.

Il 99% delle volte in cui le persone usano il termine REST, intendono veramente HTTP; potrebbero interessarsi meno di “risorse”, “rappresentazioni”, “trasferimenti di stato”, “interfacce uniformi”, “ipermedia” o qualsiasi altro vincolo o aspetto dello stile di architettura REST identificato da Fielding . Le astrazioni fornite da vari framework REST sono quindi confuse e inutili.

Quindi: vuoi inviare richieste HTTP usando Java nel 2015. Vuoi un’API che sia chiara, espressiva, intuitiva, idiomatica, semplice. Cosa usare? Non uso più Java, ma negli ultimi anni la libreria client HTTP Java che è sembrata la più promettente e interessante è OkHttp . Controlla.


Puoi sicuramente interagire con i servizi web RESTful usando URLConnection o HTTPClient per codificare le richieste HTTP.

Tuttavia, è generalmente più desiderabile utilizzare una libreria o un framework che fornisca un’API più semplice e più semantica progettata appositamente per questo scopo. Ciò facilita la scrittura, la lettura e il debug del codice e riduce la duplicazione degli sforzi. Questi framework in genere implementano alcune funzionalità eccezionali che non sono necessariamente presenti o facili da utilizzare nelle librerie di livello inferiore, come la negoziazione del contenuto, la memorizzazione nella cache e l’autenticazione.

Alcune delle opzioni più mature sono Jersey , RESTEasy e Restlet .

Sono più familiare con Restlet e Jersey, diamo un’occhiata a come fare una richiesta POST con entrambe le API.

Esempio di maglia

 Form form = new Form(); form.add("x", "foo"); form.add("y", "bar"); Client client = ClientBuilder.newClient(); WebTarget resource = client.target("http://localhost:8080/someresource"); Builder request = resource.request(); request.accept(MediaType.APPLICATION_JSON); Response response = request.get(); if (response.getStatusInfo().getFamily() == Family.SUCCESSFUL) { System.out.println("Success! " + response.getStatus()); System.out.println(response.getEntity()); } else { System.out.println("ERROR! " + response.getStatus()); System.out.println(response.getEntity()); } 

Esempio di restlet

 Form form = new Form(); form.add("x", "foo"); form.add("y", "bar"); ClientResource resource = new ClientResource("http://localhost:8080/someresource"); Response response = resource.post(form.getWebRepresentation()); if (response.getStatus().isSuccess()) { System.out.println("Success! " + response.getStatus()); System.out.println(response.getEntity().getText()); } else { System.out.println("ERROR! " + response.getStatus()); System.out.println(response.getEntity().getText()); } 

Naturalmente, le richieste GET sono ancora più semplici, e puoi anche specificare cose come tag quadro e Accept header, ma si spera che questi esempi siano utilmente non banali ma non troppo complessi.

Come puoi vedere, Restlet e Jersey hanno API client simili. Credo che siano stati sviluppati più o meno nello stesso periodo e quindi si sono influenzati a vicenda.

Trovo che l’API di Restlet sia un po ‘più semantica, e quindi un po’ più chiara, ma YMMV.

Come ho detto, sono più familiare con Restlet, l’ho usato in molte app per anni, e ne sono molto contento. È una struttura molto matura, robusta, semplice, efficace, triggers e ben supportata. Non posso parlare a Jersey o RESTEasy, ma la mia impressione è che siano entrambe anche scelte solide.

Questo è molto complicato in java, motivo per cui suggerirei di usare l’astrazione di Spring’s RestTemplate :

 String result = restTemplate.getForObject( "http://example.com/hotels/{hotel}/bookings/{booking}", String.class,"42", "21" ); 

Riferimento:

  • Spring Blog: Rest in Spring 3 (RestTemplate)
  • Riferimento di spring: accesso ai servizi RESTful sul client
  • JavaDoc: RestTemplate

Se hai solo bisogno di effettuare una semplice chiamata a un servizio REST da java, usi qualcosa lungo questa linea

 /* * Stolen from http://xml.nig.ac.jp/tutorial/rest/index.html * and http://www.dr-chuck.com/csev-blog/2007/09/calling-rest-web-services-from-java/ */ import java.io.*; import java.net.*; public class Rest { public static void main(String[] args) throws IOException { URL url = new URL(INSERT_HERE_YOUR_URL); String query = INSERT_HERE_YOUR_URL_PARAMETERS; //make connection URLConnection urlc = url.openConnection(); //use post mode urlc.setDoOutput(true); urlc.setAllowUserInteraction(false); //send query PrintStream ps = new PrintStream(urlc.getOutputStream()); ps.print(query); ps.close(); //get result BufferedReader br = new BufferedReader(new InputStreamReader(urlc .getInputStream())); String l = null; while ((l=br.readLine())!=null) { System.out.println(l); } br.close(); } } 

Ci sono diverse API RESTful in giro. Consiglierei Jersey;

https://jersey.java.net/

La documentazione API client è qui;

https://jersey.java.net/documentation/latest/index.html

Aggiornare
La posizione per i documenti OAuth nel commento qui sotto è un collegamento morto e si è spostata su https://jersey.java.net/nonav/documentation/latest/security.html#d0e12334

Voglio condividere la mia esperienza personale, chiamando un REST WS con la chiamata Post JSON:

 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintStream; import java.net.URL; import java.net.URLConnection; public class HWS { public static void main(String[] args) throws IOException { URL url = new URL("INSERT YOUR SERVER REQUEST"); //Insert your JSON query request String query = "{'PARAM1': 'VALUE','PARAM2': 'VALUE','PARAM3': 'VALUE','PARAM4': 'VALUE'}"; //It change the apostrophe char to double colon char, to form a correct JSON string query=query.replace("'", "\""); try{ //make connection URLConnection urlc = url.openConnection(); //It Content Type is so importan to support JSON call urlc.setRequestProperty("Content-Type", "application/xml"); Msj("Conectando: " + url.toString()); //use post mode urlc.setDoOutput(true); urlc.setAllowUserInteraction(false); //send query PrintStream ps = new PrintStream(urlc.getOutputStream()); ps.print(query); Msj("Consulta: " + query); ps.close(); //get result BufferedReader br = new BufferedReader(new InputStreamReader(urlc.getInputStream())); String l = null; while ((l=br.readLine())!=null) { Msj(l); } br.close(); } catch (Exception e){ Msj("Error ocurrido"); Msj(e.toString()); } } private static void Msj(String texto){ System.out.println(texto); } } 

Puoi controllare la CXF . Puoi visitare l’articolo JAX-RS qui

Chiamare è semplice come questa (citazione):

 BookStore store = JAXRSClientFactory.create("http://bookstore.com", BookStore.class); // (1) remote GET call to http://bookstore.com/bookstore Books books = store.getAllBooks(); // (2) no remote call BookResource subresource = store.getBookSubresource(1); // {3} remote GET call to http://bookstore.com/bookstore/1 Book b = subresource.getDescription(); 

La soluzione più semplice utilizzerà la libreria client http Apache. fare riferimento al seguente codice di esempio .. questo codice utilizza la sicurezza di base per l’autenticazione.

Aggiungi seguente dipendenza.

  org.apache.httpcomponents httpclient 4.4  
 CredentialsProvider credentialsProvider = new BasicCredentialsProvider(); Credentials credentials = new UsernamePasswordCredentials("username", "password"); credentialsProvider.setCredentials(AuthScope.ANY, credentials); HttpClient client = HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider).build(); HttpPost request = new HttpPost("https://api.plivo.com/v1/Account/MAYNJ3OT/Message/");HttpResponse response = client.execute(request); // Get the response BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent())); String line = ""; while ((line = rd.readLine()) != null) { textView = textView + line; } System.out.println(textView); 

In effetti, questo è “molto complicato in Java”:

Da: https://jersey.java.net/documentation/latest/client.html

 Client client = ClientBuilder.newClient(); WebTarget target = client.target("http://foo").path("bar"); Invocation.Builder invocationBuilder = target.request(MediaType.TEXT_PLAIN_TYPE); Response response = invocationBuilder.get(); 

È ansible utilizzare il client Http asincrono (la libreria supporta anche il protocollo WebSocket ) in questo modo:

  String clientChannel = UriBuilder.fromPath("http://localhost:8080/api/{id}").build(id).toString(); try (AsyncHttpClient asyncHttpClient = new AsyncHttpClient()) { BoundRequestBuilder postRequest = asyncHttpClient.preparePost(clientChannel); postRequest.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON); postRequest.setBody(message.toString()); // returns JSON postRequest.execute().get(); }