Pergunta
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?
Solução
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.
Outras dicas
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
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:
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]");
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
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.
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.
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.
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);
}
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
Uma vez que ninguém mencionou, aqui é outra: Feign , que é usado por Spring Nuvem .
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.
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);
}
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!
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 "));
}