我使用Apache HTTPClient来处理所有HTTP方面的事情。

我为XML内容编写XML SAX解析器，用于将XML解析为对象模型。我认为Axis2还公开了XML -> Model方法(Axis 1隐藏了这一部分，令人恼火)。XML生成器非常简单。

在我看来，它不需要很长时间来编码，而且非常高效。

正如我在这篇文章中提到的，我倾向于使用Jersey，它实现了JAX-RS，并附带了一个很好的REST客户机。好的事情是，如果您使用JAX-RS实现RESTful资源，那么Jersey客户端可以重用JAXB/XML/JSON/Atom等实体提供程序，因此您可以在服务器端重用与在客户端单元测试中使用相同的对象。

例如，下面是来自Apache Camel项目的一个单元测试用例，它从RESTful资源(使用JAXB对象Endpoints)查找XML有效负载。resource(uri)方法定义在这个基类中，它只使用Jersey客户机API。

e.g.

clientConfig = new DefaultClientConfig();
client = Client.create(clientConfig);

resource = client.resource("http://localhost:8080");
// let's get the XML as a String
String text = resource("foo").accept("application/xml").get(String.class);        

顺便说一句，我希望未来版本的JAX-RS能像Jersey那样添加一个很好的客户端API。

你也可以检查具有完整客户端功能的Restlet，它比httppurlconnection或Apache HTTP Client(我们可以作为连接器使用)等底层库更面向REST。

最好的问候, 杰罗姆Louvel

你可以试试拉帕。让我们知道你的反馈。 并随时记录问题或预期的功能。

您可以使用标准的Java SE api:

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

或者您可以使用JAX-RS实现(如Jersey)提供的REST客户机api。这些api更容易使用，但在类路径上需要额外的jar。

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

有关更多信息，请参阅:

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

这是一个老问题(2008年)，所以现在的选择比当时多得多:

Apache CXF有三个不同的REST客户端选项 泽西岛(上面提到过)。 Spring RestTemplate被Spring WebClient取代 公共HTTP客户端为旧的Java项目构建自己的。

更新(2020年仍然活跃的项目):

Apache HTTP Components (4.2) Fluent adapter - Basic replacement for JDK, used by several other candidates in this list. Better than old Commons HTTP Client 3 and easier to use for building your own REST client. You'll have to use something like Jackson for JSON parsing support and you can use HTTP components URIBuilder to construct resource URIs similar to Jersey/JAX-RS Rest client. HTTP components also supports NIO but I doubt you will get better performance than BIO given the short requestnature of REST. Apache HttpComponents 5 has HTTP/2 support. OkHttp - Basic replacement for JDK, similar to http components, used by several other candidates in this list. Supports newer HTTP protocols (SPDY and HTTP2). Works on Android. Unfortunately it does not offer a true reactor-loop based async option (see Ning and HTTP components above). However if you use the newer HTTP2 protocol this is less of a problem (assuming connection count is problem). Ning Async-http-client - provides NIO support. Previously known as Async-http-client by Sonatype. Feign wrapper for lower level http clients (okhttp, apache httpcomponents). Auto-creates clients based on interface stubs similar to some Jersey and CXF extensions. Strong spring integration. Retrofit - wrapper for lower level http clients (okhttp). Auto-creates clients based on interface stubs similar to some Jersey and CXF extensions. Volley wrapper for jdk http client, by google google-http wrapper for jdk http client, or apache httpcomponents, by google Unirest wrapper for jdk http client, by kong Resteasy JakartaEE wrapper for jdk http client, by jboss, part of jboss framework jcabi-http wrapper for apache httpcomponents, part of jcabi collection restlet wrapper for apache httpcomponents, part of restlet framework rest-assured wrapper with asserts for easy testing

关于选择HTTP/REST客户端的一个警告。确保检查你的框架栈为HTTP客户端使用了什么，它是如何执行线程的，如果它提供了一个客户端，最好使用相同的客户端。这是如果你使用像Vert。你可能想尝试使用它的后台客户端来参与框架提供的任何总线或反应器循环…否则，请为可能出现的有趣的线程问题做好准备。

如果您只希望调用REST服务并解析响应，则可以尝试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]");

我想指出另外两个选项:

Restfulie基于VRaptor web框架，拥有非常好的超媒体支持的服务器端和客户端实现。 RESTEasy有一个基于JAX-RS代理的客户端实现。

试试jcabi-http中的JdkRequest(我是一名开发人员)。它是这样工作的:

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

查看这篇博客文章了解更多细节:http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

尽管创建一个HTTP客户端并进行重新测试很简单。但是如果你想利用一些自动生成的客户端，你可以使用WADL来描述和生成代码。

您可以使用RestDescribe来生成和编译WSDL，也可以使用它生成php、ruby、python、java和c#中的客户端。它可以生成干净的代码，并且在代码生成之后，你需要对它进行一些调整，你可以在这里找到良好的文档和工具背后的潜在思想。

wintermute中提到了一些有趣而有用的WADL工具。

我写了一个库，将java接口映射到远程JSON REST服务:

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

我最近尝试了从square的Retrofit Library，它很棒，你可以很容易地调用你的rest API。 基于注释的配置使我们摆脱了大量的锅炉板编码。

试着看看http-rest-client

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

这里有一个简单的例子:

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

库为您处理json的序列化和绑定。

这是另一个例子，

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

最后一个例子，

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

干杯!

泽西休息客户端的例子

添加依赖项:

<!-- 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>

对于GetMethod，并传递两个参数:

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传递一个参数并获得一个List类型的响应:

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

上面它返回一个列表，我们将其作为list对象接受，然后将其转换为JSONArray，然后从JSONArray转换为list。

Post请求传递JSONObject作为参数:

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

OkHttp在与Retrofit结合使用时是轻量级和强大的。这适用于一般的Java使用，也适用于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();
}

改造:http://square.github.io/retrofit/

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

由于没有人提到，这里有另一个:Feign，由Spring Cloud使用。

我大部分时间都使用RestAssured来解析rest服务响应和测试服务。除了Rest Assured之外，我还使用下面的库来与Resful服务进行通信。

a. Jersey Rest客户端

b. Spring RestTemplate

c. Apache HTTP Client

我目前正在使用https://github.com/kevinsawicki/http-request，我喜欢他们的简单性和展示示例的方式，但当我阅读时，我主要是被卖了:

依赖关系是什么? 一个也没有。这个库的目标是成为带有一些内部静态类的单个类。测试项目确实需要Jetty，以便根据实际的HTTP服务器实现测试请求。

这解决了Java 1.6项目中的一些问题。至于把json解码成对象，gson是无敌的:)