http请求

最新推荐文章于 2022-10-03 09:55:59 发布
最新推荐文章于 2022-10-03 09:55:59 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： android
package com.hes.tools.net.httpnet;
 
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
 
import android.util.Log;
 
public class HttpRequest {
 
     private static HttpRequest httpRequest;
     private HttpClient httpClient;
 
     private HttpRequest() {
         httpClient = getHttpClient();
     }
 
     public static HttpRequest getHttRequest() {
         if (httpRequest == null ) {
             httpRequest = new HttpRequest();
         }
         return httpRequest;
     }
 
     private InputStream httpGet(String urlStr) {
         try {
             URL url = new URL(urlStr);
             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
             connection.setRequestProperty( "connection" , "Keep-Alive" );
             connection.setRequestProperty( "Charsert" , "UTF-8" );
             connection.setConnectTimeout( 2000 );
             connection.setReadTimeout( 2000 );
             connection.setRequestMethod( "GET" );
             if (connection.getResponseCode() != HttpStatus.SC_OK) {
                 return null ;
             }
             InputStream inStream = connection.getInputStream();
             if (inStream != null ) {
                 ByteArrayOutputStream outStream = new ByteArrayOutputStream();
                 byte [] buffer = new byte [ 1024 ];
                 int len = 0 ;
                 while ((len = inStream.read(buffer)) != - 1 ) {
                     outStream.write(buffer, 0 , len);
                 }
                 inStream.close();
                 Log.d( "DATA" , new String(outStream.toByteArray()));
                 return inStream;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null ;
     }
 
     private InputStream httpPost(String urlStr, String content) {
         try {
             URL url = new URL(urlStr);
             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
             connection.setDoOutput( true );
             // 设置是否从httpUrlConnection读入，默认情况下是true;
             connection.setDoInput( true );
             // Post 请求不能使用缓存
             connection.setUseCaches( false );
             connection.setInstanceFollowRedirects( true );
             // 配置本次连接的Content-type，配置为application/x-www-form-urlencoded的
             // 意思是正文是urlencoded编码过的form参数，下面我们可以看到我们对正文内容使用URLEncoder.encode
             // 进行编码
             connection.setRequestProperty( "Content-Type" , "application/x-www-form-urlencoded" );
             connection.setRequestProperty( "connection" , "Keep-Alive" );
             connection.setRequestProperty( "Charsert" , "UTF-8" );
             connection.setConnectTimeout( 2000 );
             connection.setReadTimeout( 2000 );
             connection.setRequestMethod( "POST" );
             DataOutputStream out = new DataOutputStream(connection.getOutputStream());
             out.writeBytes(content);
             out.flush();
             out.close();
             if (connection.getResponseCode() != HttpStatus.SC_OK) {
                 return null ;
             }
             InputStream inStream = connection.getInputStream();
             if (inStream != null ) {
                 ByteArrayOutputStream outStream = new ByteArrayOutputStream();
                 byte [] buffer = new byte [ 1024 ];
                 int len = 0 ;
                 while ((len = inStream.read(buffer)) != - 1 ) {
                     outStream.write(buffer, 0 , len);
                 }
                 inStream.close();
                 Log.d( "DATA" , new String(outStream.toByteArray()));
                 return inStream;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null ;
     }
 
     public InputStream reqGet(String urlStr, HashMap<String, String> params) {
         try {
             InputStream in = httpGet(getParams(urlStr, params));
             return in;
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         return null ;
     }
     
     public InputStream reqPost(String urlStr, HashMap<String, String> params) {
         try {
             InputStream in = httpPost(urlStr, getParams(params));
             return in;
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         return null ;
     }
     
     private String getParams(Map<String, String> params) throws UnsupportedEncodingException{
         int count = params.size();
         Iterator<String> iterator = params.keySet().iterator();
         StringBuffer sb = new StringBuffer();
         String param = "" ;
         String value = "" ;
         int c = 0 ;
         while (iterator.hasNext()) {
             param = iterator.next();
             sb.append(param);
             sb.append( "=" );
             value = params.get(param);
             sb.append(URLEncoder.encode(value, "UTF-8" ));
             c++;
             if (c != count) {
                 sb.append( "&" );
             }
         }
         count = c = 0 ;
         String reqUrl = sb.toString();
         return reqUrl;
     }
 
     private String getParams(String urlStr, Map<String, String> params) throws UnsupportedEncodingException {
         int count = params.size();
         Iterator<String> iterator = params.keySet().iterator();
         StringBuffer sb = new StringBuffer();
         String param = "" ;
         String value = "" ;
         sb.append(urlStr);
         sb.append( "?" );
         int c = 0 ;
         while (iterator.hasNext()) {
             param = iterator.next();
             sb.append(param);
             sb.append( "=" );
             value = params.get(param);
             sb.append(URLEncoder.encode(value, "UTF-8" ));
             c++;
             if (c != count) {
                 sb.append( "&" );
             }
         }
         count = c = 0 ;
         String reqUrl = sb.toString();
         return reqUrl;
     }
 
     private List<BasicNameValuePair> setParams(Map<String, String> params) {
         Iterator<String> iterator = params.keySet().iterator();
         List<BasicNameValuePair> requestParam = new ArrayList<BasicNameValuePair>();
         String param = "" ;
         String value = "" ;
         while (iterator.hasNext()) {
             param = iterator.next();
             value = params.get(param);
             requestParam.add( new BasicNameValuePair(param, value));
         }
         return requestParam;
     }
 
     public HttpEntity httpPost(String url, Map<String, String> params) {
         try {
             HttpPost post = new HttpPost(url);
             post.setEntity( new UrlEncodedFormEntity(setParams(params), "UTF-8" ));
             HttpResponse response = httpClient.execute(post);
             if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                 throw new Exception( "response code not 200" );
             }
             HttpEntity entity = response.getEntity();
             if (entity != null ) {
                 return entity;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null ;
     }
 
     public HttpEntity httpGet(String url, Map<String, String> params) {
         try {
             String param = URLEncodedUtils.format(setParams(params), "UTF-8" );
             HttpGet get = new HttpGet(url + "?" + param);
             HttpResponse response = httpClient.execute(get);
             if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                 throw new Exception( "response code not 200" );
             }
             HttpEntity entity = response.getEntity();
             if (entity != null ) {
                 return entity;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null ;
     }
 
     public String getString(String url, Map<String, String> params, String method) {
         HttpEntity entity = null ;
         if (method.toUpperCase().equals( "GET" )) {
             entity = httpGet(url, params);
         } else {
             entity = httpPost(url, params);
         }
         String str = null ;
         try {
             if (entity != null ) {
                 str = EntityUtils.toString(entity, "UTF-8" );
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return str;
     }
 
     public byte [] getArray(String url, Map<String, String> params, String method) {
         HttpEntity entity = null ;
         if (method.toUpperCase().equals( "GET" )) {
             entity = httpGet(url, params);
         } else {
             entity = httpPost(url, params);
         }
         byte [] bytes = null ;
         try {
             if (entity != null ) {
                 bytes = EntityUtils.toByteArray(entity);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return bytes;
     }
 
     public HttpClient getHttpClient() {
         HttpParams params = new BasicHttpParams();
         HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
         HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
         HttpProtocolParams.setUseExpectContinue(params, true );
         HttpProtocolParams.setUserAgent(params, "Mozilla/5.0(Linux;U;Android 2.3.3;en-us;Nexus One Build.FRG83) AppleWebKit/553.1(KHTML,like Gecko) Version/4.0 Mobile Safari/533.1" );
         // 超时设置
         /* 从连接池中取连接的超时时间 */
         ConnManagerParams.setTimeout(params, 5000 );
         /* 连接超时 */
         HttpConnectionParams.setConnectionTimeout(params, 5000 );
         /* 请求超时 */
         HttpConnectionParams.setSoTimeout(params, 5000 );
         // 设置HttpClient支持HTTP和HTTPS两种模式
         SchemeRegistry schReg = new SchemeRegistry();
         schReg.register( new Scheme( "http" , PlainSocketFactory.getSocketFactory(), 80 ));
         schReg.register( new Scheme( "https" , SSLSocketFactory.getSocketFactory(), 443 ));
         // 使用线程安全的连接管理来创建HttpClient
         ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);
         HttpClient httpClient = new DefaultHttpClient(conMgr, params);
         return httpClient;
     }
}

socket上传


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package com.hes.tools.net.upload;
 
import java.io.File;
import java.util.Map;
 
public class HttpHoder {
     
     protected byte [] createHeaders( long lenth){
         String header = String.format(
         "POST /Manager/WebService/UploadmediaService.aspx HTTP/1.1\r\n" +
         "keep-alive: true\r\n" +
         "connection: keep-alive\r\n" +
         "charset: UTF-8\r\n" +
         "content-type: multipart/form-data; boundary=---------7d4a6d158c9\r\n" +
         "User-Agent: Dalvik/1.2.0 (Linux; U; Android 2.2; sdk Build/FRF91)\r\n" +
         "Host: 192.168.1.103\r\n" +
         "Content-Length: %d" +
         "\r\n\r\n" , lenth);
         return header.getBytes();
     }
     
     protected byte [] createHeaders(String content_lenth, String host){
         StringBuilder header = new StringBuilder();
         header.append( "POST /Manager/WebService/UploadmediaService.aspx HTTP/1.1\r\n" );
         header.append( "HOST: " +host+ "\r\n" );
         header.append( "Connection: keep-alive\r\n" );
         header.append( "Keep-Alive: true\r\n" );
         header.append( "Accept: */*\r\n" );
         header.append( "Accept-Language: zh-cn\r\n" );
         header.append( "Accept-Charset: utf-8\r\n" );
         header.append( "User-Agent: Dalvik/1.2.0 (Linux; U; Android 2.2; sdk Build/FRF91)\r\n" );
         header.append( "Content-Type: multipart/form-data; boundary=---------7d4a6d158c9\r\n" );
         header.append( "Content-Length: " + content_lenth);
         header.append( "\r\n\r\n" );
         byte [] byte_header = header.toString().getBytes();
         return byte_header;
     }
     
     protected byte [] createParamsContent(Map<String, String> params){
         StringBuilder param = new StringBuilder();
         for (Map.Entry<String, String> entry : params.entrySet()) {
             param.append( "-----------7d4a6d158c9\r\n" );
             param.append( "Content-Disposition: form-data; name=\"" + entry.getKey() + "\"\r\n\r\n" );
             param.append(entry.getValue());
             param.append( "\r\n" );
         }
         byte [] bytes = param.toString().getBytes();
         return bytes;
     }
     
     protected byte [] createFileHeaderBoundary(String fileName) {
         StringBuilder builder = new StringBuilder();
         builder.append( "-----------7d4a6d158c9\r\n" );
         builder.append( "Content-Disposition: form-data;name=\"" + fileName + "\";filename=\"" + fileName + "\"\r\n" );
         builder.append( "Content-Type: application/octet-stream" );
         builder.append( "\r\n\r\n" );
         byte [] bytes = builder.toString().getBytes();
         return bytes;
     }
     
     protected byte [] getFileHeaderBoundary(String fileName) {
         StringBuilder builder = new StringBuilder();
         builder.append( "-----------7d4a6d158c9\r\n" );
         builder.append( "Content-Disposition: form-data;name=\"" + fileName + "\";filename=\"" + fileName + "\"\r\n" );
         builder.append( "Content-Type: application/octet-stream" );
         builder.append( "\r\n\r\n" );
         byte [] bytes = builder.toString().getBytes();
         return bytes;
     }
     
     protected byte [] createContentEnd(){
         byte [] after = ( "\r\n-----------7d4a6d158c9--\r\n" ).getBytes();
         return after;
     }
     
     protected long getFileLengths(File file){
         return file.length();
     }
 
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package com.hes.tools.net.upload;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Map;
import android.util.Log;
 
public class HttpUploadSocket extends HttpHoder {
 
     private Socket mSocket;
     private Map<String, String> params;
     private File file;
     private String host;
     private int port;
     private int bytesize = 1024 * 1024 ;
     private FileInputStream fis;
     private OutputStream out;
     private InputStream is;
 
     public HttpUploadSocket(Map<String, String> params, File file, String host, int port) {
         this .params = params;
         this .file = file;
         this .host = host;
         this .port = port;
     }
 
     public void run() {
         try {
             String fileName = file.getName();
             fis = new FileInputStream(file);
             long length = file.length();
             int size = ( int ) (length / bytesize) + 1 ;
             byte [] in = new byte [bytesize];
             for ( int i = 0 ; i < size; i++) {
                 int len = 0 ;
                 while ((len = fis.read(in)) != - 1 ) {
                     socketUpload(params, in, fileName, host, port, len);
                 }
             }
             Log.d( "SOCKET" , "获得InputStream" );
             is = mSocket.getInputStream();
             byte [] b = new byte [ 1024 * 10 ];
             int len = 0 ;
             while ((len = is.read(b)) != - 1 ) {
                 Log.d( "SOCKET" , "InputStream return " + new String(b, 0 , len));
                 break ;
             }
             Log.d( "SOCKET" , "close socket" );
         } catch (Exception e) {
             // TODO: handle exception
         } finally {
             try {
                 out.close();
                 is.close();
                 mSocket.close();
             } catch (Exception e2) {
             }
         }
     }
 
     private void socketUpload(Map<String, String> params, byte [] filebyte, String fileName, String host, int port, int len) throws UnknownHostException, IOException {
         byte [] param = this .createParamsContent(params); // 参数byte数组
         byte [] fileBoundary = this .createFileHeaderBoundary(fileName); // 文件头byte数组
         byte [] endBoundary = this .createContentEnd(); // 结束byte[]数组
         long fileLenths = len; // 文件Byte数组长度
         String countLengths = String.valueOf(param.length + fileBoundary.length + fileLenths + endBoundary.length);
         byte [] heand = this .createHeaders(countLengths, host); // 头byte数组
         Log.d( "SOCKET" , "param=" + param.length + " fileBoundary "
                 + fileBoundary.length + " endBoundary " + endBoundary.length
                 + " fileLenths" + fileLenths);
         connect(host, port); // 连接
         Log.d( "SOCKET" , "获得OutputStream" );
         out = mSocket.getOutputStream();
         Log.d( "SOCKET" , "写头文件" );
         out.write(heand, 0 , heand.length);
         Log.d( "SOCKET" , "头文件写入完成!" );
         Log.d( "SOCKET" , "写参数" );
         out.write(param, 0 , param.length);
         Log.d( "SOCKET" , "参数写入完成!" );
         Log.d( "SOCKET" , "写开始文件分割线" );
         out.write(fileBoundary, 0 , fileBoundary.length);
         Log.d( "SOCKET" , "文件分割线写入完成!" );
         Log.d( "SOCKET" , "写文件" );
         out.write(filebyte, 0 , len);
         Log.d( "SOCKET" , "文件写入完成!" );
         Log.d( "SOCKET" , "写结尾文件分割线" );
         out.write(endBoundary, 0 , endBoundary.length);
         Log.d( "SOCKET" , "结尾文件分割线写入完成!" );
         Log.d( "SOCKET" , "上传完毕!" );
     }
 
     private void connect(String host, int port) throws UnknownHostException, IOException {
         if (mSocket == null ) {
             Log.d( "SOCKET" , "建立 socket 连接" );
             mSocket = new Socket(host, port);
             mSocket.setSoTimeout( 10000 );
             mSocket.setKeepAlive( true );
             mSocket.setReuseAddress( true );
         } else {
             Log.d( "SOCKET" , "socket 已连接" );
         }
     }
 
     public void removeFile(String path) {
         File file = new File(path);
         if (file.exists() && file.isFile()) {
             if (file.delete()) {
                 Log.i( "SOCKET" , "删除文件" + path);
             }
         }
     }
}
天青色等烟雨love
关注
专栏目录
Python Web开发（三）：HTTP请求的url路由
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
07-04 3万+
Python Web开发（三）：HTTP请求的url路由。如何用HTTP去请求url路由呐，我来告诉你！
Spring Boot进阶(72)：【教程】用Spring Boot和HttpClient实现高效的HTTP请求
最新发布
**My Coding Family**
06-29 4759
本文主要包括以下内容： 使用Spring Boot和HttpClient实现基础的HTTP请求 实现带有请求头和请求体的HTTP请求 实现HTTPS请求 借助于Apache HttpClient的高级特性，如连接池、请求重试、请求超时等 通过单元测试验证HTTP请求的正确性和可靠性
try catch 用法(marksheng)
Mark Sheng的博客
04-12 776
在实际应用中，碰到了一个问题，就是在动态生成一个表格的时候，从后台接收到的的数据和表头名称是不同的接口，而表格的id是在表头名称这个接口动态生成的，所以就会导致一个问题，在火狐浏览器中，响应请求比较慢 这个时候我们就可以使用 try catch 方法 来 处理浏览器的位置错误 下面是相对简单的例子: try { foo.bar(); } catch (e) { if (e instanceof EvalError) { alert(e.name + ":" + e.message); }...
try catch理解
imkaifan的博客
10-16 229
先try 去执行代码，当请求遇到错的时候，就去执行catch，然后将其隐藏。 确保代码更加的健壮，不会请求出错后一直在loading async getHousesList(id) { try { Toast.loading("Loading...", 0, null, false); const { data: res } = await axios.get("http://localhost:8080/houses", { params: {
一定要执行多个请求，都要捕获错误，使用try catch 不够优雅
god953的博客
07-19 327
捕获多个请求的异常
java try catch 接口_try-catch语句块和 AutoCloseable接口
weixin_35990136的博客
02-25 456
早期java捕捉异常的语法是这样的：try{//do something}catch(Exception e){//handle it}finally{}而到了JDK7之后，可以使用try-with-resources和multiple catch：try(FileInputStream inputStream = new FileInputStream(new File("test")){//t...
后台发起HTTP请求时 catch块捕捉 未输入字节流长度解决方案
zhangx1224的博客
08-14 656
发起请求前添加System.Net.ServicePointManager.Expect100Continue = false;
C++通过HTTP请求Post方式请求Json数据示例程序
08-16
最近在工作中，由于合作商只提供uRL，我这边需要通过HTTP请求Get或Post方式请求Json数据，然后解析JSON格式，解析json我使用的第三方库rapidjson。开发环境是64位win7，VS2015。
C++编写的Linux下Http请求
05-10
本篇将深入探讨使用C++在Linux环境下实现HTTP请求，包括GET和POST方法。 HTTP（超文本传输协议）是互联网上应用最广泛的一种网络协议，用于从万维网服务器传输超文本到本地浏览器的传输协议。它是一个基于请求与...
Java 发送 HTTP 请求的两种常用方法
qhh0205
05-16 5959
本文主要介绍在 Java 编程中发送 HTTP 请求的两种常用方法： JDK 原生的 HttpURLConnection 发送 HTTP 请求 Apache HhttpClient 发送 HTTP 请求 两种方法都可以发送 HTTP 请求，第一种是 Java 原生的，因此使用起来相对麻烦一些，第二种是通过第三方的包来实现，这个包是 Apache 旗下的专门用来发送 HTTP 请求的 HttpClient 包，是对 Java 原生的 HttpURLConnection 扩展，因此功能也更加强大，使用起来也
关于js 中 try catch用法
前端如逆水行舟...
10-03 9715
try…catch语法，简单来说就是用来捕获异常的，我就简述一下我遇到的问题，或许你可以从我遇到的问题中明白他的作用。 当使用vuex在actions发请求时，这个接口不仅可以添加购物车数据，同时也可更新产品的数量，我就在更新产品数量的地方出现了问题，......
axios请求成功进入catch原因
zhuxiaobo09的专栏
12-29 4483
使用axios进行请求，浏览器f12检查，请求成功。但是代码逻辑还是进入axios的catch模块，并且打印为undefined. 刚开始以为是then中业务异常抛出，后只放console.log也出错，排除。 原因分析：发现axios中 是有响应拦截器的 代码如下 axios.interceptors.response.use(function (response) { if(response.headers.token){ storage.setToke
java http 请求的异常处理
超超的博客
07-16 1万+
为什么要处理http请求异常？ 因为网络是不稳定的、不可靠的，不能保证每次通知每次请求都可以发送或者接受成功。 最近在优化之前公司之前用的支付服务，要求对可能出现的所有网络状况进行异常处理，保证任何情况下都有良好的处理方式。 公司当前的采用了分布式系统来支持整个购票支付业务流程，其中涉及到网络的部分有1、票务服务去三方票务系统中查询票务；2、票务服务通知支付服务生成订单；3、支付完成之后付款方回调...
优化trycatch(完结)
weixin_45371730的博客
12-20 1030
前言:阅读这篇文章前建议先看一下前置知识点 指路:优化trycatch所需的前置知识点_多多的小宝贝的博客-CSDN博客 啦啦啦~通过前面的知识我们已经知道:promise对象的then方法中虽然不能直接获取到请求失败的结果,但是我们可以借助一个新的Promise对象来中转一下,这样就可以在Promise对象的then方法中取到请求失败的结果啦~ 实现思路:利用promise对象A then方法返回的那个全新Promise对象B(全新:意思就是他就是他,和别的Promise对象不一样,是独立存在的)来中
坑爹的后台http请求失败网页请求却可以
TryCatch
12-04 3927
今天开发的时候遇到一件特别奇葩的事情，就是在请求网络的时候没有数据，老是请求失败，用火狐却可以请求到结果。我就跑去跟后台说他们接口有问题，不说还好一说就起争执了（别误会哦，在开发过程起争执是很正常的哦，），他说我解析错误，我跟她说我没有解析啊，，我是先抓数据在解析，数据没抓到怎么解析啊，后面他后台监控看了下，，发现果然是后台问题，对此只能说无语！！！！！
Javascript错误处理——try...catch
热门推荐
neweastsun的专栏
07-29 1万+
Javascript错误处理——try…catch 无论我们编程多么精通，脚本错误怎是难免。可能是我们的错误造成，或异常输入，错误的服务器端响应以及无数个其他原因。 通常，当发送错误时脚本会立刻停止，打印至控制台。 但try...catch语法结构可以捕获错误并可以做更多的事情，而不是直接停止。 “try…catch” 语法try...catch结构有两个语句块，即try，然
api接口必备 try catch实例(操作mongo)
cominglately的博客
07-27 1923
/** * 更新mongo * @param string $table_name * @param array $where * @param array $data * @param array $options * @return boolean */ public function updateMongo($table_name, $where, $data, $option
Java网络编程：深入理解HTTP请求
"本文主要探讨了Java网络编程中关于HTTP请求的基本概念和使用，适合对Java网络编程感兴趣的读者参考学习。" 在Java网络编程中，HTTP（超文本传输协议）请求是客户端与服务器进行交互的基础。HTTP请求由多个部分组成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值