android的网络访问

最新推荐文章于 2023-05-01 11:14:47 发布
最新推荐文章于 2023-05-01 11:14:47 发布
阅读量3.5k 收藏 2
点赞数
分类专栏： Android 文件操作 文章标签： 网络 android string null download url
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wop_niaoren19870227/article/details/7103018
版权

1、核心类NetWorkCore，处理发送请求

view plain
  1. import java.io.IOException;  
  2. import java.io.InputStream;  
  3.   
  4. import org.apache.http.HttpEntity;  
  5. import org.apache.http.HttpHost;  
  6. import org.apache.http.HttpResponse;  
  7. import org.apache.http.HttpStatus;  
  8. import org.apache.http.client.ClientProtocolException;  
  9. import org.apache.http.client.HttpClient;  
  10. import org.apache.http.client.methods.HttpGet;  
  11. import org.apache.http.client.methods.HttpPost;  
  12. import org.apache.http.conn.params.ConnRouteParams;  
  13. import org.apache.http.entity.ByteArrayEntity;  
  14. import org.apache.http.entity.StringEntity;  
  15. import org.apache.http.impl.client.DefaultHttpClient;  
  16. import org.apache.http.params.BasicHttpParams;  
  17. import org.apache.http.params.HttpConnectionParams;  
  18. import org.apache.http.params.HttpParams;  
  19.   
  20. /** 
  21.  * 网络请求核心类，用于处理发送请求和返回，单例 
  22.  *  
  23.  * @author Administrator 
  24.  *  
  25.  */  
  26. public class NetworkCore {  
  27.     //连接超时(ms)  
  28.     private static final int timeoutConnection = 30000;  
  29.     //响应超时(ms)  
  30.     private static final int timeoutSocket = 50000;  
  31.   
  32.     private static NetworkCore instance;  
  33.     /*get请求*/  
  34.     private HttpGet httpGet;  
  35.     /*post请求*/  
  36.     private HttpPost httpPost;  
  37.       
  38.     public static NetworkCore Instance() {  
  39.         if (instance == null) {  
  40.             instance = new NetworkCore();  
  41.         }  
  42.         return instance;  
  43.     }  
  44.     /** 
  45.      * 发送请求 
  46.      * @param request 请求线程对象 
  47.      * @return 请求结果 
  48.      */  
  49.     public NetWorkResponseMsg perform(DoRequestRunnable request) {  
  50.         NetWorkResponseMsg msg = null;  
  51.         NetworkRequestMsg mNetworkRequestMsg = request.getmNetworkRequestMsg();  
  52.         try {  
  53.             if (NetworkRequestMsg.POST.equals(mNetworkRequestMsg.getType())) {  
  54.                 msg = handlePostRequest(mNetworkRequestMsg);  
  55.             } else {  
  56.                 msg = handleGetRequest(mNetworkRequestMsg);  
  57.             }  
  58.             if (msg.getInputStream()==null) {  
  59.                 msg.setResponseMsg(NetworkError.NODATA);  
  60.             }  
  61.             request.handleNetResponseMsg(msg);  
  62.         } catch (IOException e) {  
  63.             msg.setResponseMsg(NetworkError.CONNECT_ERROR);  
  64.         } finally {  
  65.             msg.closeStream();  
  66.         }  
  67.         return msg;  
  68.     }  
  69.     /** 
  70.      * get请求 
  71.      * @param mNetworkRequestMsg 
  72.      * @return 
  73.      * @throws ClientProtocolException 
  74.      * @throws IOException 
  75.      */  
  76.     private NetWorkResponseMsg handleGetRequest(NetworkRequestMsg mNetworkRequestMsg)  
  77.             throws ClientProtocolException, IOException {  
  78.         InputStream is = null;  
  79.         StringBuffer finalURL = new StringBuffer(mNetworkRequestMsg.getUrl());  
  80.         int index = finalURL.indexOf("?");  
  81.         if (null != mNetworkRequestMsg.getParam()) {  
  82.             for (String paramName : mNetworkRequestMsg.getParam()  
  83.                     .getParamNames()) {  
  84.                 if (index == -1) {  
  85.                     finalURL.append("?"  
  86.                             + paramName  
  87.                             + "="  
  88.                             + mNetworkRequestMsg.getParam().getParamValue(  
  89.                                     paramName));  
  90.                 } else {  
  91.                     finalURL.append("&"  
  92.                             + paramName  
  93.                             + "="  
  94.                             + mNetworkRequestMsg.getParam().getParamValue(  
  95.                                     paramName));  
  96.                 }  
  97.                 index++;  
  98.             }  
  99.             mNetworkRequestMsg.setUrl(finalURL.toString());  
  100.         }  
  101.         httpGet = new HttpGet(finalURL.toString());  
  102.         if (mNetworkRequestMsg.getParam().getParamNames().size() > 0) {  
  103.             for (String headerName : mNetworkRequestMsg.getParam()  
  104.                     .getHeaderNames()) {  
  105.                 httpGet.addHeader(headerName, mNetworkRequestMsg.getParam()  
  106.                         .getHeaderValue(headerName));  
  107.             }  
  108.         }  
  109.         mNetworkRequestMsg.getParam().clearCache();  
  110.         HttpParams httpParameters = new BasicHttpParams();  
  111.         HttpConnectionParams.setConnectionTimeout(httpParameters,  
  112.                 timeoutConnection);  
  113.         HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);  
  114.   
  115.         HttpClient httpclient = new DefaultHttpClient(httpParameters);  
  116.         if (mNetworkRequestMsg.isNeedProxy()) {  
  117.             String address = mNetworkRequestMsg.getProxyAddress() == null ? NetworkConfig.DEFAULT_PROXY  
  118.                     : mNetworkRequestMsg.getProxyAddress();  
  119.             int port = mNetworkRequestMsg.getProxyPort() == 0 ? NetworkConfig.DEFAULT_PROXYPORT  
  120.                     : mNetworkRequestMsg.getProxyPort();  
  121.             setProxy(httpclient, address, port);  
  122.         }  
  123.         HttpResponse httpResponse = httpclient.execute(httpGet);  
  124.         if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {  
  125.             is = httpResponse.getEntity().getContent();  
  126.         }   
  127.         return new NetWorkResponseMsg(is,httpResponse.getStatusLine().getStatusCode());  
  128.     }  
  129.     /** 
  130.      * post请求 
  131.      * @param mNetworkRequestMsg 
  132.      * @return 
  133.      * @throws ClientProtocolException 
  134.      * @throws IOException 
  135.      */  
  136.     private NetWorkResponseMsg handlePostRequest(NetworkRequestMsg mNetworkRequestMsg)  
  137.             throws ClientProtocolException, IOException {  
  138.         InputStream is = null;  
  139.         HttpEntity httpentity = null;  
  140.         StringBuffer finalURL = new StringBuffer(mNetworkRequestMsg.getUrl());  
  141.         int index = finalURL.indexOf("?");  
  142.         if (null != mNetworkRequestMsg.getParam()) {  
  143.             for (String paramName : mNetworkRequestMsg.getParam()  
  144.                     .getParamNames()) {  
  145.                 if (index == -1) {  
  146.                     finalURL.append("?"  
  147.                             + paramName  
  148.                             + "="  
  149.                             + mNetworkRequestMsg.getParam().getParamValue(  
  150.                                     paramName));  
  151.                 } else {  
  152.                     finalURL.append("&"  
  153.                             + paramName  
  154.                             + "="  
  155.                             + mNetworkRequestMsg.getParam().getParamValue(  
  156.                                     paramName));  
  157.                 }  
  158.                 index++;  
  159.             }  
  160.             mNetworkRequestMsg.setUrl(finalURL.toString());  
  161.         }  
  162.         httpPost = new HttpPost(finalURL.toString());  
  163.         if (mNetworkRequestMsg.getParam().getParamNames().size() > 0) {  
  164.             for (String headerName : mNetworkRequestMsg.getParam()  
  165.                     .getHeaderNames()) {  
  166.                 httpPost.addHeader(headerName, mNetworkRequestMsg.getParam()  
  167.                         .getHeaderValue(headerName));  
  168.             }  
  169.         }  
  170.         mNetworkRequestMsg.getParam().clearCache();  
  171.         if (mNetworkRequestMsg.getParam().getArrayBody() != null) {  
  172.             httpentity = new ByteArrayEntity(mNetworkRequestMsg.getParam()  
  173.                     .getArrayBody());  
  174.         } else if (mNetworkRequestMsg.getParam().getBody() != null) {  
  175.             httpentity = new StringEntity(mNetworkRequestMsg.getParam()  
  176.                     .getBody());  
  177.         }  
  178.         if (null != httpentity) {  
  179.             httpPost.setEntity(httpentity);  
  180.         }  
  181.         HttpParams httpParameters = new BasicHttpParams();  
  182.         HttpConnectionParams.setConnectionTimeout(httpParameters,  
  183.                 timeoutConnection);  
  184.         HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);  
  185.         HttpClient httpclient = new DefaultHttpClient(httpParameters);  
  186.         if (mNetworkRequestMsg.isNeedProxy()) {  
  187.             String address = mNetworkRequestMsg.getProxyAddress() == null ? NetworkConfig.DEFAULT_PROXY  
  188.                     : mNetworkRequestMsg.getProxyAddress();  
  189.             int port = mNetworkRequestMsg.getProxyPort() == 0 ? NetworkConfig.DEFAULT_PROXYPORT  
  190.                     : mNetworkRequestMsg.getProxyPort();  
  191.             setProxy(httpclient, address, port);  
  192.         }  
  193.         HttpResponse httpResponse = httpclient.execute(httpPost);  
  194.         if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {  
  195.             is = httpResponse.getEntity().getContent();  
  196.         }  
  197.         return new NetWorkResponseMsg(is,httpResponse.getStatusLine().getStatusCode());  
  198.     }  
  199.     /** 
  200.      * 断开连接 
  201.      */  
  202.     public void abort(){  
  203.         if(httpGet != null){  
  204.             if(!httpGet.isAborted()){  
  205.                 httpGet.abort();  
  206.             }  
  207.         }  
  208.         if(httpPost != null){  
  209.             if(!httpPost.isAborted()){  
  210.                 httpPost.abort();  
  211.             }  
  212.         }  
  213.     }  
  214.     /** 
  215.      *  
  216.      * @param httpclient 
  217.      * @param address 
  218.      * @param port 
  219.      */  
  220.     private void setProxy(HttpClient httpclient, String address, int port) {  
  221.         HttpHost proxy = new HttpHost(address, port);  
  222.         httpclient.getParams().setParameter(ConnRouteParams.DEFAULT_PROXY,  
  223.                 proxy);  
  224.     }  
  225.   
  226. }  

2、请求封装类NetworkRequestMsg：
view plain
  1. public class NetworkRequestMsg extends Message {  
  2.       
  3.     public static final String GET = "GET";  
  4.     public static final String POST = "POST";  
  5.       
  6.   
  7.     /** 
  8.      * 产生自增ID计数器 
  9.      */  
  10.     private static short ID = 0;  
  11.   
  12.     /** 
  13.      * 当前消息id 
  14.      */  
  15.     private short id = 0;  
  16.   
  17.     /** 
  18.      * 当前请求类型(GET/POST) 
  19.      */  
  20.     private String type;  
  21.   
  22.     /** 
  23.      * 请求地址URL 
  24.      */  
  25.     private String url;  
  26.   
  27.     /** 
  28.      * 请求消息参数 
  29.      */  
  30.     private Parameter param;  
  31.   
  32.     /** 
  33.      * 数据连接返回值 
  34.      */  
  35.     private byte retcode = -1;  
  36.   
  37.     /** 
  38.      * 请求是否取消 
  39.      */  
  40.     private boolean cancel = false;  
  41.   
  42.     /** 
  43.      * 是否正在发送数据 
  44.      */  
  45.     private boolean sending = false;  
  46.   
  47.     /** 
  48.      * 是否是下载类型 
  49.      */  
  50.     private boolean download = false;  
  51.   
  52.     /** 
  53.      * 重发次数 
  54.      */  
  55.     private byte sendTime = 0;  
  56.       
  57.     /** 
  58.      * 网络数据解析协议 
  59.      */  
  60.     private String protocol;  
  61.       
  62.     /** 
  63.      * 是否需要代理 
  64.      */  
  65.     private boolean isNeedProxy;  
  66.       
  67.     /** 
  68.      * 代理地址 
  69.      */  
  70.     private String proxyAddress;  
  71.       
  72.       
  73.     /** 
  74.      * 代理端口 
  75.      */  
  76.     private int proxyPort;   
  77.   
  78.       
  79.       
  80.   
  81.     public NetworkRequestMsg(String _url,String _type ,Parameter _param,boolean isNeedProxy,String _proxyAddress,int _proxyPort){  
  82.           
  83.         this.url = _url;  
  84.         this.type = _type;  
  85.         this.isNeedProxy = isNeedProxy;  
  86.         this.param = _param;  
  87.         this.proxyAddress = _proxyAddress;  
  88.         this.proxyPort = _proxyPort;  
  89.           
  90.     }  
  91.       
  92.   
  93.     public static short getID() {  
  94.         return ID;  
  95.     }  
  96.   
  97.     public static void setID(short iD) {  
  98.         ID = iD;  
  99.     }  
  100.   
  101.     public short getId() {  
  102.         return id;  
  103.     }  
  104.   
  105.     public void setId(short id) {  
  106.         this.id = id;  
  107.     }  
  108.   
  109.     public String getType() {  
  110.         return type;  
  111.     }  
  112.   
  113.     public void setType(String type) {  
  114.         this.type = type;  
  115.     }  
  116.   
  117.     public String getUrl() {  
  118.         return url;  
  119.     }  
  120.   
  121.     public void setUrl(String url) {  
  122.         this.url = url;  
  123.     }  
  124.   
  125.     public byte getRetcode() {  
  126.         return retcode;  
  127.     }  
  128.   
  129.     public void setRetcode(byte retcode) {  
  130.         this.retcode = retcode;  
  131.     }  
  132.   
  133.     public boolean isCancel() {  
  134.         return cancel;  
  135.     }  
  136.   
  137.     public void setCancel(boolean cancel) {  
  138.         this.cancel = cancel;  
  139.     }  
  140.   
  141.     public boolean isSending() {  
  142.         return sending;  
  143.     }  
  144.   
  145.     public void setSending(boolean sending) {  
  146.         this.sending = sending;  
  147.     }  
  148.   
  149.     public boolean isDownload() {  
  150.         return download;  
  151.     }  
  152.   
  153.     public void setDownload(boolean download) {  
  154.         this.download = download;  
  155.     }  
  156.   
  157.     public byte getSendTime() {  
  158.         return sendTime;  
  159.     }  
  160.   
  161.     public void setSendTime(byte sendTime) {  
  162.         this.sendTime = sendTime;  
  163.     }  
  164.     public Parameter getParam() {  
  165.         return param;  
  166.     }  
  167.   
  168.   
  169.     public void setParam(Parameter param) {  
  170.         this.param = param;  
  171.     }  
  172.   
  173.   
  174.       
  175.       
  176.       
  177.       
  178.     public String getProtocol() {  
  179.         return protocol;  
  180.     }  
  181.   
  182.   
  183.     public void setProtocol(String protocol) {  
  184.         this.protocol = protocol;  
  185.     }  
  186.   
  187.   
  188.     public boolean isNeedProxy() {  
  189.         return isNeedProxy;  
  190.     }  
  191.   
  192.   
  193.     public void setNeedProxy(boolean isNeedProxy) {  
  194.         this.isNeedProxy = isNeedProxy;  
  195.     }  
  196.       
  197.     public String getProxyAddress() {  
  198.         return proxyAddress;  
  199.     }  
  200.   
  201.     public void setProxyAddress(String proxyAddress) {  
  202.         this.proxyAddress = proxyAddress;  
  203.     }  
  204.   
  205.     public int getProxyPort() {  
  206.         return proxyPort;  
  207.     }  
  208.   
  209.     public void setProxyPort(int proxyPort) {  
  210.         this.proxyPort = proxyPort;  
  211.     }  
  212. }  

请求参数封装类Parameter：
view plain
  1. import java.util.ArrayList;  
  2. import java.util.HashMap;  
  3.   
  4. public class Parameter {  
  5.       
  6.     private HashMap<String,String> header = new HashMap<String,String>();  
  7.     private ArrayList<String> allHeaderNames = new ArrayList<String>();  
  8.     //参数信息  
  9.     private HashMap<String,String> param = new HashMap<String,String>();  
  10.     private ArrayList<String> allParamNames = new ArrayList<String>();  
  11.     //实体信息  
  12.     private String body;  
  13.       
  14.     private byte[] arrayBody;  
  15.       
  16.     public String getParamValue(String _name){  
  17.         return param.get(_name);  
  18.     }  
  19.     public String getHeaderValue(String _name){  
  20.         return header.get(_name);  
  21.     }  
  22.       
  23.     public void addHeader(String _name,String _value) throws Exception{  
  24.         if(null != _name && null != _value ){  
  25.             header.put(_name, _value);  
  26.             allHeaderNames.add(_name);  
  27.         } else {  
  28.             throw new Exception("头信息请求参数非法");  
  29.         }  
  30.     }  
  31.       
  32.     public void addParam(String _name,String _value) throws Exception{  
  33.         if(null != _name && null != _value ){  
  34.             param.put(_name, _value);  
  35.             allParamNames.add(_name);  
  36.         } else {  
  37.             throw new Exception("请求参数非法");  
  38.         }  
  39.     }  
  40.       
  41.       
  42.     public ArrayList<String> getHeaderNames(){  
  43.         return allHeaderNames;  
  44.     }  
  45.     public  ArrayList<String> getParamNames(){  
  46.         return allParamNames;  
  47.     }  
  48.       
  49.     public void clearCache(){  
  50.         if(null != header){  
  51.             header.clear();  
  52.         }  
  53.         if(null != allHeaderNames){  
  54.             allHeaderNames.clear();  
  55.         }  
  56.         if(null != param){  
  57.             param.clear();  
  58.         }  
  59.         if(null != allParamNames){  
  60.             allParamNames.clear();  
  61.         }  
  62.           
  63.     }  
  64.       
  65.     public String getBody() {  
  66.         return body;  
  67.     }  
  68.   
  69.     public void setBody(String body) {  
  70.         this.body = body;  
  71.     }  
  72.   
  73.       
  74.     public byte[] getArrayBody() {  
  75.         return arrayBody;  
  76.     }  
  77.     public void setArrayBody(byte[] arrayBody) {  
  78.         this.arrayBody = arrayBody;  
  79.     }  
  80.     public Parameter(){  
  81.         clearCache();  
  82.     }  
  83.       
  84.   
  85. }  

3 响应请求封装类NetWorkResponseMsg：
view plain
  1. import java.io.IOException;  
  2. import java.io.InputStream;  
  3.   
  4. public class NetWorkResponseMsg {  
  5.       
  6.     private InputStream inputStream ;  
  7.       
  8.     private int responseCode = 200;  
  9.   
  10.     private String responseMsg = null;  
  11.       
  12.     public NetWorkResponseMsg() {  
  13.     }  
  14.   
  15.       
  16.     public NetWorkResponseMsg(InputStream inputStream, int responseCode) {  
  17.         this.inputStream = inputStream;  
  18.         this.responseCode = responseCode;  
  19.     }  
  20.   
  21.       
  22.     public NetWorkResponseMsg(InputStream inputStream, int responseCode,  
  23.             String responseMsg) {  
  24.         this.inputStream = inputStream;  
  25.         this.responseCode = responseCode;  
  26.         this.responseMsg = responseMsg;  
  27.     }  
  28.   
  29.     public String getResponseMsg() {  
  30.         return responseMsg;  
  31.     }  
  32.   
  33.     public void setResponseMsg(String responseMsg) {  
  34.         this.responseMsg = responseMsg;  
  35.     }  
  36.   
  37.   
  38.     public InputStream getInputStream() {  
  39.         return inputStream;  
  40.     }  
  41.   
  42.     public void setInputStream(InputStream inputStream) {  
  43.         this.inputStream = inputStream;  
  44.     }  
  45.   
  46.     public int getResponseCode() {  
  47.         return responseCode;  
  48.     }  
  49.   
  50.     public void setResponseCode(int responseCode) {  
  51.         this.responseCode = responseCode;  
  52.     }  
  53.       
  54.     public void closeStream(){  
  55.         try {  
  56.             if(inputStream != null){  
  57.                 inputStream.close();  
  58.             }  
  59.         } catch (IOException e) {  
  60.         }  
  61.     }  
  62.       
  63. } 

wop_niaoren19870227
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android访问网络资源
fjnu_se的博客
12-05 982
当我们写AndroidAPP的时候，一定会考虑一个很重要的问题，那就是如何让APP能调用网上的其他资源呢？这时候就需要用到URL(Uniform Resource Locator)。URL代表统一资源定位器，它是指向互联网“资源”的指针。所谓的资源，可以是简单的文件或者目录，也可以是更复杂的对象的引用，比如对数据库、搜索引擎的查询等等。通常来说，URL可以由协议名、主机、端口和资源组成，以下为格式： URL类提供了多个构造器用于创建URL对象，一旦获得了URL对象之后，就可以调用如下常用方法来访问该URL对
ANDROID 网络访问 封装库
01-21
首先，我们要理解Android网络访问的基本概念。Android系统提供了两种主要的网络访问方式：HttpURLConnection和HttpClient，但随着Android版本的更新，HttpClient已被弃用，HttpURLConnection成为了推荐的选择。然而...
Android访问网络的4种方法
group601的专栏
06-25 946
1、android访问网络的四种方法 1）URL 2）URL
安卓的访问网络
程序小渣渣
07-19 256
原生访问 new Thread() { public void run() { HttpGet httpGet = new HttpGet(path); // 获取HttpClient对象 HttpClient httpClient = new DefaultHttpClient(); // 请求超时 httpClient.getParams().setP
安卓笔记——网络访问
a23_23的博客
04-25 231
目录基本步骤JSON数据的传递 基本步骤 1、在AndroidManifest.xml里加入网络访问代码 <uses-permission android:name="android.permission.INTERNET"/> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> android:usesCleartextTraffic="true" 2、在MainActivity
Android 如何访问网络
qq_41059997的博客
03-23 574
android 如何访问网络MainActivity代码块Layout代码块 主界面图片: 居中并且带尺寸的图片: 当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。 MainActivity代码块 一、绑定定控件，然后通过点击按钮获取url，由于打开url获取数据流的工作不能在主线程中工作，所以创建了内部类RequestNetworkDataTask （）继承自AsyncTask。 二、...
Android网络访问解决方案小结·1.docx
10-26
Android网络访问解决方案小结·1.docx
android网络访问框架NiceDayFramework
12-18
《深入解析Android网络访问框架NiceDayFramework》 在Android应用开发中，网络访问是不可或缺的一环，它使得应用能够获取远程服务器的数据，实现各种在线功能。NiceDayFramework是一款专为Android设计的网络访问...
关于Android Studio中使用OkHttpClient访问网络需要第三方模拟器的问题
09-14
这是Android系统中所有网络访问的基础： ```xml <uses-permission android:name="android.permission.INTERNET" /> ``` 没有这个权限，应用将无法发起任何网络请求，无论是在真实设备还是模拟器上。 接下来，针对...
安卓网络访问基础
cd837694030的博客
09-10 399
前提配置好了tomcat 1.新建Dynamic web project WebContent WEB-INF 中新建index.xml Insert title here   用户名：     密码：       2.servers栏中右键add
安卓7种网络连接方式
04-09
HTTP数据传输的7种方式，经测试完美。 httpUrlConn; httpClient; volley; Async; XUtil; imageLoader; okHttp;
android访问网络方式
iamwutianbao的博客
04-20 502
1. 使用url来访问网络 public class HttpUtils { public static final Login(final String url) { new Thread(new Runaable() { @Override public void run() { HttpURLConnection connection; try { connection =
Android 浅谈访问网络
SlienceFang的博客
03-01 541
Android 浅谈访问网络 最近开始对Android一些基础性的知识总结一下，并且也锻炼一下自己的写作能力，希望自己能够好好的学习技术，静下来总结。 谈到Android 使用HTTP协议访问网络，其实简单的理解就是客户端向服务端发出一条HTTP请求，服务器会收到请求之后会返回一些数据给客户端，然后客户端再对这些数据进行解析和处理。 在Android上发送HTTP请求一般会有
android Http协议访问网络
weixin_40856541的博客
05-16 368
android Http协议访问网络 一、HttpURLConnection实现Http请求 1、HttpURLConnection基本用法 1、获取HttpURLConnection实例 2、new一个URL对象 3、传入URL对象（目标网络地址），并调用openConnection()方法 URL url = new URL("http://www....
安卓是否连接到网络
weixin_37744986的博客
07-04 242
package com.example.administrator.myapplication; import android.content.Context; import android.net.ConnectivityManager; import android.net.NetworkInfo; /** * Created by Administrator on 2018/7/4/0...
android中使用http协议访问网络
Tang's学习笔记
07-26 608
在android应用中可以通过HttpURLConnection类来使用http协议访问网络，大概的流程是这样的。 1、获取HttpURLConnection的实例，通过一个URL对象调用openConnection()方法来获得 2、通过HttpURlConnection实例的setRequestMethod()方法设置http请求所用的方法，一般为GET或POST 3、使用HttpURL
安卓不能访问网络
FGY_u的博客
12-02 360
在真机（安卓P）上访问网络，即使赋了权限，也不能访问网络。 &amp;lt;uses-permission android:name=&quot;android.permission.INTERNET&quot;/&amp;gt; 后来发现，安卓P的新特性，安卓更新九点零以后，有新的限制，对未加密流量不在信任，直接放弃请求。也就是说，用的http就不符合要求，要改用https。 我们写的接口可能就这样连接不上了，这里提供一个最简单...
Android之使用HttpURLConnection进行网络访问
wei_zhi的博客
11-01 5758
一、概述在Android 上发送HTTP 请求的方式一般有两种：HttpURLConnection 和HttpClient。因为在Android 5.0之后，HttpClient被HttpURLConnecetion替代，后来在Android 6.0完全被舍弃，所以本文重点讲解HttpURLConnecetion。二、HttpURLConnecetion的使用步骤（1）首先需要获取到HttpURLC
【Android入门到项目实战-- 8.2】—— 使用HTTP协议访问网络
最新发布
张修宇的博客
05-01 3210
Android如何使用HTTP协议访问网络？如何使用HttpURLConnection？如何使用OkHttp？
Android网络访问：HttpURLConnection与HttpClient详解及封装
"本文将深入探讨Android开发中两种常用的网络访问方式：HttpURLConnection和HttpClient，以及它们的使用和封装技巧。" 在Android应用开发中，与服务器进行数据交换是常见的需求，HTTP作为最广泛使用的网络通信协议...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值