restful - jersey java rest client




Clientes REST para Java? (12)

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?

https://code.i-harness.com


Como eu mencionei neste segmento, eu costumo usar Jersey que implementa o JAX-RS e vem com um bom cliente REST. O bom é que se você implementar seus recursos RESTful usando JAX-RS, o cliente Jersey poderá reutilizar os provedores de entidades, como JAXB / XML / JSON / Atom e assim por diante, para que você possa reutilizar os mesmos objetos no lado do servidor. use no teste da unidade do lado do cliente.

Por exemplo, aqui está um caso de teste de unidade do projeto Apache Camel que procura cargas úteis XML a partir de um recurso RESTful (usando os pontos de extremidade do objeto JAXB). O método resource (uri) é definido nesta classe base que usa apenas a API do cliente 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 a futura versão do JAX-RS adicione uma boa API do lado do cliente ao longo das linhas de uma em Jersey


Como ninguém mencionou, aqui está outro: Feign , que é usado pelo Spring Cloud .


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.


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

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.


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

O OkHttp é leve e poderoso quando combinado com Retrofit também. Isso funciona bem para o uso geral de Java, bem como no Android.

Ok : 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 : Retrofit

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

Por um tempo agora, eu tenho usado o Resty :

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

Pode-se encontrar alguns exemplos here .



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 da serialização e ligação do json 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!


Você poderia tentar Rapa . Deixe-nos saber seu feedback sobre o mesmo. E sinta-se à vontade para registrar problemas ou recursos esperados.


Você também pode verificar o Restlet que possui recursos completos do lado do cliente, mais orientado ao REST que bibliotecas de nível inferior, como HttpURLConnection ou Apache HTTP Client (que podemos utilizar como conectores).

Atenciosamente, Jerome Louvel





client