Android的三种网络联接方式
1、标准Java接口:java.net.*提供相关的类
//定义地址
URL url = new URL("http://www.google.com");
//打开连接
HttpURLConnection http = (HttpURLConnection) url.openConnection(); 2、Apache接口:android.net.http.*
//DefaultHttpClient表示默认属性
HttpClient httpClient = new DefaultHttpClient();
//HttpGet实例
HttpGet get = new HttpGet("http://www.google.com");
HttpResponse rp = httpClient.execute(get);
其中post的方式请求步骤比较复杂 3、Android接口:android.net.*
//IP地址
InetAddress inetAddress = InetAddress.getByName("192.168.1.1");
//端口
Socket client = new Socket(inetAddress,61203,true);
//取得数据
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();
Android网络连接之HttpURLConnection和HttpClient
转 http://www.cnblogs.com/devinzhang/archive/2012/01/17/2325092.html
1.概念
HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了,越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能:HttpURLConnection。但是对于大部分应用程序来说,JDK 库本身提供的功能还不够丰富和灵活。
除此之外,在Android中,androidSDK中集成了Apache的HttpClient模块,用来提供高效的、最新的、功能丰富的支持 HTTP 协议工具包,并且它支持 HTTP 协议最新的版本和建议。使用HttpClient可以快速开发出功能强大的Http程序。
2.区别
HttpClient是个很不错的开源框架,封装了访问http的请求头,参数,内容体,响应等等,
HttpURLConnection是java的标准类,什么都没封装,用起来太原始,不方便,比如重访问的自定义,以及一些高级功能等。
URLConnection |
HTTPClient |
|
---|---|---|
Proxies and SOCKS |
Full support in Netscape browser, appletviewer, and applications (SOCKS: Version 4 only); no additional limitations from security policies. |
Full support (SOCKS: Version 4 and 5); limited in applets however by security policies; in Netscape can't pick up the settings from the browser. |
Authorization |
Full support for Basic Authorization in Netscape (can use info given by the user for normal accesses outside of the applet); no support in appletviewer or applications. |
Full support everywhere; however cannot access previously given info from Netscape, thereby possibly requesting the user to enter info (s)he has already given for a previous access. Also, you can add/implement additional authentication mechanisms yourself. |
Methods |
Only has GET and POST. |
Has HEAD, GET, POST, PUT, DELETE, TRACE and OPTIONS, plus any arbitrary method. |
Headers |
Currently you can only set any request headers if you are doing a POST under Netscape; for GETs and the JDK you can't set any headers. |
Allows any arbitrary headers to be sent and received. |
Automatic Redirection Handling |
Yes. |
Yes (as allowed by the HTTP/1.1 spec). |
Persistent Connections |
No support currently in JDK; under Netscape uses HTTP/1.0 Keep-Alive's. |
Supports HTTP/1.0 Keep-Alive's and HTTP/1.1 persistence. |
Pipelining of Requests |
No. |
Yes. |
Can handle protocols other than HTTP |
Theoretically; however only http is currently implemented. |
No. |
Can do HTTP over SSL (https) |
Under Netscape, yes. Using Appletviewer or in an application, no. |
No (not yet). |
Source code available |
No. |
Yes. |
3.案例
URLConnection
String urlAddress = "http://192.168.1.102:8080/AndroidServer/login.do";
URL url;
HttpURLConnection uRLConnection;
public UrlConnectionToServer(){ }
//向服务器发送get请求
public String doGet(String username,String password){
String getUrl = urlAddress + "?username="+username+"&password="+password;
try {
url = new URL(getUrl);
uRLConnection = (HttpURLConnection)url.openConnection();
InputStream is = uRLConnection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String response = "";
String readLine = null;
while((readLine =br.readLine()) != null){
//response = br.readLine();
response = response + readLine;
}
is.close();
br.close();
uRLConnection.disconnect();
return response;
} catch (MalformedURLException e) {
e.printStackTrace();
return null;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
//向服务器发送post请求
public String doPost(String username,String password){
try {
url = new URL(urlAddress);
uRLConnection = (HttpURLConnection)url.openConnection();
uRLConnection.setDoInput(true);
uRLConnection.setDoOutput(true);
uRLConnection.setRequestMethod("POST");
uRLConnection.setUseCaches(false);
uRLConnection.setInstanceFollowRedirects(false);
uRLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
uRLConnection.connect(); DataOutputStream out = new DataOutputStream(uRLConnection.getOutputStream());
String content = "username="+username+"&password="+password;
out.writeBytes(content);
out.flush();
out.close(); InputStream is = uRLConnection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String response = "";
String readLine = null;
while((readLine =br.readLine()) != null){
//response = br.readLine();
response = response + readLine;
}
is.close();
br.close();
uRLConnection.disconnect();
return response;
} catch (MalformedURLException e) {
e.printStackTrace();
return null;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
HTTPClient
String urlAddress = "http://192.168.1.102:8080/qualityserver/login.do";
public HttpClientServer(){ } public String doGet(String username,String password){
String getUrl = urlAddress + "?username="+username+"&password="+password;
HttpGet httpGet = new HttpGet(getUrl);
HttpParams hp = httpGet.getParams();
hp.getParameter("true");
//hp.
//httpGet.setp
HttpClient hc = new DefaultHttpClient();
try {
HttpResponse ht = hc.execute(httpGet);
if(ht.getStatusLine().getStatusCode() == HttpStatus.SC_OK){
HttpEntity he = ht.getEntity();
InputStream is = he.getContent();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String response = "";
String readLine = null;
while((readLine =br.readLine()) != null){
//response = br.readLine();
response = response + readLine;
}
is.close();
br.close(); //String str = EntityUtils.toString(he);
System.out.println("========="+response);
return response;
}else{
return "error";
}
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return "exception";
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return "exception";
}
} public String doPost(String username,String password){
//String getUrl = urlAddress + "?username="+username+"&password="+password;
HttpPost httpPost = new HttpPost(urlAddress);
List params = new ArrayList();
NameValuePair pair1 = new BasicNameValuePair("username", username);
NameValuePair pair2 = new BasicNameValuePair("password", password);
params.add(pair1);
params.add(pair2); HttpEntity he;
try {
he = new UrlEncodedFormEntity(params, "gbk");
httpPost.setEntity(he); } catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} HttpClient hc = new DefaultHttpClient();
try {
HttpResponse ht = hc.execute(httpPost);
//连接成功
if(ht.getStatusLine().getStatusCode() == HttpStatus.SC_OK){
HttpEntity het = ht.getEntity();
InputStream is = het.getContent();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String response = "";
String readLine = null;
while((readLine =br.readLine()) != null){
//response = br.readLine();
response = response + readLine;
}
is.close();
br.close(); //String str = EntityUtils.toString(he);
System.out.println("=========&&"+response);
return response;
}else{
return "error";
}
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return "exception";
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return "exception";
}
}
servlet端json转化:
resp.setContentType("text/json");
resp.setCharacterEncoding("UTF-8");
toDo = new ToDo();
List<UserBean> list = new ArrayList<UserBean>();
list = toDo.queryUsers(mySession);
String body; //设定JSON
JSONArray array = new JSONArray();
for(UserBean bean : list)
{
JSONObject obj = new JSONObject();
try
{
obj.put("username", bean.getUserName());
obj.put("password", bean.getPassWord());
}catch(Exception e){}
array.add(obj);
}
pw.write(array.toString());
System.out.println(array.toString());
android端接收:
String urlAddress = "http://192.168.1.102:8080/qualityserver/result.do";
String body =
getContent(urlAddress);
JSONArray array = new JSONArray(body);
for(int i=0;i<array.length();i++)
{
obj = array.getJSONObject(i);
sb.append("用户名:").append(obj.getString("username")).append("\t");
sb.append("密码:").append(obj.getString("password")).append("\n"); HashMap<String, Object> map = new HashMap<String, Object>();
try {
userName = obj.getString("username");
passWord = obj.getString("password");
} catch (JSONException e) {
e.printStackTrace();
}
map.put("username", userName);
map.put("password", passWord);
listItem.add(map); } } catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} if(sb!=null)
{
showResult.setText("用户名和密码信息:");
showResult.setTextSize(20);
} else
extracted(); //设置adapter
SimpleAdapter simple = new SimpleAdapter(this,listItem,
android.R.layout.simple_list_item_2,
new String[]{"username","password"},
new int[]{android.R.id.text1,android.R.id.text2});
listResult.setAdapter(simple); listResult.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
int positionId = (int) (id+1);
Toast.makeText(MainActivity.this, "ID:"+positionId, Toast.LENGTH_LONG).show(); }
});
}
private void extracted() {
showResult.setText("没有有效的数据!");
}
//和服务器连接
private String getContent(String url)throws Exception{
StringBuilder sb = new StringBuilder();
HttpClient client =new DefaultHttpClient();
HttpParams httpParams =client.getParams(); HttpConnectionParams.setConnectionTimeout(httpParams, 3000);
HttpConnectionParams.setSoTimeout(httpParams, 5000);
HttpResponse response = client.execute(new HttpGet(url));
HttpEntity entity =response.getEntity(); if(entity !=null){
BufferedReader reader = new BufferedReader(new InputStreamReader
(entity.getContent(),"UTF-8"),8192);
String line =null;
while ((line= reader.readLine())!=null){
sb.append(line +"\n");
}
reader.close();
}
return sb.toString();
}
HttpURLConnection 类是一种重要的访问 HTTP 资源的方式。HttpURLConnection 类具有完全的访问能力,可以取代HttpGet和HttpPost类。使用HttpUrlConnection 访问HTTP资源可以使用如
下几步:
.使用java.net.URL封装HTTP资源的url,并使用openConnection方法获得HttpUrlConnection 对象,代码如下:
URL url = new URL("http://www.blogjava.net/nokiaguy/archive/2009/12/14/305890.html");
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
.设置请求方法,例如GET、POST等,代码如下:
httpURLConnection.setRequestMethod("POST");
要注意的是,setRequestMethod方法的参数值必须大写,例如GET、POST等。
.设置输入输出及其他权限。如果要下载 HTTP资源或向服务端上传数据,需要使用如下代码进行设置:
// 下载 HTTP资源,需要将setDoInput方法的参数值设为true
httpURLConnection.setDoInput(true);
// 上传数据,需要将setDoOutput方法的参数值设为true
httpURLConnection.setDoOutput(true);
HttpURLConnection 类还包含更多的选项,例如,使用下面的代码可以禁止HttpURLConnection使用缓存。
httpURLConnection.setUseCaches(false);
.设置HTTP请求头。在很多情况下,要根据实际情况设置一些HTTP请求头,例如下面的代码设置了Charset请求头的值为UTF-8。
httpURLConnection.setRequestProperty("Charset", "UTF-8");
.输入和输出数据。这一步是对 HTTP 资源的读写操作,也就是通过 InputStream 和OutputStream读取和写入数据。下面的代码获得了InputStream对象和OutputStream对象。
InputStream is = httpURLConnection.getInputStream();
OutputStream os = httpURLConnection.getOutputStream();
至于是先读取还是先写入数据,需要根据具体情况而定。
.关闭输入输出流。虽然关闭输入输出流并不是必需的,在应用程序结束后,输入输出流会自动关闭,但显式关闭输入输出流是一个好习惯。关闭输入输出流的代码如下:
is.close();
os.close();
转http://www.eoeandroid.com/thread-314728-1-1.html
最近在研究Volley框架的源码,发现它在HTTP请求的使用上比较有意思,在Android 2.3及以上版本,使用的是HttpURLConnection,而在Android 2.2及以下版本,使用的是HttpClient。我也比较好奇这么使用的原因,于是专门找到了一位Google的工程师写的一篇博客,文中对 HttpURLConnection和HttpClient进行了对比,下面我就给大家简要地翻译一下。
原文地址:http://android-developers.blogspot.com/2011/09/androids-http-clients.html
大多数的Android应用程序都会使用HTTP协议来发送和接收网络数据,而Android中主要提供了两种方式来进行HTTP操
作,HttpURLConnection和HttpClient。这两种方式都支持HTTPS协议、以流的形式进行上传和下载、配置超时时间、IPv6、
以及连接池等功能。
HttpClientDefaultHttpClient和它的兄弟AndroidHttpClient都是HttpClient具体的实现类,它们都拥有众多的API,而且实现比较稳定,bug数量也很少。
但同时也由于HttpClient的API数量过多,使得我们很难在不破坏兼容性的情况下对它进行升级和扩展,所以目前Android团队在提升和优化HttpClient方面的工作态度并不积极。
HttpURLConnectionHttpURLConnection是一种多用途、轻量极的HTTP客户端,使用它来进行HTTP操作可以适用于大多数的应用程序。虽然HttpURLConnection的API提供的比较简单,但是同时这也使得我们可以更加容易地去使用和扩展它。
不过在Android 2.2版本之前,HttpURLConnection一直存在着一些令人厌烦的bug。比如说对一个可读的InputStream调用close()方法时,就有可能会导致连接池失效了。那么我们通常的解决办法就是直接禁用掉连接池的功能:
[java] view plaincopy
- private void disableConnectionReuseIfNecessary() {
- // 这是一个2.2版本之前的bug
- if (Integer.parseInt(Build.VERSION.SDK) < Build.VERSION_CODES.FROYO) {
- System.setProperty("http.keepAlive", "false");
- }
- }
在Android 2.3版本的时候,我们加入了更加透明化的响应压缩。HttpURLConnection会自动在每个发出的请求中加入如下消息头,并处理相应的返回结果:Accept-Encoding: gzip
配置你的Web服务器来支持对客户端的响应进行压缩的功能,从而可以在这一改进上获取到最大的好处。如果在压缩响应的时候出现了问题,这篇文档会告诉你如何禁用掉这个功能。
但是如果启动了响应压缩的功能,HTTP响应头里的Content-Length就会代表着压缩后的长度,这时再使用
getContentLength()方法来取出解压后的数据就是错误的了。正确的做法应该是一直调用InputStream.read()方法来读取响
应数据,一直到出现-1为止。
我们在Android 2.3版本中还增加了一些HTTPS方面的改进,现在HttpsURLConnection会使用SNI(Server Name
Indication)的方式进行连接,使得多个HTTPS主机可以共享同一个IP地址。除此之外,还增加了一些压缩和会话的机制。如果连接失败,它会自
动去尝试重新进行连接。这使得HttpsURLConnection可以在不破坏老版本兼容性的前提下,更加高效地连接最新的服务器。
在Android 4.0版本中,我们又添加了一些响应的缓存机制。当缓存被安装后(调用HttpResponseCache的install()方法),所有的HTTP请求都会满足以下三种情况:
所有的缓存响应都由本地存储来提供。因为没有必要去发起任务的网络连接请求,所有的响应都可以立刻获取到。
视情况而定的缓存响应必须要有服务器来进行更新检查。比如说客户端发起了一条类似于 “如果/foo.png这张图片发生了改变,就将它发送给我”
这样的请求,服务器需要将更新后的数据进行返回,或者返回一个304 Not
Modified状态。如果请求的内容没有发生,客户端就不会下载任何数据。
没有缓存的响应都是由服务器直接提供的。这部分响应会在稍后存储到响应缓存中。
由于这个功能是在4.0之后的版本才有的,通常我们就可以使用反射的方式来启动响应缓存功能。下面的示例代码展示了如何在Android 4.0及以后的版本中去启用响应缓存的功能,同时还不会影响到之前的版本:
[java] view plaincopy
- private void enableHttpResponseCache() {
- try {
- long httpCacheSize = 10 * 1024 * 1024; // 10 MiB
- File httpCacheDir = new File(getCacheDir(), "http");
- Class.forName("android.net.http.HttpResponseCache")
- .getMethod("install", File.class, long.class)
- .invoke(null, httpCacheDir, httpCacheSize);
- } catch (Exception httpResponseCacheNotAvailable) {
- }
- }
你也应该同时配置一下你的Web服务器,在HTTP响应上加入缓存的消息头。哪一种才是最好的?在Android 2.2版本之前,HttpClient拥有较少的bug,因此使用它是最好的选择。
而在Android
2.3版本及以后,HttpURLConnection则是最佳的选择。它的API简单,体积较小,因而非常适用于Android项目。压缩和缓存机制可
以有效地减少网络访问的流量,在提升速度和省电方面也起到了较大的作用。对于新的应用程序应该更加偏向于使用HttpURLConnection,因为在
以后的工作当中我们也会将更多的时间放在优化HttpURLConnection上面。
客户端Socket连接服务器与服务器交互的代码如下
Socket socket = new Socket("192.168.17.100", 8080); 或者 Socket socket = new Socket(); socket.connect(new InetSocketAddress("192.168.18.100", 8080));
OutputStream os = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os)
BufferedWriter bw = new BufferedWriter(osw);
// 向服务器写数据
bw.write("hello world\r\n\r\n");
bw.flush();
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String s = "";
// 从服务器读数据
while((s = br.readLine()) != null)
Log.d("line", s);
// 下面的代码关闭输入输出流以及Socket连接
os.close();
is.close();
socket.close();
服务端Socket:
ServerSocket serverSocket = new ServerSocket(1234); // ServerSocket serverSocket = new ServerSocket(1234, 100); 100为请求队列的长度
// 处理其他任务的代码
while(true)
{
Socket socket = serverSocket.accept(); // 等待接收客户端请求
// 处理其他任务的代码
new ThreadClass(socket).start(); // 创建并运行处理客户端请求的线程
}
上传文件的HTTP请求信息分为如下部分:
1. 分界符。由两部分组成:两个连字符“--”和一个任意字符串。使用浏览器上传文件一般为“-----------------数字”。分界符为单独一行。
2. 上传文件的相关信息。这些信息包括请求参数名、上传文件名、文件类型,但并不仅限于此,例如Content-Disposition: form-data; name="file"; filename="abc.jpg"。
3. 上传文件的内容。字节流形式。
4. 文件全部上传后的结束符。这个符号在图中并没有显示出来。当上传的文件是最后一个时,在 HTTP请求信息的结尾就会出现这个符号字符串。结束符和分界符类似,只是在分界符后面再加两个连字符,例如,“-----------------------------------218813199810322--”就是一个结束符。
aaarticlea/png;base64,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" alt="" />
Android SDK支持访问HTTPS资源,代码如下:
// 信任所有的host
HostnameVerifier hostnameVerifier =
org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
SchemeRegistry registry = new SchemeRegistry();
SSLSocketFactory socketFactory = SSLSocketFactory.getSocketFactory();
socketFactory.setHostnameVerifier((X509HostnameVerifier) hostnameVerifier);
registry.register(new Scheme("https", socketFactory, 443));
// 像访问HTTP资源一样使用httpClient 和 httpPost
DefaultHttpClient client = new DefaultHttpClient();
SingleClientConnManager mgr = new SingleClientConnManager(client.getParams(), registry);
DefaultHttpClient httpClient = new DefaultHttpClient(mgr, client.getParams());
HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
HttpPost httpPost = new HttpPost("https://www.myhttps.com");
// 下面的代码和访问HTTP资源完全一样
...
[Android] HttpURLConnection & HttpClient & Socket的更多相关文章
-
android httpUrlConnection HttpClient
韩梦飞沙 韩亚飞 313134555@qq.com yue31313 han_meng_fei_sha httpUrlConnection 超文本传输协议统一资源定位器连接 http 超 ...
-
Android 网络编程 Socket Http
前言 欢迎大家我分享和推荐好用的代码段~~ 声明 欢迎转载,但请保留文章原始出处: CSDN:http://www.csdn.net ...
-
Android HttpURLConnection源代码分析
Android HttpURLConnection源代码分析 之前写过HttpURLConnection与HttpClient的差别及选择.后来又分析了Volley的源代码. 近期又遇到了问题,想在V ...
-
Android 网络编程 Socket
1.服务端开发 创建一个Java程序 public class MyServer { // 定义保存所有的Socket,与客户端建立连接得到一个Socket public static List< ...
-
Android中基于Socket的网络通信
1. Socket介绍 2. ServerSocket的建立与使用 3. 使用ServerSocket建立聊天服务器-1 4. 使用ServerSocket建立聊天服务器-2 5. 在Android中 ...
-
Android HttpURLConnection.connect找不到源 HttpURLConnection连接失败 HttpURLConnection.connect IO异常 解决办法
Android HttpURLConnection.connect找不到源 HttpURLConnection连接失败 HttpURLConnection.connect IO异常 解决办法 以下代 ...
-
在Android上使用Socket
原文地址:http://www.cnblogs.com/kross/p/3621952.html 考虑到以后可能要用到这方面的知识,就来写个Demo尝试下,其实以前学过,但不记得了……(用不到的东西各 ...
-
Android 网络通信之Socket
Android 网络通信之Socket 应用软件的网络通信无非就是Socket和HTTP,其中Socket又可以用TCP和UDP,HTTP的话就衍生出很多方式,基础的HTTP GET和POST请求,然 ...
-
【Android实战】Socket消息通信
这篇博客的内容是基于http://my.oschina.net/fengcunhan/blog/178155进行改造的.所以须要先看完这篇博客,然后再来看以下的内容. 1.须要完毕的功能是直播间的so ...
随机推荐
-
webapi aspose导出excel表格
API 通过get请求,注意用到一个[FromUri]特性,使GET接收实体参数 /// <summary> /// 导出 /// </summary> /// <par ...
-
PHP 底层的运行机制与原理
PHP说简单,但是要精通也不是一件简单的事.我们除了会使用之外,还得知道它底层的工作原理. PHP是一种适用于web开发的动态语言.具体点说,就是一个用C语言实现包含大量组件的软件框架.更狭义点看,可 ...
-
tcp/ip程序
#include<stdio.h> #include<stdlib.h> #include<errno.h> #include<string.h> #i ...
-
[Express] Level 1: First Step
Installing Express Let's start building our new Express application by installing Express. Type the ...
-
python time模块详解(转)
python 的内嵌time模板翻译及说明 一.简介 time模块提供各种操作时间的函数 说明:一般有两种表示时间的方式: 第一种是时间戳的方式(相对于1970.1.1 00:00 ...
-
spark HA 安装配置和使用(spark1.2-cdh5.3)
安装环境如下: 操作系统:CentOs 6.6 Hadoop 版本:CDH-5.3.0 Spark 版本:1.2 集群5个节点 node01~05 node01~03 为worker. node04. ...
-
Android——service重启
一.在application中注册消息监听 public class BackgroundServiceApplication extends Application { @Override publ ...
-
软交所--微软将对IE浏览器进行关键性安全更新
微软于当地时间周四宣布下周二,即本月的"补丁星期二"推送九个安全升级. 当中最重要的就是解决IE浏览器远程运行代码(RCE)漏洞,这个漏洞影响从IE6至IE11全版本号,全部Win ...
-
hibernate---一级缓存, 二级缓存, 查询缓存
缓存: 内存开辟一块空间,把本来存在硬盘的东西放在内存里, 以后从内存读取. 一级缓存: session级别的缓存, session.load 二级缓存: 总的缓存.
-
解读vscode断点调试配置文件【待续】
一.参考链接 https://code.visualstudio.com/Docs/editor/debugging https://code.visualstudio.com/docs/nodejs ...