clientes REST para Java?

Question

Com 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 para SOAP -. Algo que esconde os serviços web e controla os dados de forma transparente de volta para objetos Java

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

Answer 1

Esta é uma questão de idade (2008) por isso há muitas mais opções agora do que havia então:

• Apache CXF tem três diferentes cliente REST opções
• Jersey (mencionados acima).
• Spring também tem seu próprio chamado RestTemplate
• Commons HTTP Cliente construir o seu próprio para idosos projetos Java.

Atualização circa 2014:

• Async-http-client por Sonatype . Ning Async-http-client .

O novo garoto sobre o bloco que fornece suporte NIO (embora sinceramente eu não acho que isso realmente melhora o desempenho para os clientes como ele faz servidores).

• Apache HTTP Componentes (4,2) adaptador Fluente - melhor que velhos Commons HTTP cliente 3 e fácil de usar para construir o seu próprio cliente REST. Você vai ter que usar algo como Jackson para JSON análise de suporte e você pode usar HTTP componentes UriBuilder para URIs de recursos construto semelhante ao cliente Jersey / JAX-RS Resto . componentes HTTP também suporta NIO mas eu duvido que você vai obter um melhor desempenho do que BIO dado o curto pedido natureza do REST.

ATUALIZAÇÃO 2016 :

• OkHttp - Suporta mais recente HTTP protocolos (SPDY e HTTP2). Funciona em Android. Infelizmente ele não oferece um verdadeiro reator de circuito baseado async opção (ver componentes Ning e HTTP acima). No entanto, se você usar o protocolo HTTP2 mais recente este é um problema menor (assumindo contagem de conexão é problema).
• Retrofit - Will auto criar clientes com base em recibos de interface semelhante ao alguns Jersey e CXF extensões. Usa OkHttp.
• Apache HttpComponents 5 supostamente vai ter HTTP2 apoio

Uma advertência em escolher clientes HTTP / REST. Certifique-se de verificar o que sua pilha quadro está usando para um cliente HTTP, como ele se enfiar, e, idealmente, usar o mesmo cliente se ele oferece um. Isto é, se o seu usando algo como Vert.x ou jogar você pode querer tentar usar seu cliente de apoio para participar em qualquer ônibus ou reactor de circuito fechado do quadro fornece ... caso contrário estar preparado para problemas de segmentação possivelmente interessantes.

Answer 2

Como mencionei no esta discussão I tendem a usar Jersey que implementa JAX-RS e vem com um cliente agradável REST. O bom é que se você implementar seus recursos RESTful usando JAX-RS, em seguida, o cliente Jersey pode reutilizar os provedores entidade como para JAXB / XML / JSON / Atom e assim por diante - assim você pode reutilizar os mesmos objetos no lado do servidor, como você usar no teste de unidade do lado do cliente.

Por exemplo aqui é um caso de teste de unidade do Apache Camel projeto que olha para cima payloads XML a partir de um recurso RESTful (usando os Endpoints JAXB objeto). O método de recursos (URI) é definida em este classe base que apenas utiliza o cliente API Jersey.

por exemplo.

    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 Espero que versão futura do JAX-RS adicionar uma boa API do lado do cliente ao longo das linhas de um em Jersey

Answer 3

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

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 cliente REST fornecidos pelo JAX-RS implementações, como Jersey. Essas APIs são mais fáceis de usar, mas exigem frascos adicionais em 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 obter mais informações, consulte:

• http: //bdoughan.blogspot. com / 2010/08 / criando-reparador-web-service-parte-55.html

Answer 4

Se você só deseja invocar um serviço REST e analisar a resposta que você pode experimentar resto assegurou

// 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]");

Answer 5

Você também pode verificar Restlet que tem capacidades de client-side completas, mais descanso orientada que as bibliotecas de nível inferior tais como HttpURLConnection ou Apache HTTP cliente (que pode alavancar como conectores).

Com os melhores cumprimentos, Jerome Louvel

Answer 6

Você poderia tentar Rapa . Deixe-nos saber sua opinião sobre o mesmo. E sinta-se livre para questões ou características esperadas de log.

Answer 7

Eu recentemente tentou Retrofit Biblioteca da praça, a sua grande e você pode chamar o seu descanso API muito facilmente. configuração baseada anotação nos permite livrar-se de grande quantidade de placa de caldeira codificação.

Answer 8

Eu gostaria de salientar mais 2 opções:

• Restfulie , baseado no framework web VRaptor, tem ambas as implementações do lado do servidor e do cliente com muito bom hipermídia apoio.
• RESTEasy tem um JAX-RS.

Answer 9

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

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

Ele não leva muito tempo para o código, e é bastante eficiente, na minha opinião.

Answer 10

OkHttp é leve e potente quando combinado com Retrofit bem. Isso funciona bem para uso geral Java, bem como no 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);
}

Answer 11

Tente JdkRequest de jcabi-http (Eu sou um desenvolvedor). É assim que funciona:

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

Verifique este post para mais detalhes: http: // www.yegor256.com/2014/04/11/jcabi-http-intro.html

Answer 12

Uma vez que ninguém mencionou, aqui é outra: Feign , que é usado por Spring Nuvem .

Answer 13

Por um tempo agora, eu tenho usado Resty :

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

Pode-se encontrar alguns exemplos aqui .

Answer 14

Apesar de sua simples para criar um cliente HTTP e fazer uma reuest. Mas se você quiser fazer uso de algumas auto gerado clientes, você pode fazer uso de WADL para descrever e gerar código.

Você pode usar RestDescribe para gerar e WSDL de compilação, você pode gerar clientes em PHP, ruby, Python, Java e C # usando isso. Ele gera um código limpo e há uma boa mudança que você tem que ajustá-lo um pouco após a geração de código, você pode encontrar boa documentação e pensamentos subjacentes por trás da ferramenta aqui .

Há alguns interessantes e úteis ferramentas WADL mencionados no Wintermute.

Answer 15

Eu escrevi uma biblioteca que mapeia uma interface Java para um serviço JSON RESTO 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);
}

Answer 16

Tente olhar para http-rest-client

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

Aqui está um exemplo simples:

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

A biblioteca cuida de serialização JSON e vinculativa para você.

Aqui está outro exemplo,

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

E um último exemplo,

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

Felicidades!

Answer 17

Exemplos de jersey cliente de lazer:
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 Conseguir 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 ele retorna uma lista que estamos aceitando como uma lista e, em seguida, convertê-lo para JSON matriz e, em seguida, Json Array para List.

Se o POST Request passar 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 "));
    }