封装 HttpURLConnection

最新推荐文章于 2022-05-18 13:39:57 发布
最新推荐文章于 2022-05-18 13:39:57 发布
阅读量83 收藏
点赞数
文章标签： java

HttpURLConnection为javaAPI提供的一种Rest访问的方式。其支持对Post,Delete,Get,Put等方式的访问。

以下为对于HttpURLConnection对Post等方式访问的一段代码。

view plain copy to clipboard print ?
  1. packagecom.sw.study.urlConnection;
  3. importjava.io.BufferedReader;
  4. importjava.io.InputStreamReader;
  5. importjava.io.OutputStream;
  6. importjava.net.HttpURLConnection;
  7. importjava.net.URL;
  8. importjava.net.URLConnection;
  9. importjava.util.HashMap;
  10. importjava.util.Map;
  12. publicclassURLConnectionUtil{
  14. privatestaticfinalStringSERVLET_POST="POST";
  15. privatestaticfinalStringSERVLET_GET="GET";
  16. privatestaticfinalStringSERVLET_DELETE="DELETE";
  17. privatestaticfinalStringSERVLET_PUT="PUT";
  19. privatestaticStringprepareParam(Map<String,Object>paramMap){
  20. StringBuffersb=newStringBuffer();
  21. if(paramMap.isEmpty()){
  22. return"";
  23. }else{
  24. for(Stringkey:paramMap.keySet()){
  25. Stringvalue=(String)paramMap.get(key);
  26. if(sb.length()<1){
  27. sb.append(key).append("=").append(value);
  28. }else{
  29. sb.append("&").append(key).append("=").append(value);
  30. }
  31. }
  32. returnsb.toString();
  33. }
  34. }
  36. publicstaticvoiddoPost(StringurlStr,Map<String,Object>paramMap)throwsException{
  37. URLurl=newURL(urlStr);
  38. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  39. conn.setRequestMethod(SERVLET_POST);
  40. StringparamStr=prepareParam(paramMap);
  41. conn.setDoInput(true);
  42. conn.setDoOutput(true);
  43. OutputStreamos=conn.getOutputStream();
  44. os.write(paramStr.toString().getBytes("utf-8"));
  45. os.close();
  47. BufferedReaderbr=newBufferedReader(newInputStreamReader(conn.getInputStream()));
  48. Stringline;
  49. Stringresult="";
  50. while((line=br.readLine())!=null){
  51. result+="/n"+line;
  52. }
  53. System.out.println(result);
  54. br.close();
  56. }
  58. publicstaticvoiddoGet(StringurlStr,Map<String,Object>paramMap)throwsException{
  59. StringparamStr=prepareParam(paramMap);
  60. if(paramStr==null||paramStr.trim().length()<1){
  62. }else{
  63. urlStr+="?"+paramStr;
  64. }
  65. System.out.println(urlStr);
  66. URLurl=newURL(urlStr);
  67. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  68. conn.setRequestMethod(SERVLET_PUT);
  69. conn.setRequestProperty("Content-Type","text/html;charset=UTF-8");
  71. conn.connect();
  72. BufferedReaderbr=newBufferedReader(newInputStreamReader(conn.getInputStream()));
  73. Stringline;
  74. Stringresult="";
  75. while((line=br.readLine())!=null){
  76. result+="/n"+line;
  77. }
  78. System.out.println(result);
  79. br.close();
  80. }
  82. publicstaticvoiddoPut(StringurlStr,Map<String,Object>paramMap)throwsException{
  83. URLurl=newURL(urlStr);
  84. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  85. conn.setRequestMethod(SERVLET_PUT);
  86. StringparamStr=prepareParam(paramMap);
  87. conn.setDoInput(true);
  88. conn.setDoOutput(true);
  89. OutputStreamos=conn.getOutputStream();
  90. os.write(paramStr.toString().getBytes("utf-8"));
  91. os.close();
  93. BufferedReaderbr=newBufferedReader(newInputStreamReader(conn.getInputStream()));
  94. Stringline;
  95. Stringresult="";
  96. while((line=br.readLine())!=null){
  97. result+="/n"+line;
  98. }
  99. System.out.println(result);
  100. br.close();
  102. }
  104. publicstaticvoiddoDelete(StringurlStr,Map<String,Object>paramMap)throwsException{
  105. StringparamStr=prepareParam(paramMap);
  106. if(paramStr==null||paramStr.trim().length()<1){
  108. }else{
  109. urlStr+="?"+paramStr;
  110. }
  111. System.out.println(urlStr);
  112. URLurl=newURL(urlStr);
  113. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  114. conn.setDoOutput(true);
  115. conn.setRequestMethod(SERVLET_DELETE);
  116. //屏蔽掉的代码是错误的，java.net.ProtocolException:HTTPmethodDELETEdoesn'tsupportoutput
  117. /*OutputStreamos=conn.getOutputStream();
  118. os.write(paramStr.toString().getBytes("utf-8"));
  119. os.close();*/
  121. if(conn.getResponseCode()==200){
  122. System.out.println("成功");
  123. }else{
  124. System.out.println(conn.getResponseCode());
  125. }
  126. }
  128. publicstaticvoidmain(String[]args)throwsException{
  129. StringurlStr="http://localhost:8080/SwTest/ReceiveDataServlet";
  130. Map<String,Object>map=newHashMap<String,Object>();
  131. map.put("username","张三");
  132. map.put("password","88888");
  133. //URLConnectionUtil.doGet(urlStr,map);
  134. //URLConnectionUtil.doPost(urlStr,map);
  135. //URLConnectionUtil.doPut(urlStr,map);
  136. URLConnectionUtil.doDelete(urlStr,map);
  138. }
  141. }

view plain
  1. packagecom.sw.study.urlConnection;
  2. importjava.io.BufferedReader;
  3. importjava.io.InputStreamReader;
  4. importjava.io.OutputStream;
  5. importjava.net.HttpURLConnection;
  6. importjava.net.URL;
  7. importjava.net.URLConnection;
  8. importjava.util.HashMap;
  9. importjava.util.Map;
  10. publicclassURLConnectionUtil{
  12. privatestaticfinalStringSERVLET_POST="POST";
  13. privatestaticfinalStringSERVLET_GET="GET";
  14. privatestaticfinalStringSERVLET_DELETE="DELETE";
  15. privatestaticfinalStringSERVLET_PUT="PUT";
  17. privatestaticStringprepareParam(Map<String,Object>paramMap){
  18. StringBuffersb=newStringBuffer();
  19. if(paramMap.isEmpty()){
  20. return"";
  21. }else{
  22. for(Stringkey:paramMap.keySet()){
  23. Stringvalue=(String)paramMap.get(key);
  24. if(sb.length()<1){
  25. sb.append(key).append("=").append(value);
  26. }else{
  27. sb.append("&").append(key).append("=").append(value);
  28. }
  29. }
  30. returnsb.toString();
  31. }
  32. }
  34. publicstaticvoiddoPost(StringurlStr,Map<String,Object>paramMap)throwsException{
  35. URLurl=newURL(urlStr);
  36. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  37. conn.setRequestMethod(SERVLET_POST);
  38. StringparamStr=prepareParam(paramMap);
  39. conn.setDoInput(true);
  40. conn.setDoOutput(true);
  41. OutputStreamos=conn.getOutputStream();
  42. os.write(paramStr.toString().getBytes("utf-8"));
  43. os.close();
  45. BufferedReaderbr=newBufferedReader(newInputStreamReader(conn.getInputStream()));
  46. Stringline;
  47. Stringresult="";
  48. while((line=br.readLine())!=null){
  49. result+="/n"+line;
  50. }
  51. System.out.println(result);
  52. br.close();
  54. }
  56. publicstaticvoiddoGet(StringurlStr,Map<String,Object>paramMap)throwsException{
  57. StringparamStr=prepareParam(paramMap);
  58. if(paramStr==null||paramStr.trim().length()<1){
  60. }else{
  61. urlStr+="?"+paramStr;
  62. }
  63. System.out.println(urlStr);
  64. URLurl=newURL(urlStr);
  65. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  66. conn.setRequestMethod(SERVLET_PUT);
  67. conn.setRequestProperty("Content-Type","text/html;charset=UTF-8");
  69. conn.connect();
  70. BufferedReaderbr=newBufferedReader(newInputStreamReader(conn.getInputStream()));
  71. Stringline;
  72. Stringresult="";
  73. while((line=br.readLine())!=null){
  74. result+="/n"+line;
  75. }
  76. System.out.println(result);
  77. br.close();
  78. }
  80. publicstaticvoiddoPut(StringurlStr,Map<String,Object>paramMap)throwsException{
  81. URLurl=newURL(urlStr);
  82. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  83. conn.setRequestMethod(SERVLET_PUT);
  84. StringparamStr=prepareParam(paramMap);
  85. conn.setDoInput(true);
  86. conn.setDoOutput(true);
  87. OutputStreamos=conn.getOutputStream();
  88. os.write(paramStr.toString().getBytes("utf-8"));
  89. os.close();
  91. BufferedReaderbr=newBufferedReader(newInputStreamReader(conn.getInputStream()));
  92. Stringline;
  93. Stringresult="";
  94. while((line=br.readLine())!=null){
  95. result+="/n"+line;
  96. }
  97. System.out.println(result);
  98. br.close();
  100. }
  102. publicstaticvoiddoDelete(StringurlStr,Map<String,Object>paramMap)throwsException{
  103. StringparamStr=prepareParam(paramMap);
  104. if(paramStr==null||paramStr.trim().length()<1){
  106. }else{
  107. urlStr+="?"+paramStr;
  108. }
  109. System.out.println(urlStr);
  110. URLurl=newURL(urlStr);
  111. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  112. conn.setDoOutput(true);
  113. conn.setRequestMethod(SERVLET_DELETE);
  114. //屏蔽掉的代码是错误的，java.net.ProtocolException:HTTPmethodDELETEdoesn'tsupportoutput
  115. /*OutputStreamos=conn.getOutputStream();
  116. os.write(paramStr.toString().getBytes("utf-8"));
  117. os.close();*/
  119. if(conn.getResponseCode()==200){
  120. System.out.println("成功");
  121. }else{
  122. System.out.println(conn.getResponseCode());
  123. }
  124. }
  126. publicstaticvoidmain(String[]args)throwsException{
  127. StringurlStr="http://localhost:8080/SwTest/ReceiveDataServlet";
  128. Map<String,Object>map=newHashMap<String,Object>();
  129. map.put("username","张三");
  130. map.put("password","88888");
  131. //URLConnectionUtil.doGet(urlStr,map);
  132. //URLConnectionUtil.doPost(urlStr,map);
  133. //URLConnectionUtil.doPut(urlStr,map);
  134. URLConnectionUtil.doDelete(urlStr,map);
  136. }
  139. }

方法中是存在重复的。有些方法是可以通过参数的改变来达到统一，但是那样的做法对于程序的扩展性会有很大的局限性。

还是对于每一种方式提供一个单独的方法进行访问比较好。

在Servlet端，获取参数可以通过

request.getInputStream,及request.getParamter来进行。

其中，当Rest访问传入参数是通过conn的outputStream来进行的，可以通过request.getInputStream来进行参数获取（Post方式可通用）；

当以url?key=value方法传递参数时，可以通过request.getParamter来进行参数获取。（Post方式可通用）

其中request.getInputStream和request.getParamter两种方式不能同时出现。当request.getParamter运行的过程，也是输入流的读取过程。当输入流读取完成后，再次调用时无效的。

附上Servlet端程序

view plain copy to clipboard print ?
  1. packagecom.sw.servlet;
  3. importjava.io.BufferedReader;
  4. importjava.io.IOException;
  5. importjava.io.InputStreamReader;
  6. importjava.io.OutputStream;
  8. importjavax.servlet.ServletException;
  9. importjavax.servlet.ServletInputStream;
  10. importjavax.servlet.http.HttpServlet;
  11. importjavax.servlet.http.HttpServletRequest;
  12. importjavax.servlet.http.HttpServletResponse;
  14. /**
  15. *ServletimplementationclassReceiveDataServlet
  16. */
  17. publicclassReceiveDataServletextendsHttpServlet{
  18. privatestaticfinallongserialVersionUID=1L;
  20. /**
  21. *@seeHttpServlet#HttpServlet()
  22. */
  23. publicReceiveDataServlet(){
  24. super();
  25. //TODOAuto-generatedconstructorstub
  26. }
  28. /**
  29. *@seeHttpServlet#doGet(HttpServletRequestrequest,HttpServletResponseresponse)
  30. */
  31. protectedvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)throwsServletException,IOException{
  32. System.out.println("----------get--------------");
  33. Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  34. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  35. System.out.println(username);
  36. System.out.println(password);
  37. OutputStreamos=response.getOutputStream();
  38. os.write("get".getBytes("utf-8"));
  39. }
  41. /**
  42. *@seeHttpServlet#doPost(HttpServletRequestrequest,HttpServletResponseresponse)
  43. */
  44. protectedvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse)throwsServletException,IOException{
  45. System.out.println("----------post--------------");
  46. BufferedReaderbr=newBufferedReader(newInputStreamReader((ServletInputStream)request.getInputStream()));
  47. Stringline=null;
  48. StringBuildersb=newStringBuilder();
  49. while((line=br.readLine())!=null){
  50. sb.append(line);
  51. }
  52. System.out.println(sb.toString());
  53. br.close();
  54. /*Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  55. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  56. System.out.println(username);
  57. System.out.println(password);
  58. */OutputStreamos=response.getOutputStream();
  59. os.write("post".getBytes("utf-8"));
  60. }
  62. @Override
  63. protectedvoiddoDelete(HttpServletRequestrequest,HttpServletResponseresponse)
  64. throwsServletException,IOException{
  65. System.out.println("----------delete--------------");
  66. Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  67. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  68. System.out.println(username);
  69. System.out.println(password);
  70. OutputStreamos=response.getOutputStream();
  71. os.write("delete".getBytes("utf-8"));
  72. }
  74. @Override
  75. protectedvoiddoPut(HttpServletRequestrequest,HttpServletResponseresponse)
  76. throwsServletException,IOException{
  77. System.out.println("----------put--------------");
  79. /*BufferedReaderbr=newBufferedReader(newInputStreamReader((ServletInputStream)request.getInputStream()));
  80. Stringline=null;
  81. StringBuildersb=newStringBuilder();
  82. while((line=br.readLine())!=null){
  83. sb.append(line);
  84. }
  85. System.out.println(sb.toString());
  86. br.close();*/
  88. Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  89. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  90. System.out.println(username);
  91. System.out.println(password);
  92. OutputStreamos=response.getOutputStream();
  93. os.write("put".getBytes("utf-8"));
  94. }
  96. }

view plain
  1. packagecom.sw.servlet;
  2. importjava.io.BufferedReader;
  3. importjava.io.IOException;
  4. importjava.io.InputStreamReader;
  5. importjava.io.OutputStream;
  6. importjavax.servlet.ServletException;
  7. importjavax.servlet.ServletInputStream;
  8. importjavax.servlet.http.HttpServlet;
  9. importjavax.servlet.http.HttpServletRequest;
  10. importjavax.servlet.http.HttpServletResponse;
  11. /**
  12. *ServletimplementationclassReceiveDataServlet
  13. */
  14. publicclassReceiveDataServletextendsHttpServlet{
  15. privatestaticfinallongserialVersionUID=1L;
  17. /**
  18. *@seeHttpServlet#HttpServlet()
  19. */
  20. publicReceiveDataServlet(){
  21. super();
  22. //TODOAuto-generatedconstructorstub
  23. }
  24. /**
  25. *@seeHttpServlet#doGet(HttpServletRequestrequest,HttpServletResponseresponse)
  26. */
  27. protectedvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)throwsServletException,IOException{
  28. System.out.println("----------get--------------");
  29. Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  30. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  31. System.out.println(username);
  32. System.out.println(password);
  33. OutputStreamos=response.getOutputStream();
  34. os.write("get".getBytes("utf-8"));
  35. }
  36. /**
  37. *@seeHttpServlet#doPost(HttpServletRequestrequest,HttpServletResponseresponse)
  38. */
  39. protectedvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse)throwsServletException,IOException{
  40. System.out.println("----------post--------------");
  41. BufferedReaderbr=newBufferedReader(newInputStreamReader((ServletInputStream)request.getInputStream()));
  42. Stringline=null;
  43. StringBuildersb=newStringBuilder();
  44. while((line=br.readLine())!=null){
  45. sb.append(line);
  46. }
  47. System.out.println(sb.toString());
  48. br.close();
  49. /*Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  50. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  51. System.out.println(username);
  52. System.out.println(password);
  53. */OutputStreamos=response.getOutputStream();
  54. os.write("post".getBytes("utf-8"));
  55. }
  57. @Override
  58. protectedvoiddoDelete(HttpServletRequestrequest,HttpServletResponseresponse)
  59. throwsServletException,IOException{
  60. System.out.println("----------delete--------------");
  61. Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  62. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  63. System.out.println(username);
  64. System.out.println(password);
  65. OutputStreamos=response.getOutputStream();
  66. os.write("delete".getBytes("utf-8"));
  67. }
  69. @Override
  70. protectedvoiddoPut(HttpServletRequestrequest,HttpServletResponseresponse)
  71. throwsServletException,IOException{
  72. System.out.println("----------put--------------");
  74. /*BufferedReaderbr=newBufferedReader(newInputStreamReader((ServletInputStream)request.getInputStream()));
  75. Stringline=null;
  76. StringBuildersb=newStringBuilder();
  77. while((line=br.readLine())!=null){
  78. sb.append(line);
  79. }
  80. System.out.println(sb.toString());
  81. br.close();*/
  83. Stringusername=newString(request.getParameter("username").getBytes("iso-8859-1"),"utf-8");
  84. Stringpassword=newString(request.getParameter("password").getBytes("iso-8859-1"),"utf-8");
  85. System.out.println(username);
  86. System.out.println(password);
  87. OutputStreamos=response.getOutputStream();
  88. os.write("put".getBytes("utf-8"));
  89. }
  90. }

程序中对于request.getInputStream和getParameter的获取方式可能说明的会多少有些问题，我也是通过几组测试后得出的结论。肯定有我没有测试到得。如果有问题，请指出，我会再看到评论后进行测试，修改。

另外，Apache的HttpClient非常好。封装的详细。在我的工作中也用到过，在以后会对于HttpClient进行有些单独的程序笔记。

这里HttpUrlConnection是同事在别的项目中用到的，用法比较简单，我大体给他简单讲解了一下，简明扼要，功能完备，还是很方便，

所以在这里记下来，留个笔记吧。

btw,最近工作比较忙，有2个月没有写些东西了，在工作中确实还遇到了不少有意思的问题，最近刚好快闲下来了，慢慢整理一下。

iteye_2125
关注
简单封装HttpUrlConnection异步请求
u010963053的博客
04-02 2210
package com.zwk.ezandroid.common; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.util.Log; import com.zwk.ezandroid.App; import com.zwk.ezandroid.com...
封装HttpURLConnection和OkHttp
冰之沁泠的博客
07-19 524
通常情况下，我们都将一些通用的网络操作提取到一个公共类里，并提供一个静态方法，当想要发起网络请求的时候，只需要简单的调用一下这个方法即可。 将HttpURLConnection发送网络请求的操作封装在一个公共类中，代码如下： public class HttpUtil { public static void sendHttpRequest(final String address, f...
封装httpurlconnection
04-03
封装httpurlconnection 自己动手丰衣足食
封装HttpURLConnection
Liusuzhi19610221的博客
05-19 164
package com.pingyijinren.test; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; /**...
HttpURLConnection封装
www？的博客
04-04 1002
HttpURLConnection封装 思考： 如果在一个应用程序中需要多次使用网络功能，而发送HTTP请求的代码基本都是相同的，难道我们每次都要去编写一遍发送HTTP请求的代码？ 解决办法：封装 方式一： 将通用的网络操作提取到一个公共类中，外提供一个静态方法。 public class HttpUtil{ //通过sendHttpRequest() 发送HTTP请求 //返回数据类型为String public static String sendHttpRequest(
基于HttpURLConnection的封装http请求
06-23
基于HttpURLConnection的封装http请求，进行了https校验忽略，对get和post进行了整合，更方便请求，对header以及超时的进行了可配置化处理，对返回也进行了封装，便于请求结果的处理。
对Java的HttpURLConnection的封装类
12-22
其实Java内置的HttpURLConnection很好的。HttpComponents不但复杂，而且有小问题。Java API没有内置HttpComponents是应该是有考虑的，HttpURLConnection已经可以了。 　* 基于HttpURLConnection 　* version 1.0.0...
不要再自己封装各种Util工具类了，这款神仙级框架你值得拥有！
HollisChuang's Blog
08-14 623
来源：ryanc.cc/archives/hutool-java-tools-lib作者：Ryan Wang简介Hutool 谐音 “糊涂”，寓意追求 “万事都作糊涂观，无所谓失，无所谓...
Java的HttpURLConnection的封装类 v3.0
12-12
用于对基于HTTP的服务进行抓取 HttpClient 现在是HttpComponents 把问题搞复杂了 其实Java内置的HttpURLConnection很好的 内含文档 使用方法见http://blog.csdn.net/jdgdf566/article/details/17039693
HttpURLConnection的封装
06-08
HttpUrlConnect的封装，我们可以使用HttpRequest来请求一些东西
Java的HttpURLConnection的封装类
11-17
用于对基于HTTP的服务进行抓取 HttpClient 现在是HttpComponents 把问题搞复杂了 其实Java内置的HttpURLConnection很好的 内含文档 使用方法见http: blog csdn net jdgdf566 article details 16357677
NetWodUtils
zz19970108的博客
10-24 212
package com.bwie.zhoukao2demo; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.util.Log; import java.io.BufferedReader; import java.io.IOException; import java.
基于HttpUrlConnection的简单封装SimpleHttp
cdporter的博客
10-26 1052
基于HttpUrlConnection的简单封装SimpleHttp
一个HttpURLConnection的封装
猪头三
01-23 5186
对HttpURLConnection进行封装，提供简单接口，支持 http/https 协议 和 get/post 方式
HttpURLConnection网络请求的封装
Mr_zhao_BLOG
09-12 693
public class Helper { private final int HTTP_SUCCESS=100;//成功 private final int HTTP_FAIL=101;//失败 public Helper(){} //get请求 public Helper get(String url){ doHttp(0,url,""); retur...
HttpURLConnection发送请求封装
m0_63538358的博客
05-18 241
Java HttpURLConnection发送请求
httpurlconnection 封装
最新发布
09-23
封装HttpURLConnection时，我们可以将URL、请求方法、请求头部信息、请求体等作为方法的参数，方法中的逻辑可以参考上述的步骤。 另外，为了便于处理异常，我们可以在封装的方法中使用try-catch语句来捕获可能的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值