java - Clientes REST para Java?




9 Answers

Esta é uma questão antiga (2008), então há muito mais opções agora do que havia então:

ATUALIZAR por volta de 2014:

O novo garoto no bloco que fornece suporte a NIO (embora, na verdade, eu não acho que isso realmente melhora o desempenho de clientes como servidores).

ATUALIZAÇÃO 2016 :

  • OkHttp - Suporta protocolos HTTP mais recentes (SPDY e HTTP2). Funciona no Android. Infelizmente, ele não oferece uma opção async verdadeira baseada em reatores (veja os componentes Ning e HTTP acima). No entanto, se você usar o protocolo HTTP2 mais recente, isso será um problema menor (supondo que a contagem de conexões seja um problema).
  • Retrofit - Retrofit automaticamente clientes com base em stubs de interface semelhantes a algumas extensões Jersey e CXF. Usa o OkHttp.
  • O Apache HttpComponents 5 supostamente terá suporte a HTTP2

Uma ressalva na escolha de clientes HTTP / REST. Certifique-se de verificar o que sua pilha de estruturas está usando para um cliente HTTP, como ele faz o encadeamento e, idealmente, use o mesmo cliente se ele oferecer um. Isto é, se você estiver usando algo como Vert.x ou Play, você pode querer tentar usar seu cliente de apoio para participar de qualquer loop de barramento ou reator que a estrutura forneça ... caso contrário, esteja preparado para problemas de encadeamento possivelmente interessantes.

Com o JSR 311 e suas implementações, temos um poderoso padrão para expor objetos Java via Rest. No entanto, no lado do cliente, parece haver algo faltando que é comparável ao Apache Axis for SOAP - algo que oculta o serviço da Web e reúne os dados de forma transparente de volta aos objetos Java.

Como você cria clientes Java RESTful? Usando HTTPConnection e análise manual do resultado? Ou clientes especializados para, por exemplo, Jersey ou Apache CXR?




Você pode usar as APIs padrão do Java SE:

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

Ou você pode usar as APIs do cliente REST fornecidas por implementações JAX-RS, como Jersey. Essas APIs são mais fáceis de usar, mas exigem jars adicionais no seu caminho de classe.

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

Para mais informações, veja:




Se você deseja apenas invocar um serviço REST e analisar a resposta, você pode experimentar Rest 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]");



Eu recentemente tentei Retrofit Library da praça, é ótimo e você pode chamar sua API de descanso com muita facilidade. A configuração baseada em anotação nos permite livrar-se de muitos códigos de placa de caldeira.




Eu uso o Apache HTTPClient para lidar com todo o lado HTTP das coisas.

Eu escrevo analisadores XML SAX para o conteúdo XML que analisa o XML em seu modelo de objeto. Acredito que o Axis2 também expõe os métodos XML -> Model (o Axis 1 ocultou essa parte, irritantemente). Geradores XML são trivialmente simples.

Não demora muito para codificar e é bastante eficiente, na minha opinião.







Por um tempo agora, eu tenho usado o Resty :

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

Pode-se encontrar alguns exemplos here .




Eu escrevi uma biblioteca que mapeia uma interface java para um serviço JSON REST remoto:

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



Exemplos de jersey Rest client:
Adicionando dependência:

         <!-- 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 e passando dois parâmetros:

          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 passando um parâmetro e Obtendo um Respone da Lista:

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

Em Acima, Retorna uma Lista que estamos aceitando como uma Lista e, em seguida, convertendo-a para Json Array e, em seguida, Json Array para List.

Se Post Request passar o objeto Json como parâmetro:

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



Related

java rest client