Clientes de descanso para Java?

Por exemplo Aqui está um caso de teste unitário do camelo Apache projecto que procura as cargas de XML a partir de um recurso repousante (usando os objectivos do objecto JAXB). O método resource (uri) é definido em Esta classe base que apenas usa a API do cliente de 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);        

Espero que a futura versão do JAX-R adicione uma boa API ao lado do cliente, tal como a de Jersey

Pode usar o Java SE APIs padrão:

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

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, ver:

• http://bdoughan.blogspot.com/2010/08/creating-restful-web-service-part-55.html

Também pode verificar a Restlet {[3] } que tem capacidades do lado do cliente completas, mais orientadas para o descanso que bibliotecas de nível inferior como o HttpURLConnection ou o cliente HTTP Apache (que podemos usar como conectores).

Melhores cumprimentos., Jerome Louvel

Se apenas deseja invocar um serviço de repouso e analisar a resposta, pode experimentar Tenha a certeza

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

Podes tentarRapa . Deixe-nos saber o seu feedback sobre o mesmo. E sinta-se livre para registrar problemas ou características esperadas.

Gostaria de apontar mais duas opções:

• Restfulie , com base no framework web VRaptor, tem implementações do lado do servidor e do cliente com muito bom suporte Hypermedia.
• O RESTEasy tem uma implementaçãocom base no JAX-RS, .

Eu tentei recentementeRetrofit Biblioteca da praça, é grande e você pode chamar a sua API de descanso muito facilmente. A configuração baseada na anotação permite-nos livrar-nos de muitos códigos de placa da caldeira.

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

Escrevo os analisadores de SAX XML para o conteúdo XML que processa o XML no seu modelo de objecto. Acredito que o Axis2 também expõe métodos de modelo XML - > (o eixo 1 escondeu esta parte, irritantemente). Geradores de XML são trivialmente simples.

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

Tente JdkRequest de jcabi-http (sou um programador). É 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

O OkHttp é leve e poderoso quando combinado com Retrofit também. 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);
}

Desde que ninguém mencionado, aqui está outro: fingir , que é usado pornuvem de Primavera .

Há algum tempo que ando a usar O Resty.:

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

Pode-se encontrar alguns exemplos Aqui.

Embora seja simples criar um cliente HTTP e fazer um reuest. Mas se você quiser fazer uso de alguns clientes gerados automaticamente, você pode fazer uso de WADL para descrever e gerar código.

Você pode usar RestDescribe para gerar e compilar o WSDL, você poderá gerar clientes em php, ruby, python, java e C# usando isto. Ele gera 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 subjacente pensamentos por trás da ferramenta aqui .

Existem poucas ferramentas interessantes e úteis de WADL mencionadas em wintermute.

Escrevi uma biblioteca que mapeia uma interface java para um serviço remoto de descanso JSON:

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

Tente ver o 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);

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

Exemplos de cliente de jersey:
Adicionar 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>

Esquecer o método e passar 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 cima ele retorna uma lista que estamos aceitando como uma lista e, em seguida, convertê-lo para JSON Array e, em seguida, JSON Array para Lista .

Se após pedido passar o objecto 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 "));
    }

Pode usar o java. net. URL

public class URL {
public URL(java.lang.String s)
throws java.net.MalformedURLException {}
public java.net.URLConnection
openConnection() throws java.io.IOException {}
...
}

A partir de um URL, poderá criar uma ligação HttpURLConnection que lhe permite invocar um

requests. Here’s an example of doing a simple GET request:
URL url = new URL("http://example.com/customers/1");
connection = (HttpURLConnection) getUrl.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("Accept", "application/xml");
if (connection.getResponseCode() != 200) {
throw new RuntimeExceptioin("Operation failed: "
+ connection.getResponseCode());
}
System.out.println("Content-Type: 

" + connection.getContentType());
BufferedReader reader = new BufferedReader(new
InputStreamReader(connection.getInputStream()));
String line = reader.readLine();
while (line != null) {
System.out.println(line);
line = reader.readLine();
}
connection.disconnect();