Java Http下载文件到本地

1. 1. package com.proxy.util;  
   2.   
   3. import java.io.BufferedOutputStream;  
   4. import java.io.File;  
   5. import java.io.FileOutputStream;  
   6. import java.io.IOException;  
   7. import java.io.UnsupportedEncodingException;  
   8. import java.net.URLEncoder;  
   9. import java.util.ArrayList;  
   10. import java.util.List;  
   11. import java.util.Map;  
   12.   
   13. import org.apache.http.Header;  
   14. import org.apache.http.HttpResponse;  
   15. import org.apache.http.HttpStatus;  
   16. import org.apache.http.NameValuePair;  
   17. import org.apache.http.client.ClientProtocolException;  
   18. import org.apache.http.client.HttpClient;  
   19. import org.apache.http.client.entity.UrlEncodedFormEntity;  
   20. import org.apache.http.client.methods.HttpGet;  
   21. import org.apache.http.client.methods.HttpPost;  
   22. import org.apache.http.client.methods.HttpUriRequest;  
   23. import org.apache.http.impl.client.DefaultHttpClient;  
   24. import org.apache.http.message.BasicNameValuePair;  
   25. import org.apache.http.params.CoreConnectionPNames;  
   26. import org.apache.http.util.EntityUtils;  
   27. import org.slf4j.Logger;  
   28. import org.slf4j.LoggerFactory;  
   29.   
   30. import com.anxin.common.util.SSLUtil;  
   31.   
   32. /** 
   33.  * HTTP工具类. 
   34.  *  
   35.  * @author David.Huang 
   36.  */  
   37. public class HttpUtil {  
   38.   
   39.     private static Logger log = LoggerFactory.getLogger(HttpUtil.class);  
   40.   
   41.     /** 默认编码方式 -UTF8 */  
   42.     private static final String DEFAULT_ENCODE = "utf-8";  
   43.   
   44.     // 信任所有站点  
   45.     static {  
   46.         SSLUtil.trustAllHostnames();  
   47.         SSLUtil.trustAllHttpsCertificates();  
   48.     }  
   49.   
   50.     /** 
   51.      * 构造方法 
   52.      */  
   53.     public HttpUtil() {  
   54.         // empty constructor for some tools that need an instance object of the  
   55.         // class  
   56.     }  
   57.   
   58.     /** 
   59.      * GET请求, 结果以字符串形式返回. 
   60.      *  
   61.      * @param url 
   62.      *            请求地址 
   63.      * @return 内容字符串 
   64.      */  
   65.     public static String getUrlAsString(String url) throws Exception {  
   66.         return getUrlAsString(url, null, DEFAULT_ENCODE);  
   67.     }  
   68.   
   69.     /** 
   70.      * GET请求, 结果以字符串形式返回. 
   71.      *  
   72.      * @param url 
   73.      *            请求地址 
   74.      * @param params 
   75.      *            请求参数 
   76.      * @return 内容字符串 
   77.      */  
   78.     public static String getUrlAsString(String url, Map<String, String> params)  
   79.             throws Exception {  
   80.         return getUrlAsString(url, params, DEFAULT_ENCODE);  
   81.     }  
   82.   
   83.     /** 
   84.      * GET请求, 结果以字符串形式返回. 
   85.      *  
   86.      * @param url 
   87.      *            请求地址 
   88.      * @param params 
   89.      *            请求参数 
   90.      * @param encode 
   91.      *            编码方式 
   92.      * @return 内容字符串 
   93.      */  
   94.     public static String getUrlAsString(String url, Map<String, String> params,  
   95.             String encode) throws Exception {  
   96.         // 开始时间  
   97.         long t1 = System.currentTimeMillis();  
   98.         // 获得HttpGet对象  
   99.         HttpGet httpGet = getHttpGet(url, params, encode);  
   100.         // 调试信息  
   101.         log.debug("url:" + url);  
   102.         log.debug("params:" + params.toString());  
   103.         log.debug("encode:" + encode);  
   104.         // 发送请求  
   105.         String result = executeHttpRequest(httpGet, null);  
   106.         // 结束时间  
   107.         long t2 = System.currentTimeMillis();  
   108.         // 调试信息  
   109.         log.debug("result:" + result);  
   110.         log.debug("consume time:" + ((t2 - t1)));  
   111.         // 返回结果  
   112.         return result;  
   113.     }  
   114.   
   115.     /** 
   116.      * POST请求, 结果以字符串形式返回. 
   117.      *  
   118.      * @param url 
   119.      *            请求地址 
   120.      * @return 内容字符串 
   121.      */  
   122.     public static String postUrlAsString(String url) throws Exception {  
   123.         return postUrlAsString(url, null, null, null);  
   124.     }  
   125.   
   126.     /** 
   127.      * POST请求, 结果以字符串形式返回. 
   128.      *  
   129.      * @param url 
   130.      *            请求地址 
   131.      * @param params 
   132.      *            请求参数 
   133.      * @return 内容字符串 
   134.      */  
   135.     public static String postUrlAsString(String url, Map<String, String> params)  
   136.             throws Exception {  
   137.         return postUrlAsString(url, params, null, null);  
   138.     }  
   139.   
   140.     /** 
   141.      * POST请求, 结果以字符串形式返回. 
   142.      *  
   143.      * @param url 
   144.      *            请求地址 
   145.      * @param params 
   146.      *            请求参数 
   147.      * @param reqHeader 
   148.      *            请求头内容 
   149.      * @return 内容字符串 
   150.      * @throws Exception 
   151.      */  
   152.     public static String postUrlAsString(String url,  
   153.             Map<String, String> params, Map<String, String> reqHeader)  
   154.             throws Exception {  
   155.         return postUrlAsString(url, params, reqHeader, null);  
   156.     }  
   157.   
   158.     /** 
   159.      * POST请求, 结果以字符串形式返回. 
   160.      *  
   161.      * @param url 
   162.      *            请求地址 
   163.      * @param params 
   164.      *            请求参数 
   165.      * @param reqHeader 
   166.      *            请求头内容 
   167.      * @param encode 
   168.      *            编码方式 
   169.      * @return 内容字符串 
   170.      * @throws Exception 
   171.      */  
   172.     public static String postUrlAsString(String url,  
   173.             Map<String, String> params, Map<String, String> reqHeader,  
   174.             String encode) throws Exception {  
   175.         // 开始时间  
   176.         long t1 = System.currentTimeMillis();  
   177.         // 获得HttpPost对象  
   178.         HttpPost httpPost = getHttpPost(url, params, encode);  
   179.         // 发送请求  
   180.         String result = executeHttpRequest(httpPost, reqHeader);  
   181.         // 结束时间  
   182.         long t2 = System.currentTimeMillis();  
   183.         // 调试信息  
   184.         log.debug("url:" + url);  
   185.         log.debug("params:" + params.toString());  
   186.         log.debug("reqHeader:" + reqHeader);  
   187.         log.debug("encode:" + encode);  
   188.         log.debug("result:" + result);  
   189.         log.debug("consume time:" + ((t2 - t1)));  
   190.         // 返回结果  
   191.         return result;  
   192.     }  
   193.   
   194.     /** 
   195.      * 获得HttpGet对象 
   196.      *  
   197.      * @param url 
   198.      *            请求地址 
   199.      * @param params 
   200.      *            请求参数 
   201.      * @param encode 
   202.      *            编码方式 
   203.      * @return HttpGet对象 
   204.      */  
   205.     private static HttpGet getHttpGet(String url, Map<String, String> params,  
   206.             String encode) {  
   207.         StringBuffer buf = new StringBuffer(url);  
   208.         if (params != null) {  
   209.             // 地址增加?或者&  
   210.             String flag = (url.indexOf('?') == -1) ? "?" : "&";  
   211.             // 添加参数  
   212.             for (String name : params.keySet()) {  
   213.                 buf.append(flag);  
   214.                 buf.append(name);  
   215.                 buf.append("=");  
   216.                 try {  
   217.                     String param = params.get(name);  
   218.                     if (param == null) {  
   219.                         param = "";  
   220.                     }  
   221.                     buf.append(URLEncoder.encode(param, encode));  
   222.                 } catch (UnsupportedEncodingException e) {  
   223.                     log.error("URLEncoder Error,encode=" + encode + ",param="  
   224.                             + params.get(name), e);  
   225.                 }  
   226.                 flag = "&";  
   227.             }  
   228.         }  
   229.         HttpGet httpGet = new HttpGet(buf.toString());  
   230.         return httpGet;  
   231.     }  
   232.   
   233.     /** 
   234.      * 获得HttpPost对象 
   235.      *  
   236.      * @param url 
   237.      *            请求地址 
   238.      * @param params 
   239.      *            请求参数 
   240.      * @param encode 
   241.      *            编码方式 
   242.      * @return HttpPost对象 
   243.      */  
   244.     private static HttpPost getHttpPost(String url, Map<String, String> params,  
   245.             String encode) {  
   246.         HttpPost httpPost = new HttpPost(url);  
   247.         if (params != null) {  
   248.             List<NameValuePair> form = new ArrayList<NameValuePair>();  
   249.             for (String name : params.keySet()) {  
   250.                 form.add(new BasicNameValuePair(name, params.get(name)));  
   251.             }  
   252.             try {  
   253.                 UrlEncodedFormEntity entity = new UrlEncodedFormEntity(form,  
   254.                         encode);  
   255.                 httpPost.setEntity(entity);  
   256.             } catch (UnsupportedEncodingException e) {  
   257.                 log.error("UrlEncodedFormEntity Error,encode=" + encode  
   258.                         + ",form=" + form, e);  
   259.             }  
   260.         }  
   261.         return httpPost;  
   262.     }  
   263.   
   264.     /** 
   265.      * 执行HTTP请求 
   266.      *  
   267.      * @param request 
   268.      *            请求对象 
   269.      * @param reqHeader 
   270.      *            请求头信息 
   271.      * @return 内容字符串 
   272.      */  
   273.     private static String executeHttpRequest(HttpUriRequest request,  
   274.             Map<String, String> reqHeader) throws Exception {  
   275.         HttpClient client = null;  
   276.         String result = null;  
   277.         try {  
   278.             // 创建HttpClient对象  
   279.             client = new DefaultHttpClient();  
   280.             // 设置连接超时时间  
   281.             client.getParams().setParameter(  
   282.                     CoreConnectionPNames.CONNECTION_TIMEOUT, 60);  
   283.             // 设置Socket超时时间  
   284.             client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT,  
   285.                     36600);  
   286.             // 设置请求头信息  
   287.             if (reqHeader != null) {  
   288.                 for (String name : reqHeader.keySet()) {  
   289.                     request.addHeader(name, reqHeader.get(name));  
   290.                 }  
   291.             }  
   292.             // 获得返回结果  
   293.             HttpResponse response = client.execute(request);  
   294.             // 如果成功  
   295.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {  
   296.                 result = EntityUtils.toString(response.getEntity());  
   297.             }  
   298.             // 如果失败  
   299.             else {  
   300.                 StringBuffer errorMsg = new StringBuffer();  
   301.                 errorMsg.append("httpStatus:");  
   302.                 errorMsg.append(response.getStatusLine().getStatusCode());  
   303.                 errorMsg.append(response.getStatusLine().getReasonPhrase());  
   304.                 errorMsg.append(", Header: ");  
   305.                 Header[] headers = response.getAllHeaders();  
   306.                 for (Header header : headers) {  
   307.                     errorMsg.append(header.getName());  
   308.                     errorMsg.append(":");  
   309.                     errorMsg.append(header.getValue());  
   310.                 }  
   311.                 log.error("HttpResonse Error:" + errorMsg);  
   312.             }  
   313.         } catch (Exception e) {  
   314.             log.error("http连接异常", e);  
   315.             throw new Exception("http连接异常");  
   316.         } finally {  
   317.             try {  
   318.                 client.getConnectionManager().shutdown();  
   319.             } catch (Exception e) {  
   320.                 log.error("finally HttpClient shutdown error", e);  
   321.             }  
   322.         }  
   323.         return result;  
   324.     }  
   325.   
   326.     /** 
   327.      * 下载文件保存到本地 
   328.      *  
   329.      * @param path 
   330.      *            文件保存位置 
   331.      * @param url 
   332.      *            文件地址 
   333.      * @throws IOException 
   334.      */  
   335.     public static void downloadFile(String path, String url) throws IOException {  
   336.         log.debug("path:" + path);  
   337.         log.debug("url:" + url);  
   338.         HttpClient client = null;  
   339.         try {  
   340.             // 创建HttpClient对象  
   341.             client = new DefaultHttpClient();  
   342.             // 获得HttpGet对象  
   343.             HttpGet httpGet = getHttpGet(url, null, null);  
   344.             // 发送请求获得返回结果  
   345.             HttpResponse response = client.execute(httpGet);  
   346.             // 如果成功  
   347.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {  
   348.                 byte[] result = EntityUtils.toByteArray(response.getEntity());  
   349.                 BufferedOutputStream bw = null;  
   350.                 try {  
   351.                     // 创建文件对象  
   352.                     File f = new File(path);  
   353.                     // 创建文件路径  
   354.                     if (!f.getParentFile().exists())  
   355.                         f.getParentFile().mkdirs();  
   356.                     // 写入文件  
   357.                     bw = new BufferedOutputStream(new FileOutputStream(path));  
   358.                     bw.write(result);  
   359.                 } catch (Exception e) {  
   360.                     log.error("保存文件错误,path=" + path + ",url=" + url, e);  
   361.                 } finally {  
   362.                     try {  
   363.                         if (bw != null)  
   364.                             bw.close();  
   365.                     } catch (Exception e) {  
   366.                         log.error(  
   367.                                 "finally BufferedOutputStream shutdown close",  
   368.                                 e);  
   369.                     }  
   370.                 }  
   371.             }  
   372.             // 如果失败  
   373.             else {  
   374.                 StringBuffer errorMsg = new StringBuffer();  
   375.                 errorMsg.append("httpStatus:");  
   376.                 errorMsg.append(response.getStatusLine().getStatusCode());  
   377.                 errorMsg.append(response.getStatusLine().getReasonPhrase());  
   378.                 errorMsg.append(", Header: ");  
   379.                 Header[] headers = response.getAllHeaders();  
   380.                 for (Header header : headers) {  
   381.                     errorMsg.append(header.getName());  
   382.                     errorMsg.append(":");  
   383.                     errorMsg.append(header.getValue());  
   384.                 }  
   385.                 log.error("HttpResonse Error:" + errorMsg);  
   386.             }  
   387.         } catch (ClientProtocolException e) {  
   388.             log.error("下载文件保存到本地,http连接异常,path=" + path + ",url=" + url, e);  
   389.             throw e;  
   390.         } catch (IOException e) {  
   391.             log.error("下载文件保存到本地,文件操作异常,path=" + path + ",url=" + url, e);  
   392.             throw e;  
   393.         } finally {  
   394.             try {  
   395.                 client.getConnectionManager().shutdown();  
   396.             } catch (Exception e) {  
   397.                 log.error("finally HttpClient shutdown error", e);  
   398.             }  
   399.         }  
   400.     }  
   401.   
   402.     public static void main(String[] args) throws IOException {  
   403.         // String result = getUrlAsString("http://www.gewara.com/");  
   404.         // System.out.println(result);  
   405.         downloadFile("F:/logo3w.png",  
   406.             "http://www.google.com.hk/images/srpr/logo3w.png");  
   407.     }  
   408. }