HttpClient

HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。本文首先介绍 HTTPClient，然后根据作者实际工作经验给出了一些常见问题的解决方法。 
HttpClient 基本功能的使用 
（一）、GET 方法  
使用 HttpClient 需要以下 6 个步骤： 
1. 创建 HttpClient 的实例 
2. 创建某种连接方法的实例，在这里是 GetMethod。在 GetMethod 的构造函数中传入待连接的地址 
3. 调用第一步中创建好的实例的 execute 方法来执行第二步中创建好的 method 实例 
4. 读 response 
5. 释放连接。无论执行方法是否成功，都必须释放连接 
6. 对得到后的内容进行处理 
根据以上步骤，我们来编写用GET方法来取得某网页内容的代码。 
• 大部分情况下 HttpClient 默认的构造函数已经足够使用。 
HttpClient httpClient = new HttpClient(); 
• 创建GET方法的实例。在GET方法的构造函数中传入待连接的地址即可。用GetMethod将会自动处理转发过程，如果想要把自动处理转发过程去掉的话，可以调用方法setFollowRedirects(false)。 
GetMethod getMethod = new GetMethod("http://www.ibm.com/"); 
• 调用实例httpClient的executeMethod方法来执行getMethod。由于是执行在网络上的程序，在运行executeMethod方法的时候，需要处理两个异常，分别是HttpException和IOException。引起第一种异常的原因主要可能是在构造getMethod的时候传入的协议不对，比如不小心将"http"写成"htp"，或者服务器端返回的内容不正常等，并且该异常发生是不可恢复的；第二种异常一般是由于网络原因引起的异常，对于这种异常 （IOException），HttpClient会根据你指定的恢复策略自动试着重新执行executeMethod方法。HttpClient的恢复策略可以自定义（通过实现接口HttpMethodRetryHandler来实现）。通过httpClient的方法setParameter设置你实现的恢复策略，本文中使用的是系统提供的默认恢复策略，该策略在碰到第二类异常的时候将自动重试3次。executeMethod返回值是一个整数，表示了执行该方法后服务器返回的状态码，该状态码能表示出该方法执行是否成功、需要认证或者页面发生了跳转（默认状态下GetMethod的实例是自动处理跳转的）等。 
//设置成了默认的恢复策略，在发生异常时候将自动重试3次，在这里你也可以设置成自定义的恢复策略 
getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, 
    new DefaultHttpMethodRetryHandler()); 
//执行getMethod 
int statusCode = client.executeMethod(getMethod); 
if (statusCode != HttpStatus.SC_OK) { 
  System.err.println("Method failed: " + getMethod.getStatusLine()); 
} 
• 在返回的状态码正确后，即可取得内容。取得目标地址的内容有三种方法：第一种，getResponseBody，该方法返回的是目标的二进制的byte流；第二种，getResponseBodyAsString，这个方法返回的是String类型，值得注意的是该方法返回的String的编码是根据系统默认的编码方式，所以返回的String值可能编码类型有误，在本文的"字符编码"部分中将对此做详细介绍；第三种，getResponseBodyAsStream，这个方法对于目标地址中有大量数据需要传输是最佳的。在这里我们使用了最简单的getResponseBody方法。 
byte[] responseBody = method.getResponseBody(); 
• 释放连接。无论执行方法是否成功，都必须释放连接。 
method.releaseConnection(); 
• 处理内容。在这一步中根据你的需要处理内容，在例子中只是简单的将内容打印到控制台。 
System.out.println(new String(responseBody)); 
下面是程序的完整代码，这些代码也可在附件中的test.GetSample中找到。 
package test; 
import java.io.IOException; 
import org.apache.commons.httpclient.*; 
import org.apache.commons.httpclient.methods.GetMethod; 
import org.apache.commons.httpclient.params.HttpMethodParams; 
public class GetSample{ 
  public static void main(String[] args) { 
  //构造HttpClient的实例 
  HttpClient httpClient = new HttpClient(); 
  //创建GET方法的实例 
  GetMethod getMethod = new GetMethod("http://www.ibm.com"); 
  //使用系统提供的默认的恢复策略 
  getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, 
    new DefaultHttpMethodRetryHandler()); 
  try { 
   //执行getMethod 
   int statusCode = httpClient.executeMethod(getMethod); 
   if (statusCode != HttpStatus.SC_OK) { 
    System.err.println("Method failed: " 
      + getMethod.getStatusLine()); 
   } 
   //读取内容 
   byte[] responseBody = getMethod.getResponseBody(); 
   //处理内容 
   System.out.println(new String(responseBody)); 
  } catch (HttpException e) { 
   //发生致命的异常，可能是协议不对或者返回的内容有问题 
   System.out.println("Please check your provided http address!"); 
   e.printStackTrace(); 
  } catch (IOException e) { 
   //发生网络异常 
   e.printStackTrace(); 
  } finally { 
   //释放连接 
   getMethod.releaseConnection(); 
  } 
} 
} 
（二）、POST方法  
根据RFC2616，对POST的解释如下：POST方法用来向目的服务器发出请求，要求它接受被附在请求后的实体，并把它当作请求队列（Request-Line）中请求URI所指定资源的附加新子项。POST被设计成用统一的方法实现下列功能： 
• 对现有资源的注释（Annotation of existing resources） 
• 向电子公告栏、新闻组，邮件列表或类似讨论组发送消息 
• 提交数据块，如将表单的结果提交给数据处理过程 
• 通过附加操作来扩展数据库 
调用HttpClient中的PostMethod与GetMethod类似，除了设置PostMethod的实例与GetMethod有些不同之外，剩下的步骤都差不多。在下面的例子中，省去了与GetMethod相同的步骤，只说明与上面不同的地方，并以登录清华大学BBS为例子进行说明。 
• 构造PostMethod之前的步骤都相同，与GetMethod一样，构造PostMethod也需要一个URI参数，在本例中，登录的地址是http://www.newsmth.net/bbslogin2.php。在创建了PostMethod的实例之后，需要给method实例填充表单的值，在BBS的登录表单中需要有两个域，第一个是用户名（域名叫id），第二个是密码（域名叫passwd）。表单中的域用类NameValuePair来表示，该类的构造函数第一个参数是域名，第二参数是该域的值；将表单所有的值设置到PostMethod中用方法setRequestBody。另外由于BBS登录成功后会转向另外一个页面，但是HttpClient对于要求接受后继服务的请求，比如POST和PUT，不支持自动转发，因此需要自己对页面转向做处理。具体的页面转向处理请参见下面的"自动转向"部分。代码如下： 
String url = "http://www.newsmth.net/bbslogin2.php"; 
PostMethod postMethod = new PostMethod(url); 
// 填入各个表单域的值 
NameValuePair[] data = { new NameValuePair("id", "youUserName"), 
new NameValuePair("passwd", "yourPwd") }; 
// 将表单的值放入postMethod中 
postMethod.setRequestBody(data); 
// 执行postMethod 
int statusCode = httpClient.executeMethod(postMethod); 
// HttpClient对于要求接受后继服务的请求，象POST和PUT等不能自动处理转发 
// 301或者302 
if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || 
statusCode == HttpStatus.SC_MOVED_TEMPORARILY) { 
    // 从头中取出转向的地址 
    Header locationHeader = postMethod.getResponseHeader("location"); 
    String location = null; 
    if (locationHeader != null) { 
     location = locationHeader.getValue(); 
     System.out.println("The page was redirected to:" + location); 
    } else { 
     System.err.println("Location field value is null."); 
    } 
    return; 
} 

二、HttpClient一些问题  
下面介绍在使用HttpClient过程中常见的一些问题。 
（一）、字符编码  
某目标页的编码可能出现在两个地方，第一个地方是服务器返回的http头中，另外一个地方是得到的html/xml页面中。 
• 在http头的Content-Type字段可能会包含字符编码信息。例如可能返回的头会包含这样子的信息：Content-Type: text/html; charset=UTF-8。这个头信息表明该页的编码是UTF-8，但是服务器返回的头信息未必与内容能匹配上。比如对于一些双字节语言国家，可能服务器返回的编码类型是UTF-8，但真正的内容却不是UTF-8编码的，因此需要在另外的地方去得到页面的编码信息；但是如果服务器返回的编码不是UTF-8，而是具体的一些编码，比如gb2312等，那服务器返回的可能是正确的编码信息。通过method对象的getResponseCharSet()方法就可以得到http头中的编码信息。 
• 对于象xml或者html这样的文件，允许作者在页面中直接指定编码类型。比如在html中会有<meta http-equiv="Content-Type" content="text/html; charset=gb2312"/>这样的标签；或者在xml中会有<?xml version="1.0" encoding="gb2312"?>这样的标签，在这些情况下，可能与http头中返回的编码信息冲突，需要用户自己判断到底那种编码类型应该是真正的编码。 
编码问题解决 
private static final String CONTENT_CHARSET = "GBK";// httpclient读取内容时使用的字符集   
HttpClient client = new HttpClient();   
client.getParams().setParameter(   
HttpMethodParams.HTTP_CONTENT_CHARSET, CONTENT_CHARSET); 

字符串编码改变的方法：String target = new String(orig.getBytes("ISO-8859-1"),"GBK"); 


（二）、认证  
HttpClient三种不同的认证方案: Basic, Digest and NTLM. 这些方案可用于服务器或代理对客户端的认证，简称服务器认证或代理认证。 
1) 服务器认证(Server Authentication) 
HttpClient处理服务器认证几乎是透明的，仅需要开发人员提供登录信息(login credentials)。登录信息保存在HttpState类的实例中，可以通过 setCredentials(String realm, Credentials cred)和getCredentials(String realm)来获取或设置。注意，设定对非特定站点访问所需要的登录信息，将realm参数置为null. HttpClient内建的自动认证，可以通过HttpMethod类的setDoAuthentication(boolean doAuthentication)方法关闭，而且这次关闭只影响HttpMethod当前的实例。 
抢先认证(Preemptive Authentication)可以通过下述方法打开. 
client.getState().setAuthenticationPreemptive(true); 
在这种模式时，HttpClient会主动将basic认证应答信息传给服务器，即使在某种情况下服务器可能返回认证失败的应答，这样做主要是为了减少连接的建立。为使每个新建的 HttpState实例都实行抢先认证，可以如下设置系统属性。 
setSystemProperty(Authenticator.PREEMPTIVE_PROPERTY, "true"); 
Httpclient实现的抢先认证遵循rfc2617. 
2)代理认证(proxy authentication) 
除了登录信息需单独存放以外，代理认证与服务器认证几乎一致。用 setProxyCredentials(String realm, Credentials cred)和 getProxyCredentials(String realm)设、取登录信息。 
2) 认证方案(authentication schemes) 
Basic 
是HTTP中规定最早的也是最兼容(?)的方案，遗憾的是也是最不安全的一个方案，因为它以明码传送用户名和密码。它要求一个UsernamePasswordCredentials实例，可以指定服务器端的访问空间或采用默认的登录信息。 
Digest 
是在HTTP1.1中增加的一个方案，虽然不如Basic得到的软件支持多，但还是有广泛的使用。Digest方案比Basic方案安全得多，因它根本就不通过网络传送实际的密码，传送的是利用这个密码对从服务器传来的一个随机数(nonce)的加密串。它要求一个UsernamePasswordCredentials实例，可以指定服务器端的访问空间或采用默认的登录信息。 
NTLM 
这是HttpClient支持的最复杂的认证协议。它M$设计的一个私有协议，没有公开的规范说明。一开始由于设计的缺陷，NTLM的安全性比Digest差，后来经过一个ServicePack补丁后，安全性则比较Digest高。NTLM需要一个NTCredentials实例. 注意，由于NTLM不使用访问空间(realms)的概念，HttpClient利用服务器的域名作访问空间的名字。还需要注意，提供给NTCredentials的用户名，不要用域名的前缀 - 如: "adrian" 是正确的，而 "DOMAIN/adrian" 则是错的. NTLM认证的工作机制与basic和digest有很大的差别。这些差别一般由HttpClient处理，但理解这些差别有助避免在使用NTLM认证时出现错误。 
从HttpClientAPI的角度来看，NTLM与其它认证方式一样的工作，差别是需要提供'NTCredentials'实例而不是'UsernamePasswordCredentials'(其实，前者只是扩展了后者)对NTLM认证，访问空间是连接到的机器的域名，这对多域名主机会有一些麻烦.只有HttpClient连接中指定的域名才是认证用的域名。建议将realm设为null以使用默认的设置。NTLM只是认证了一个连接而不是一请求，所以每当一个新的连接建立就要进行一次认证，且在认证的过程中保持连接是非常重要的。 因此，NTLM不能同时用于代理认证和服务器认证，也不能用于http1.0连接或服务器不支持持久连接的情况。 
（三）、重定向  
由于技术限制，以及为保证2.0发布版API的稳定，HttpClient还不能自动处重定向，但对重定向到同一主机、同一端口且采用同一协议的情况HttpClient可以支持。不能自动的处理的情况，包括需要人工交互的情况，或超出httpclient的能力。 
当服务器重定向指令指到不同的主机时，HttpClient只是简单地将重定向状态码作为应答状态。所有的300到399（包含两端）的返回码，都表示是重定向应答。常见的有： 
301 永久移动. HttpStatus.SC_MOVED_PERMANENTLY 
302 临时移动. HttpStatus.SC_MOVED_TEMPORARILY 
303 See Other. HttpStatus.SC_SEE_OTHER 
307 临时重定向. HttpStatus.SC_TEMPORARY_REDIRECT　　 
当收到简单的重定向时，程序应从HttpMethod对象中抽取新的URL并将其下载。另外,限制一下重定向次数是个好的主意，这可以避免递归循环。新的URL可以从头字段Location中抽取，如下： 
String redirectLocation; 
Header locationHeader = method.getResponseHeader("location"); 
if (locationHeader != null) { 
redirectLocation = locationHeader.getValue(); 
} else { 
// The response is invalid and did not provide the new location for 
// the resource. Report an error or possibly handle the response 
// like a 404 Not Found error. 
} 
特殊重定向： 
300 多重选择. HttpStatus.SC_MULTIPLE_CHOICES 
304 没有改动. HttpStatus.SC_NO T_MODIFIED 
305 使用代理. HttpStatus.SC_USE_PROXY 

（四）、自动转向  
根据RFC2616中对自动转向的定义，主要有两种：301和302。301表示永久的移走（Moved Permanently），当返回的是301，则表示请求的资源已经被移到一个固定的新地方，任何向该地址发起请求都会被转到新的地址上。302表示暂时的转向，比如在服务器端的servlet程序调用了sendRedirect方法，则在客户端就会得到一个302的代码，这时服务器返回的头信息中location的值就是sendRedirect转向的目标地址。 
HttpClient支持自动转向处理，但是象POST和PUT方式这种要求接受后继服务的请求方式，暂时不支持自动转向，因此如果碰到POST方式提交后返回的是301或者302的话需要自己处理。就像刚才在POSTMethod中举的例子：如果想进入登录BBS后的页面，必须重新发起登录的请求，请求的地址可以在头字段location中得到。不过需要注意的是，有时候location返回的可能是相对路径，因此需要对location返回的值做一些处理才可以发起向新地址的请求。 
另外除了在头中包含的信息可能使页面发生重定向外，在页面中也有可能会发生页面的重定向。引起页面自动转发的标签是：<meta http-equiv="refresh" content="5; url=http://www.ibm.com/us">。如果你想在程序中也处理这种情况的话得自己分析页面来实现转向。需要注意的是，在上面那个标签中url的值也可以是一个相对地址，如果是这样的话，需要对它做一些处理后才可以转发。 
（五）、Cookies  
　　 HttpClient能自动管理cookie,包括允许服务器设置cookie并在需要的时候自动将cookie返回服务器，它也支持手工设置cookie后发送到服务器端。不幸的是，对如何处理cookie，有几个规范互相冲突：Netscape Cookie 草案, RFC2109, RFC2965，而且还有很大数量的软件商的cookie实现不遵循任何规范. 为了处理这种状况，HttpClient提供了策略驱动的cookie管理方式。HttpClient支持的cookie规范有： Netscape cookie草案，是最早的cookie规范，基于rfc2109。尽管这个规范与rc2109有较大的差别，这样做可以与一些服务器兼容。rfc2109，是w3c发布的第一个官方cookie规范。理论上讲，所有的服务器在处理cookie(版本1)时，都要遵循此规范，正因如此，HttpClient将其设为默认的规范。遗憾的是，这个规范太严格了，以致很多服务器不正确的实施了该规范或仍在作用Netscape规范。在这种情况下，应使用兼容规范。兼容性规范，设计用来兼容尽可能多的服务器，即使它们并没有遵循标准规范。当解析cookie出现问题时，应考虑采用兼容性规范。 
　　 RFC2965规范暂时没有被HttpClient支持（在以后的版本为会加上），它定义了cookie版本2，并说明了版本1cookie的不足，RFC2965有意有久取代rfc2109. 
在HttpClient中，有两种方法来指定cookie规范的使用， 
HttpClient client = new HttpClient(); 
client.getState().setCookiePolicy(CookiePolicy.COMPATIBILITY); 
这种方法设置的规范只对当前的HttpState有效，参数可取值CookiePolicy.COMPATIBILITY，CookiePolicy.NETSCAPE_DRAFT或CookiePolicy.RFC2109。 
System.setProperty("apache.commons.httpclient.cookiespec", "COMPATIBILITY"); 
此法指的规范，对以后每个新建立的HttpState对象都有效，参数可取值"COMPATIBILITY","NETSCAPE_DRAFT"或"RFC2109"。 
常有不能解析cookie的问题，但更换到兼容规范大都能解决。 
（六）、使用HttpClient遇到问题怎么办?  
用一个浏览器访问服务器，以确认服务器应答正常如果在使代理，关掉代理试试另找一个服务器来试试（如果运行着不同的服务器软件更好）检查代码是否按教程中讲的思路编写设置log级别为debug，找出问题出现的原因打开wiretrace，来追踪客户端与服务器的通信，以确实问题出现在什么地方用telnet或netcat手工将信息发送到服务器，适合于猜测已经找到了原因而进行试验时将netcat以监听方式运行，用作服务器以检查httpclient如何处理应答的。利用最新的httpclient试试，bug可能在最新的版本中修复了向邮件列表求帮助向bugzilla报告bug. 
（七）、SSL  
借助Java Secure Socket Extension (JSSE)，HttpClient全面支持Secure Sockets Layer (SSL)或IETF Transport Layer Security (TLS)协议上的HTTP。JSSE已经jre1.4及以后的版本中，以前的版本则需要手工安装设置，具体过程参见Sun网站或本学习笔记。 
HttpClient中使用SSL非常简单，参考下面两个例子: 
HttpClient httpclient = new HttpClient(); 
GetMethod httpget = new GetMethod("https://www.verisign.com/"); 
httpclient.executeMethod(httpget); 
System.out.println(httpget.getStatusLine().toString()); 
，如果通过需要授权的代理，则如下： 
HttpClient httpclient = new HttpClient(); 
httpclient.getHostConfiguration().setProxy("myproxyhost", 8080); 
httpclient.getState().setProxyCredentials("my-proxy-realm", " myproxyhost", 
new UsernamePasswordCredentials("my-proxy-username", "my-proxy-password")); 
GetMethod httpget = new GetMethod("https://www.verisign.com/"); 
httpclient.executeMethod(httpget); 
System.out.println(httpget.getStatusLine().toString()); 
在HttpClient中定制SSL的步骤如下： 
提供了一个实现了org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory接口的socket factory。这个 socket factory负责打一个到服务器的端口，使用标准的或第三方的SSL函数库，并进行象连接握手等初始化操作。通常情况下，这个初始化操作在端口被创建时自动进行的。实例化一个org.apache.commons.httpclient.protocol.Protocol对象。创建这个实例时，需要一个合法的协议类型(如https)，一个定制的socket factory，和一个默认的端中号(如https的443端口). Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);然后，这个实例可被设置为协议的处理器。 
HttpClient httpclient = new HttpClient(); 
httpclient.getHostConfiguration().setHost("www.whatever.com", 443, myhttps); 
GetMethod httpget = new GetMethod("/"); 
httpclient.executeMethod(httpget); 
通过调用Protocol.registerProtocol方法，将此定制的实例，注册为某一特定协议的默认的处理器。由此，可以很方便地定制自己的协议类型(如myhttps)。 
Protocol.registerProtocol("myhttps", 
new Protocol("https", new MySSLSocketFactory(), 9443)); 
... 
HttpClient httpclient = new HttpClient(); 
GetMethod httpget = new GetMethod("myhttps://www.whatever.com/"); 
httpclient.executeMethod(httpget); 
如果想用自己定制的处理器取代https默认的处理器，只需要将其注册为"https"即可。 
Protocol.registerProtocol("https", 
new Protocol("https", new MySSLSocketFactory(), 443)); 
HttpClient httpclient = new HttpClient(); 
GetMethod httpget = new GetMethod("https://www.whatever.com/"); 
httpclient.executeMethod(httpget); 
已知的限制和问题持续的SSL连接在Sun的低于1.4JVM上不能工作，这是由于JVM的bug造成。通过代理访问服务器时，非抢先认证（ Non-preemptive authentication）会失败，这是由于HttpClient的设计缺陷造成的，以后的版本中会修改。 
遇到问题的处理 
很多问题，特别是在jvm低于1.4时，是由jsse的安装造成的。 
下面的代码，可作为最终的检测手段。 
import java.io.BufferedReader; 
import java.io.InputStreamReader; 
import java.io.OutputStreamWriter; 
import java.io.Writer; 
import java.net.Socket; 
import javax.net.ssl.SSLSocketFactory; 
public class Test { 
public static final String TARGET_HTTPS_SERVER = "www.verisign.com"; 
public static final int TARGET_HTTPS_PORT = 443; 
public static void main(String[] args) throws Exception { 
Socket socket = SSLSocketFactory.getDefault(). 
createSocket(TARGET_HTTPS_SERVER, TARGET_HTTPS_PORT); 
try { 
Writer out = new OutputStreamWriter( 
socket.getOutputStream(), "ISO-8859-1"); 
out.write("GET / HTTP/1.1/r/n"); 
out.write("Host: " + TARGET_HTTPS_SERVER + ":" + 
TARGET_HTTPS_PORT + "/r/n"); 
out.write("Agent: SSL-TEST/r/n"); 
out.write("/r/n"); 
out.flush(); 
BufferedReader in = new BufferedReader( 
new InputStreamReader(socket.getInputStream(), "ISO-8859-1")); 
String line = null; 
while ((line = in.readLine()) != null) { 
System.out.println(line); 
} 
} finally { 
socket.close(); 
} 
} 
} 
（八）、httpclient的多线程处理  
使用多线程的主要目的，是为了实现并行的下载。在httpclient运行的过程中，每个http协议的方法，使用一个HttpConnection实例。由于连接是一种有限的资源，每个连接在某一时刻只能供一个线程和方法使用，所以需要确保在需要时正确地分配连接。HttpClient采用了一种类似jdbc连接池的方法来管理连接，这个管理工作由 MultiThreadedHttpConnectionManager完成。 
MultiThreadedHttpConnectionManager connectionManager = 
new MultiThreadedHttpConnectionManager(); 
HttpClient client = new HttpClient(connectionManager); 
此是，client可以在多个线程中被用来执行多个方法。每次调用HttpClient.executeMethod() 方法，都会去链接管理器申请一个连接实例，申请成功这个链接实例被签出(checkout)，随之在链接使用完后必须归还管理器。管理器支持两个设置：maxConnectionsPerHost 每个主机的最大并行链接数，默认为2 
maxTotalConnections 客户端总并行链接最大数，默认为20 
管理器重新利用链接时，采取早归还者先重用的方式（least recently used approach）。　　由于是使用HttpClient的程序而不是HttpClient本身来读取应答包的主体，所以HttpClient无法决定什么时间连接不再使用了，这也就要求在读完应答包的主体后必须手工显式地调用releaseConnection()来释放申请的链接。 
MultiThreadedHttpConnectionManager connectionManager = new 
MultiThreadedHttpConnectionManager(); 
HttpClient client = new HttpClient(connectionManager); 
... 
// 在某个线程中。 
GetMethod get = new GetMethod("http://jakarta.apache.org/"); 
try { 
client.executeMethod(get); 
// print response to stdout 
System.out.println(get.getResponseBodyAsStream()); 
} finally { 
// be sure the connection is released back to the connection 
// manager 
get.releaseConnection(); 
} 
对每一个HttpClient.executeMethod须有一个method.releaseConnection()与之匹配. 
（九）、HttpClient的连接释放问题  
在method.releaseConnection()后并没有把链接关闭，这个方法只是将链接返回给connection manager。 
如果使用HttpClient client = new HttpClient()实例化一个HttpClient connection manager默认实现是使用SimpleHttpConnectionManager。 
SimpleHttpConnectionManager有个构造函数如下 
public SimpleHttpConnectionManager(boolean alwaysClose) {   
    super();   
    this.alwaysClose = alwaysClose;   
}  
alwaysClose设为true在链接释放之后connection manager 就会关闭链。在我们HttpClient client = new HttpClient()这样实例化一个client时connection manager是这样被实例化的 
this.httpConnectionManager = new SimpleHttpConnectionManager();  
因此alwaysClose默认是false,connection是不会被主动关闭的，因此我们就有了一个客户端关闭链接的方法。 
解决方法： 
1、把事例代码中的第一行实例化代码改为如下即可，在method.releaseConnection();之后connection manager会关闭connection 。 
HttpClient client = new HttpClient(new HttpClientParams(),new SimpleHttpConnectionManager(true) );  
2、实例化代码使用：HttpClient client = new HttpClient(); 在method.releaseConnection();之后加上 ((SimpleHttpConnectionManager)client.getHttpConnectionManager()).shutdown(); 
其实shutdown源代码是  
public void shutdown() {   
    httpConnection.close();   
}  
3、实例化代码使用：HttpClient client = new HttpClient(); 
在method.releaseConnection();之后加上 
client.getHttpConnectionManager().closeIdleConnections(0);此方法源码代码如下： 
public void closeIdleConnections(long idleTimeout) {   
    long maxIdleTime = System.currentTimeMillis() - idleTimeout;   
    if (idleStartTime <= maxIdleTime) {   
        httpConnection.close();   
    }   
} 
4、代码实现很简单，所有代码就和最上面的事例代码一样。只需要在HttpMethod method = new GetMethod("http://www.apache.org");加上一行HTTP头的设置即可method.setRequestHeader("Connection", "close"); 
（十）、HttpClient的一个应用的例子（图片下载）  
1. import java.io.File;   
2. import java.io.FileOutputStream;   
3. import java.io.IOException;   
4. import org.apache.commons.httpclient.HttpClient;   
5. import org.apache.commons.httpclient.methods.GetMethod;   
6.    
7. /**  
8. * 用HttpClient下载图片  
9. * @author wei  
10. */   
11. public class TestDownImage {   
12.        
13.     public static void main(String[] args) throws IOException{   
14.         HttpClient client = new HttpClient();   
15.         GetMethod get = new GetMethod("http://images.sohu.com/uiue/sohu_logo/beijing2008/2008sohu.gif");   
16.         client.executeMethod(get);   
17.         File storeFile = new File("c:/2008sohu.gif");   
18.         FileOutputStream output = new FileOutputStream(storeFile);   
19.         //得到网络资源的字节数组,并写入文件   
20.         output.write(get.getResponseBody());   
21.         output.close();   
22.     }   
23. }

HttpClient 学习整理

HttpClient 是我最近想研究的东西，以前想过的一些应用没能有很好的实现，发现这个开源项目之后就有点眉目了，令人头痛的cookie问题还是有办法解决滴。在网上整理了一些东西，写得很好，寄放在这里。

HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上很著名的另外两个开源项目 Cactus 和 HTMLUnit 都使用了 HttpClient，更多使用 HttpClient 的应用可以参见http://wiki.apache.org/jakarta-httpclient/HttpClientPowered。HttpClient 项目非常活跃，使用的人还是非常多的。目前 HttpClient 版本是在 2005.10.11 发布的 3.0 RC4 。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

应用HttpClient来对付各种顽固的WEB服务器
转自：http://blog.csdn.net/ambitiontan/archive/2006/01/06/572171.aspx

一般的情况下我们都是使用IE或者Navigator浏览器来访问一个WEB服务器，用来浏览页面查看信息或者提交一些数据等等。所访问的这些页面有的仅仅是一些普通的页面，有的需要用户登录后方可使用，或者需要认证以及是一些通过加密方式传输，例如HTTPS。目前我们使用的浏览器处理这些情况都不会构成问题。不过你可能在某些时候需要通过程序来访问这样的一些页面，比如从别人的网页中“偷”一些数据；利用某些站点提供的页面来完成某种功能，例如说我们想知道某个手机号码的归属地而我们自己又没有这样的数据，因此只好借助其他公司已有的网站来完成这个功能，这个时候我们需要向网页提交手机号码并从返回的页面中解析出我们想要的数据来。如果对方仅仅是一个很简单的页面，那我们的程序会很简单，本文也就没有必要大张旗鼓的在这里浪费口舌。但是考虑到一些服务授权的问题，很多公司提供的页面往往并不是可以通过一个简单的URL就可以访问的，而必须经过注册然后登录后方可使用提供服务的页面，这个时候就涉及到COOKIE问题的处理。我们知道目前流行的动态网页技术例如ASP、JSP无不是通过COOKIE来处理会话信息的。为了使我们的程序能使用别人所提供的服务页面，就要求程序首先登录后再访问服务页面，这过程就需要自行处理cookie，想想当你用java.net.HttpURLConnection来完成这些功能时是多么恐怖的事情啊！况且这仅仅是我们所说的顽固的WEB服务器中的一个很常见的“顽固”！再有如通过HTTP来上传文件呢？不需要头疼，这些问题有了“它”就很容易解决了！

我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。

Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所有问题。

1． 读取网页(HTTP/HTTPS)内容

下面是我们给出的一个简单的例子用来访问某个页面

/* 
* Created on 2011-10-14 by eddle 
*/

package http.demo; 
import java.io.IOException; 
import org.apache.commons.httpclient.*; 
import org.apache.commons.httpclient.methods.*;

/** 
 *最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面
  *@author eddle

public class SimpleClient {
public static void main(String[] args) throws IOException
{
  HttpClient client = new HttpClient(); 
      // 设置代理服务器地址和端口      

      //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port); 
      // 使用 GET 方法 ，如果服务器需要通过 HTTPS 连接，那只需要将下面 URL 中的 http 换成 https 
         HttpMethodmethod=newGetMethod("http://java.sun.com");
      //使用POST方法
      //HttpMethod method = new PostMethod("http://java.sun.com");
      client.executeMethod(method);

      //打印服务器返回的状态
       System.out.println(method.getStatusLine());
      //打印返回的信息
      System.out.println(method.getResponseBodyAsString());
      //释放连接
      method.releaseConnection();
   }
}

 

在这个例子中首先创建一个HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者POST，最后在HttpClient实例上执行提交的方法，最后从所选择的提交方法中读取服务器反馈回来的结果。这就是使用HttpClient的基本流程。其实用一行代码也就可以搞定整个请求的过程，非常的简单！

2． 以GET或者POST方式向网页提交参数

其实前面一个最简单的示例中我们已经介绍了如何使用GET或者POST方式来请求一个页面，本小节与之不同的是多了提交时设定页面所需的参数，我们知道如果是GET的请求方式，那么所有参数都直接放到页面的URL后面用问号与页面地址隔开，每个参数用&隔开，例如：http://java.sun.com/?name=liudong&mobile=123456，但是当使用POST方法时就会稍微有一点点麻烦。本小节的例子演示向如何查询手机号码所在的城市，代码如下：

 

/* 
* Created on 2011-10-14 by eddle

*/

package http.demo; 
import java.io.IOException; 
import org.apache.commons.httpclient.*; 
import org.apache.commons.httpclient.methods.*;

/** 
 *提交参数演示
 *该程序连接到一个用于查询手机号码所属地的页面
 *以便查询号码段1330227所在的省份以及城市
 *@authorLiudong
 */

public class SimpleHttpClient { 
   public static void main(String[] args) throws IOException {
      HttpClient client = new HttpClient();
      client.getHostConfiguration().setHost( "www.imobile.com.cn" , 80, "http" );
      method = getPostMethod();    // 使用 POST 方式提交数据 
      client.executeMethod(method);   //打印服务器返回的状态 
      System.out.println(method.getStatusLine());   //打印结果页面
      Stringresponse=newString(method.getResponseBodyAsString().getBytes("8859_1"));

      //打印返回的信息
      System.out.println(response);
      method.releaseConnection();
   }

   /** 
    * 使用 GET 方式提交数据 
    *@return 
    */

   privatestaticHttpMethodgetGetMethod(){
      returnnewGetMethod("/simcard.php?simcard=1330227");
   }

    /** 
     * 使用 POST 方式提交数据 
     *@return 
     */

    private static HttpMethod getPostMethod(){
      PostMethod post = new PostMethod( "/simcard.php" );
      NameValuePair simcard = new NameValuePair( "simcard" , "1330227" );
      post.setRequestBody( new NameValuePair[] { simcard});
      return post; 
   } 
}

在上面的例子中页面http://www.imobile.com.cn/simcard.php需要一个参数是simcard，这个参数值为手机号码段，即手机号码的前七位，服务器会返回提交的手机号码对应的省份、城市以及其他详细信息。GET的提交方法只需要在URL后加入参数信息，而POST则需要通过NameValuePair类来设置参数名称和它所对应的值。

3． 处理页面重定向

在JSP/Servlet编程中response.sendRedirect方法就是使用HTTP协议中的重定向机制。它与JSP中的<jsp:forward …>的区别在于后者是在服务器中实现页面的跳转，也就是说应用容器加载了所要跳转的页面的内容并返回给客户端；而前者是返回一个状态码，这些状态码的可能值见下表，然后客户端读取需要跳转到的页面的URL并重新加载新的页面。就是这样一个过程，所以我们编程的时候就要通过HttpMethod.getStatusCode()方法判断返回值是否为下表中的某个值来判断是否需要跳转。如果已经确认需要进行页面跳转了，那么可以通过读取HTTP头中的location属性来获取新的地址。

状态码	对应 HttpServletResponse 的常量	详细描述
301	SC_MOVED_PERMANENTLY	页面已经永久移到另外一个新地址
302	SC_MOVED_TEMPORARILY	页面暂时移动到另外一个新的地址
303	SC_SEE_OTHER	客户端请求的地址必须通过另外的 URL 来访问
307	SC_TEMPORARY_REDIRECT	同 SC_MOVED_TEMPORARILY

下面的代码片段演示如何处理页面的重定向

client.executeMethod(post);
System.out.println(post.getStatusLine().toString());
post.releaseConnection();
// 检查是否重定向
int statuscode = post.getStatusCode();
if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
// 读取新的 URL 地址 
   Headerheader=post.getResponseHeader("location");
   if (header!=null){
      Stringnewuri=header.getValue();
      if((newuri==null)||(newuri.equals("")))
         newuri="/";
         GetMethodredirect=newGetMethod(newuri);
         client.executeMethod(redirect);
         System.out.println("Redirect:"+redirect.getStatusLine().toString());
         redirect.releaseConnection();
   }else 
    System.out.println("Invalid redirect");
}

我们可以自行编写两个JSP页面，其中一个页面用response.sendRedirect方法重定向到另外一个页面用来测试上面的例子。

4． 模拟输入用户名和口令进行登录

本小节应该说是HTTP客户端编程中最常碰见的问题，很多网站的内容都只是对注册用户可见的，这种情况下就必须要求使用正确的用户名和口令登录成功后，方可浏览到想要的页面。因为HTTP协议是无状态的，也就是连接的有效期只限于当前请求，请求内容结束后连接就关闭了。在这种情况下为了保存用户的登录信息必须使用到Cookie机制。以JSP/Servlet为例，当浏览器请求一个JSP或者是Servlet的页面时，应用服务器会返回一个参数，名为jsessionid（因不同应用服务器而异），值是一个较长的唯一字符串的Cookie，这个字符串值也就是当前访问该站点的会话标识。浏览器在每访问该站点的其他页面时候都要带上jsessionid这样的Cookie信息，应用服务器根据读取这个会话标识来获取对应的会话信息。

对于需要用户登录的网站，一般在用户登录成功后会将用户资料保存在服务器的会话中，这样当访问到其他的页面时候，应用服务器根据浏览器送上的Cookie中读取当前请求对应的会话标识以获得对应的会话信息，然后就可以判断用户资料是否存在于会话信息中，如果存在则允许访问页面，否则跳转到登录页面中要求用户输入帐号和口令进行登录。这就是一般使用JSP开发网站在处理用户登录的比较通用的方法。

这样一来，对于HTTP的客户端来讲，如果要访问一个受保护的页面时就必须模拟浏览器所做的工作，首先就是请求登录页面，然后读取Cookie值；再次请求登录页面并加入登录页所需的每个参数；最后就是请求最终所需的页面。当然在除第一次请求外其他的请求都需要附带上Cookie信息以便服务器能判断当前请求是否已经通过验证。说了这么多，可是如果你使用httpclient的话，你甚至连一行代码都无需增加，你只需要先传递登录信息执行登录过程，然后直接访问想要的页面，跟访问一个普通的页面没有任何区别，因为类HttpClient已经帮你做了所有该做的事情了，太棒了！下面的例子实现了这样一个访问的过程。

/* 
* Created on 2011-10-14by eddle

*/

package http.demo; 
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.cookie.*;
import org.apache.commons.httpclient.methods.*; 

/** 
 * 用来演示登录表单的示例 
 * @author eddle

 */

public class FormLoginDemo {
   static final String LOGON_SITE = "localhost" ;
   static final int     LOGON_PORT = 8080;

   public static void main(String[] args) throws Exception{
      HttpClient client = new HttpClient();
      client.getHostConfiguration().setHost(LOGON_SITE, LOGON_PORT);

      // 模拟登录页面 login.jsp->main.jsp
      PostMethod post = new PostMethod( "/main.jsp" );
      NameValuePair name = new NameValuePair( "name" , "ld" );
      NameValuePair pass = new NameValuePair( "password" , "ld" );
      post.setRequestBody( new NameValuePair[]{name,pass});
      int status = client.executeMethod(post);
      System.out.println(post.getResponseBodyAsString());
      post.releaseConnection();

      // 查看 cookie 信息
      CookieSpec cookiespec = CookiePolicy.getDefaultSpec();
      Cookie[] cookies = cookiespec.match(LOGON_SITE, LOGON_PORT, "/" , false, client.getState().getCookies());
      if (cookies.length == 0) {
         System.out.println( "None" );
      } else {
         for ( int i = 0; i < cookies.length; i++) {
            System.out.println(cookies[i].toString());
         }
      }

      // 访问所需的页面 main2.jsp 
      GetMethodget=newGetMethod("/main2.jsp");
      client.executeMethod(get);
      System.out.println(get.getResponseBodyAsString());
      get.releaseConnection();
   }
}

5． 提交XML格式参数

提交XML格式的参数很简单，仅仅是一个提交时候的ContentType问题，下面的例子演示从文件文件中读取XML信息并提交给服务器的过程，该过程可以用来测试Web服务。

import java.io.File; 
import java.io.FileInputStream; 
import org.apache.commons.httpclient.HttpClient; 
import org.apache.commons.httpclient.methods.EntityEnclosingMethod;
import org.apache.commons.httpclient.methods.PostMethod;

/** 
 *用来演示提交XML格式数据的例子
*/

public class PostXMLClient {

   public static void main(String[] args) throws Exception {
      File input = new File(“test.xml”);
      PostMethod post = new PostMethod(“http://localhost:8080/httpclient/xml.jsp”);

      // 设置请求的内容直接从文件中读取
      post.setRequestBody( new FileInputStream(input)); 
      if (input.length() < Integer.MAX_VALUE)
         post.setRequestContentLength(input.length());
      else
         post.setRequestContentLength(EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);

      // 指定请求内容的类型
      post.setRequestHeader( "Content-type" , "text/xml; charset=GBK" );
      HttpClient httpclient = new HttpClient();
      int result = httpclient.executeMethod(post);
      System.out.println( "Response status code: " + result);
      System.out.println( "Response body: " );
      System.out.println(post.getResponseBodyAsString()); 
      post.releaseConnection(); 
   } 
}

6． 通过HTTP上传文件

httpclient使用了单独的一个HttpMethod子类来处理文件的上传，这个类就是MultipartPostMethod，该类已经封装了文件上传的细节，我们要做的仅仅是告诉它我们要上传文件的全路径即可，下面的代码片段演示如何使用这个类。

MultipartPostMethod filePost = new MultipartPostMethod(targetURL);
filePost.addParameter( "fileName" , targetFilePath); 
HttpClient client = new HttpClient();

// 由于要上传的文件可能比较大 , 因此在此设置最大的连接超时时间 
client.getHttpConnectionManager(). getParams().setConnectionTimeout(5000); 
int status = client.executeMethod(filePost); 

上面代码中，targetFilePath即为要上传的文件所在的路径。

7． 访问启用认证的页面

我们经常会碰到这样的页面，当访问它的时候会弹出一个浏览器的对话框要求输入用户名和密码后方可，这种用户认证的方式不同于我们在前面介绍的基于表单的用户身份验证。这是HTTP的认证策略，httpclient支持三种认证方式包括：基本、摘要以及NTLM认证。其中基本认证最简单、通用但也最不安全；摘要认证是在HTTP 1.1中加入的认证方式，而NTLM则是微软公司定义的而不是通用的规范，最新版本的NTLM是比摘要认证还要安全的一种方式。

下面例子是从httpclient的CVS服务器中下载的，它简单演示如何访问一个认证保护的页面：

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.methods.GetMethod; 

public class BasicAuthenticationExample { 

   public BasicAuthenticationExample() { 
   }

   public static void main(String[] args) throws Exception {
      HttpClient client = new HttpClient();
      client.getState().setCredentials( "www.verisign.com" , "realm" , newUsernamePasswordCredentials( "username" , "password" ) );

      GetMethod get = new GetMethod( "https://www.verisign.com/products/index.html" );
      get.setDoAuthentication( true );
      int status = client.executeMethod( get );
      System.out.println(status+ "\n" + get.getResponseBodyAsString());
      get.releaseConnection();
   } 
}

8． 多线程模式下使用httpclient

多线程同时访问httpclient，例如同时从一个站点上下载多个文件。对于同一个HttpConnection同一个时间只能有一个线程访问，为了保证多线程工作环境下不产生冲突，httpclient使用了一个多线程连接管理器的类：MultiThreadedHttpConnectionManager，要使用这个类很简单，只需要在构造HttpClient实例的时候传入即可，代码如下：

MultiThreadedHttpConnectionManager connectionManager = newMultiThreadedHttpConnectionManager();

HttpClient client = new HttpClient(connectionManager);

以后尽管访问client实例即可。

参考资料：

httpclient首页：    http://jakarta.apache.org/commons/httpclient/
关于NTLM是如何工作：  http://davenport.sourceforge.net/ntlm.html


－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

HttpClient入门
http://blog.csdn.net/ambitiontan/archive/2006/01/07/572644.aspx

Jakarta Commons HttpClient 学习笔记
http://blog.csdn.net/cxl34/archive/2005/01/19/259051.aspx

Cookies,SSL，httpclient的多线程处理，HTTP方法
http://blog.csdn.net/bjbs_270/archive/2004/11/05/168233.aspx

  

android-HttpClient上传信息（包括图片）到服务端

（

<form action="AddFoodStyle" enctype="multipart/form-data" method="post">    
    <div style="width:300px;">

        <s:textfield label="菜式名称" name="foodname"></s:textfield><br/>       

        <s:select name="foodstyle" list="list" label="菜式类别" listKey="Itemid" listValue="itemname"  > </s:select><br/>       

        <s:textfield label="菜式价格" name="price"></s:textfield><br/>        
        
        <s:file label="菜式图片" name="foodimg"></s:file><br/>        
        
        <s:textarea label="菜式标签" name="foodtab" cols="20"  cssStyle=""></s:textarea><br/>       
        
        <s:textfield label="菜式状态" name="state"></s:textfield><br/>        
        
        <s:submit value="添加"/>
        </div>        
    </form>

模拟构造上面的请求表单：

private String url="http://192.168.2.189:8080/MyOrderMeal/AddFoodStyle";

     HttpClient httpclient= new DefaultHttpClient();
     HttpPost httpPost= new HttpPost(url);
     MultipartEntity mulentity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
        mulentity.addPart("foodname", new StringBody(foodname.getText().toString().trim()));
        mulentity.addPart("foodstyle", new StringBody(foodstyle.getText().toString().trim()));
        mulentity.addPart("price", new StringBody(foodprice.getText().toString().trim()));  

       //添加图片表单数据        
        FileBody filebody = new FileBody(this.image);        
        mulentity.addPart("foodimg",filebody );    
        mulentity.addPart("foodtab", new StringBody(foodtab.getText().toString().trim()));
        mulentity.addPart("state", new StringBody("1"));         
        httpPost.setEntity(mulentity);
        HttpResponse response =    httpclient.execute(httpPost);
        
        if(response.getStatusLine().getStatusCode()==HttpStatus.SC_OK)
        {
            makeToase("上传成功",true);
            if(this.image.exists())
            this.image.delete();
        }
        else
        {
            makeToase("上传失败",true);
        }

）

服务端：action的配置

     <action name="AddFoodStyle" class="com.ordermeal.xiao.action.AddFoodStyle">
          <result name="success" type="redirect">/ShowAddFoodStyle</result>
     </action>
   
    action的编写

public class AddFoodStyle extends ActionSupport{
    /**
     * 
     */
    private static final long serialVersionUID = -8380963167787044860L;
    
    private String foodname;
    private Integer foodstyle;
    private Double price;

    

   //接收上传文件

    private File foodimg;
    private String foodimgFileName;
    private String foodimgContentType;
    
    private String foodtab;

    private Integer state;

、、、、省略get  set方法

@Override
    public String execute() throws Exception {        
        
        FoodStyleDao fsd = DaoFactory.getFoodStyleDao();
        FoodStyle  foodstyleob= new FoodStyle();        
        foodstyleob.setFoodname(foodname);
        foodstyleob.setMystyletype(foodstyle);
        foodstyleob.setFoodprice(price);
        foodstyleob.setImageurl(foodimgFileName);
        foodstyleob.setFoodtab(foodtab);
        foodstyleob.setFdstystate(state);       
        fsd.addFoodStyle(foodstyleob);

        String path= ServletActionContext.getServletContext().getRealPath("/");

       //保存上传文件

       FileUtil.copyFile(foodimg, path+"/images/"+foodimgFileName);

       return SUCCESS;

    }

HttpClient程序包是一个实现了 HTTP 协议的客户端编程工具包，要想熟练的掌握它，必须熟悉 HTTP协议。一个最简单的调用如下：

01. import java.io.IOException;

02. import org.apache.http.HttpResponse;

03. import org.apache.http.client.ClientProtocolException;

04. import org.apache.http.client.HttpClient;

05. import org.apache.http.client.methods.HttpGet;

06. import org.apache.http.client.methods.HttpUriRequest;

07. import org.apache.http.impl.client.DefaultHttpClient;

08.  

09. public class Test {

10. public static void main(String[] args) {

11.  

12. // 核心应用类

13. HttpClient httpClient = new DefaultHttpClient();

14.  

15. // HTTP请求

16. HttpUriRequest request =

17. new HttpGet("http://localhost/index.html");

18.  

19. // 打印请求信息

20. System.out.println(request.getRequestLine());

21. try {

22. // 发送请求，返回响应

23. HttpResponse response = httpClient.execute(request);

24.  

25. // 打印响应信息

26. System.out.println(response.getStatusLine());

27. } catch (ClientProtocolException e) {

28. // 协议错误

29. e.printStackTrace();

30. } catch (IOException e) {

31. // 网络异常

32. e.printStackTrace();

33. }

34. }

35. }

如果HTTP服务器正常并且存在相应的服务，则上例会打印出两行结果：

GET http://localhost/index.html HTTP/1.1
HTTP/1.1 200 OK

核心对象httpClient的调用非常直观，其execute方法传入一个request对象，返回一个response对象。使用httpClient发出HTTP请求时，系统可能抛出两种异常，分别是ClientProtocolException和IOException。第一种异常的发生通常是协议错误导致，如在构造HttpGet对象时传入的协议不对（例如不小心将”http”写成”htp”），或者服务器端返回的内容不符合HTTP协议要求等；第二种异常一般是由于网络原因引起的异常，如HTTP服务器未启动等。
从实际应用的角度看，HTTP协议由两大部分组成：HTTP请求和HTTP响应。那么HttpClient程序包是如何实现HTTP客户端应用的呢？实现过程中需要注意哪些问题呢？

HTTP请求

HTTP 1.1由以下几种请求组成：GET, HEAD, POST, PUT, DELETE, TRACE and OPTIONS， 程序包中分别用HttpGet, HttpHead, HttpPost, HttpPut, HttpDelete, HttpTrace, and HttpOptions 这几个类创建请求。所有的这些类均实现了HttpUriRequest接口，故可以作为execute的执行参数使用。
所有请求中最常用的是GET与POST两种请求，与创建GET请求的方法相同，可以用如下方法创建一个POST请求：

1. HttpUriRequest request = new HttpPost(

2. "http://localhost/index.html");

HTTP请求格式告诉我们，有两个位置或者说两种方式可以为request提供参数：request-line方式与request-body方式。

request-line

request-line方式是指在请求行上通过URI直接提供参数。
（1）
我们可以在生成request对象时提供带参数的URI，如：

1. HttpUriRequest request = new HttpGet(

2. "http://localhost/index.html?param1=value1&;param2=value2");

（2）
另外，HttpClient程序包为我们提供了URIUtils工具类，可以通过它生成带参数的URI，如：

1. URI uri = URIUtils.createURI("http", "localhost", -1,"/index.html",

2. "param1=value1&param2=value2", null);

3. HttpUriRequest request = new HttpGet(uri);

4. System.out.println(request.getURI());

上例的打印结果如下：

http://localhost/index.html?param1=value1&param2=value2

（3）
需要注意的是，如果参数中含有中文，需将参数进行URLEncoding处理，如：

1. String param = "param1=" + URLEncoder.encode("中国", "UTF-8") + "&param2=value2";

2. URI uri = URIUtils.createURI("http", "localhost", 8080,

3. "/sshsky/index.html", param, null);

4. System.out.println(uri);

上例的打印结果如下：

http://localhost/index.html?param1=%E4%B8%AD%E5%9B%BD&param2=value2

（4）
对于参数的URLEncoding处理，HttpClient程序包为我们准备了另一个工具类：URLEncodedUtils。通过它，我们可以直观的（但是比较复杂）生成URI，如：

1. List<namevaluepair> params = new ArrayList<namevaluepair>();

2. params.add(new BasicNameValuePair("param1", "中国"));

3. params.add(new BasicNameValuePair("param2", "value2"));

4. String param = URLEncodedUtils.format(params, "UTF-8");

5. URI uri = URIUtils.createURI("http", "localhost", 8080,

6. "/sshsky/index.html", param, null);

7. System.out.println(uri);

8. </namevaluepair></namevaluepair>

上例的打印结果如下：

http://localhost/index.html?param1=%E4%B8%AD%E5%9B%BD&param2=value2

request-body

与request-line方式不同，request-body方式是在request-body中提供参数，此方式只能用于POST请求。在HttpClient程序包中有两个类可以完成此项工作，它们分别是UrlEncodedFormEntity类与MultipartEntity类。这两个类均实现了HttpEntity接口。
（1）
使用最多的是UrlEncodedFormEntity类。通过该类创建的对象可以模拟传统的HTML表单传送POST请求中的参数。如下面的表单：

1. <form action="http://localhost/index.html" method="POST">

2. <input type="text" name="param1" value="中国"/>

3. <input type="text" name="param2" value="value2"/>

4. <inupt type="submit" value="submit"/>

5. </form>

我们可以用下面的代码实现：

1. List<namevaluepair> formParams = new ArrayList<namevaluepair>();

2. formParams.add(new BasicNameValuePair("param1", "中国"));

3. formParams.add(new BasicNameValuePair("param2", "value2"));

4. HttpEntity entity = new UrlEncodedFormEntity(formParams, "UTF-8");

5.  

6. HttpPost request = newHttpPost(“http://localhost/index.html”);

7. request.setEntity(entity);

8. </namevaluepair></namevaluepair>

当然，如果想查看HTTP数据格式，可以通过HttpEntity对象的各种方法取得。如：

01. List<namevaluepair> formParams = new ArrayList<namevaluepair>();

02. formParams.add(new BasicNameValuePair("param1", "中国"));

03. formParams.add(new BasicNameValuePair("param2", "value2"));

04. UrlEncodedFormEntity entity = newUrlEncodedFormEntity(formParams, "UTF-8");

05.  

06. System.out.println(entity.getContentType());

07. System.out.println(entity.getContentLength());

08. System.out.println(EntityUtils.getContentCharSet(entity));

09. System.out.println(EntityUtils.toString(entity));

10. </namevaluepair></namevaluepair>

上例的打印结果如下：

Content-Type: application/x-www-form-urlencoded; charset=UTF-8
39
UTF-8
param1=%E4%B8%AD%E5%9B%BD&param2=value2

（2）
除了传统的application/x-www-form-urlencoded表单，我们另一个经常用到的是上传文件用的表单，这种表单的类型为multipart/form-data。在HttpClient程序扩展包（HttpMime）中专门有一个类与之对应，那就是MultipartEntity类。此类同样实现了HttpEntity接口。如下面的表单：

1. <form action="http://localhost/index.html" method="POST"

2. enctype="multipart/form-data">

3. <input type="text" name="param1" value="中国"/>

4. <input type="text" name="param2" value="value2"/>

5. <input type="file" name="param3"/>

6. <inupt type="submit" value="submit"/>

7. </form>

我们可以用下面的代码实现：

1. MultipartEntity entity = new MultipartEntity();

2. entity.addPart("param1", new StringBody("中国", Charset.forName("UTF-8")));

3. entity.addPart("param2", new StringBody("value2", Charset.forName("UTF-8")));

4. entity.addPart("param3", new FileBody(new File("C:\\1.txt")));

5.  

6. HttpPost request = newHttpPost(“http://localhost/index.html”);

7. request.setEntity(entity);

HTTP响应

HttpClient程序包对于HTTP响应的处理较之HTTP请求来说是简单多了，其过程同样使用了HttpEntity接口。我们可以从HttpEntity对象中取出数据流（InputStream），该数据流就是服务器返回的响应数据。需要注意的是，HttpClient程序包不负责解析数据流中的内容。如：

01. HttpUriRequest request = ...;

02. HttpResponse response = httpClient.execute(request);

03.  

04. // 从response中取出HttpEntity对象

05. HttpEntity entity = response.getEntity();

06.  

07. // 查看entity的各种指标

08. System.out.println(entity.getContentType());

09. System.out.println(entity.getContentLength());

10. System.out.println(EntityUtils.getContentCharSet(entity));

11.  

12. // 取出服务器返回的数据流

13. InputStream stream = entity.getContent();

14.  

15. // 以任意方式操作数据流stream

16. // 调用方式 略

附注：

本文说明的是HttpClient 4.0.1，该程序包（包括依赖的程序包）由以下几个JAR包组成：

commons-logging-1.1.1.jar
commons-codec-1.4.jar
httpcore-4.0.1.jar
httpclient-4.0.1.jar
apache-mime4j-0.6.jar
httpmime-4.0.1.jar