跨域

跨域请求如何携带cookie

学习withCredentials属性；
学习axios配置withCredentials；
学习设置Access-Control-Allow-Origin属性；
学习设置Access-Control-Allow-Credentials属性；
学习解决跨域请求携带源站 cookie 的问题；

一. 搭建一个跨域请求的环境

思路：

使用 express 搭建第一个服务 A(http://localhost:8000)，运行在 8000 端口上；
A 服务托管 index.html(用于在前端页面发送网络请求)文件；
在 A 服务中写一个处理请求的路由，加载 index.html 页面时，种下 cookie(这里种 cookie 为了在请求 B 服务时携带上);
使用 express 搭建第二个服务 B(http://localhost:8003)，运行在 8003 端口上；
在 A 服务托管的 index.html 页面去请求 B 服务，然后把 cookie 传过去；

先看下代码结构，相对比较的简单：

// src/app1.js
const express = require("express");
const app = express();

// `index.html` 加载时会请求login接口
// 设置`cookie`
app.get("/login", (req, res) => {
  res.cookie("user", "jay", { maxAge: 2000000, httpOnly: true });
  res.json({ code: 0, message: "登录成功" });
});

// 此接口是检测`cookie`是否设置成功，如果设置成功的话，浏览器会自动携带上`cookie`
app.get("/user", (req, res) => {
  // req.headers.cookie: user=jay
  const user = req.headers.cookie.split("=")[1];
  res.json({ code: 0, user });
});

// 托管`index.html`页面
// 这样的话在`index.html`中发起的请求，默认的源就是`http://localhost:8000`
// 然后再去请求`http://localhost:8003`就会出现跨域了
app.use("/static", express.static("public"));

app.listen("8000", () => {
  console.log("app1 running at port 8000");
});

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <h2>this is index.html at port 8000</h2>
    <button id="button">发送同源请求</button>
    <button id="cross-button">发送跨域请求</button>
    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
    <script>
      const button = document.querySelector("#button");
      const crossButton = document.querySelector("#cross-button");

      axios.get("http://localhost:8000/login", {}).then((res) => {
        console.log(res);
      });
      // 发送同域请求
      button.onclick = function () {
        axios.get("http://localhost:8000/user", {}).then((res) => {
          console.log(res);
        });
      };
      // 发送跨域请求
      crossButton.onclick = function () {
        axios({
          method: "get",
          url: "http://localhost:8003/anotherService",
        }).then((res) => {
          console.log(res);
        });
      };
    </script>
  </body>
</html>

// src/app2.js
const express = require("express");
const app = express();

// 定义一个接口，index.html页面请求这个接口就是跨域（因为端口不同）
app.get("/anotherService", (req, res) => {
  res.json({ code: 0, msg: "这是8003端口返回的" });
});

app.listen("8003", () => {
  console.log("app2 running at port 8003");
});

首先先在 A 服务的 index.html 页面中得到一个 cookie,运行 A 服务：

npm install express -D
node src/app1.js

然后打开 http://localhost:8000/static/index.html: 没有问题的话，页面长这样：
![image](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b2e0edc978b7481093b171a09c7545f9~tplv-k3u1fbpfcp-zoom-in-crop-mark:1304:0:0:0.awebp?_

这个时候 F12 打开控制台：可以看到发送了一个 login 请求，并且设置了 cookie,也可以选择浏览器控制台的 Application 页签，选中 cookie，可以看到 cookie 的信息：

然后点击页面上的发送同源请求按钮，可以看到发送了一个 user 请求，并且已经携带上了 cookie：

接下来刺激的画面来了，点击发送跨域请求按钮，出现了跨域请求的报错：

** 重点：接下来开始解决跨域携带 cookie 问题：

1. 在前端请求的时候设置 request 对象的属性 withCredentials 为 true;

什么是 withCredentials？
XMLHttpRequest.withCredentials 属性是一个 Boolean 类型，它指示了是否该使用类似 cookies,authorization headers(头部授权)或者 TLS 客户端证书这一类资格证书来创建一个跨站点访问控制（cross-site Access-Control）请求。在同一个站点下使用 withCredentials 属性是无效的。
如果在发送来自其他域的 XMLHttpRequest 请求之前，未设置 withCredentials 为 true，那么就不能为它自己的域设置 cookie 值。而通过设置 withCredentials 为 true 获得的第三方 cookies，将会依旧享受同源策略，因此不能被通过 document.cookie 或者从头部相应请求的脚本等访问。

// 修改跨域请求的代码
crossButton.onclick = function () {
  axios({
    withCredentials: true, // ++ 新增
    method: "get",
    url: "http://localhost:8003/anotherService",
  }).then((res) => {
    console.log(res);
  });
};

这个时候再去发送一个跨域请求，会发现依旧报错，但是仔细看下报错，意思是需要设置 header 的 Access-Control-Allow-Origin 属性：

2. 在服务端设置 Access-Control-Allow-Origin

修改 B(app2.js)服务的代码：

// 在所有路由前增加，可以拦截所有请求
app.all("*", (req, res, next) => {
  res.header("Access-Control-Allow-Origin", "http://localhost:8000");
  next();
});

修改完之后再次发送一个跨域请求，会发现，又报错了，但是跟之前报的错不一样了，意思大概就是 Access-Control-Allow-Credentials 这个属性应该设置为 true，但是显示得到的是个''：

3. 在服务端设置 Access-Control-Allow-Credentials

再次修改 B 服务的代码（每次修改后需要重新运行）：

// 在所有路由前增加，可以拦截所有请求
app.all("*", (req, res, next) => {
  res.header("Access-Control-Allow-Origin", "http://localhost:8000");
  res.header("Access-Control-Allow-Credentials", "true"); // ++ 新增
  next();
});

再发送一个跨域请求：

可以看到，这个跨域请求已经请求成功并且返回数据了！而且也携带了 A 服务的 cookie，这个时候已经大功告成了。

三、总结

前端请求时在 request 对象中配置"withCredentials": true；
服务端在 response 的 header 中配置"Access-Control-Allow-Origin", "http://xxx😒{port}";
服务端在 response 的 header 中配置"Access-Control-Allow-Credentials", "true"

6种跨域方式实现原理

一、什么是跨域？

1. 什么是同源策略及其限制内容？

同源策略是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，浏览器很容易受到 XSS、CSRF(跨站请求伪造) 等攻击。所谓同源是指"协议+域名+端口"三者相同，即便两个不同的域名指向同一个 ip 地址，也非同源。

同源策略限制内容有：
Cookie、LocalStorage、IndexedDB 等存储性内容
DOM 节点
AJAX 请求发送后，结果被浏览器拦截了

但是有三个标签是允许跨域加载资源：

<img src=XXX>
<link href=XXX>
<script src=XXX>

2. 常见跨域场景

当协议、子域名、主域名、端口号中任意一个不相同时，都算作不同域。不同域之间相互请求资源，就算作“跨域”

特别说明两点：
第一：如果是协议和端口造成的跨域问题“前台”是无能为力的。
第二：在跨域问题上，仅仅是通过“URL 的首部”来识别而不会根据域名对应的 IP 地址是否相同来判断。“URL 的首部”可以理解为“协议, 域名和端口必须匹配”。

这里或许有个疑问：请求跨域了，那么请求到底发出去没有？

跨域并不是请求发不出去，请求能发出去，服务端能收到请求并正常返回结果，只是结果被浏览器拦截了。可能会疑问明明通过表单的方式可以发起跨域请求，为什么 Ajax 就不会?因为归根结底，跨域是为了阻止用户读取到另一个域名下的内容，Ajax 可以获取响应，浏览器认为这不安全，所以拦截了响应。但是表单并不会获取新的内容，所以可以发起跨域请求。同时也说明了跨域并不能完全阻止 CSRF，因为请求毕竟是发出去了。

二、跨域解决方案

1. jsonp

(1) JSONP 原理
利用 <script> 标签没有跨域限制的漏洞，网页可以得到从其他来源动态产生的 JSON 数据。JSONP 请求一定需要对方的服务器做支持才可以。

(2) JSONP 和 AJAX 对比
JSONP 和 AJAX 相同，都是客户端向服务器端发送请求，从服务器端获取数据的方式。但 AJAX 属于同源策略，JSONP 属于非同源策略（跨域请求）

(3) JSONP 优缺点
JSONP 优点是简单兼容性好，可用于解决主流浏览器的跨域数据访问的问题。缺点是仅支持 get 方法具有局限性,不安全可能会遭受 XSS 攻击。

(4) JSONP 的实现流程
声明一个回调函数，其函数名(如 show)当做参数值，要传递给跨域请求数据的服务器，函数形参为要获取目标数据(服务器返回的 data)。
创建一个<script>标签，把那个跨域的 API 数据接口地址，赋值给 script 的 src,还要在这个地址中向服务器传递该函数名（可以通过问号传参:?callback=show）。
服务器接收到请求后，需要进行特殊的处理：把传递进来的函数名和它需要给数据拼接成一个字符串,例如：传递进去的函数名是 show，它准备好的数据是 show('不爱')。
最后服务器把准备的数据通过 HTTP 协议返回给客户端，客户端再调用执行之前声明的回调函数（show），对返回的数据进行操作。

在开发中可能会遇到多个 JSONP 请求的回调函数名是相同的，这时候就需要自己封装一个 JSONP 函数。

// index.html
function jsonp({ url, params, callback }) {
  return new Promise((resolve, reject) => {
    let script = document.createElement("script");
    window[callback] = function (data) {
      resolve(data);
      document.body.removeChild(script);
    };
    params = { ...params, callback }; // wd=b&callback=show
    let arrs = [];
    for (let key in params) {
      arrs.push(`${key}=${params[key]}`);
    }
    script.src = `${url}?${arrs.join("&")}`;
    document.body.appendChild(script);
  });
}
jsonp({
  url: "http://localhost:3000/say",
  params: { wd: "Iloveyou" },
  callback: "show",
}).then((data) => {
  console.log(data);
});

上面这段代码相当于向 http://localhost:3000/say?wd=Iloveyou&callback=show 这个地址请求数据，然后后台返回 show('不爱')，最后会运行 show()这个函数，打印出'不爱'

// server.js
let express = require("express");
let app = express();
app.get("/say", function (req, res) {
  let { wd, callback } = req.query;
  console.log(wd); // Iloveyou
  console.log(callback); // show
  res.end(`${callback}('不爱')`);
});
app.listen(3000);

(5) jQuery 的 jsonp 形式
JSONP 都是 GET 和异步请求的，不存在其他的请求方式和同步请求，且 jQuery 默认就会给 JSONP 的请求清除缓存。

$.ajax({
  url: "http://crossdomain.com/jsonServerResponse",
  dataType: "jsonp",
  type: "get", //可以省略
  jsonpCallback: "show", //->自定义传递给服务器的函数名，而不是使用 jQuery 自动生成的，可省略
  jsonp: "callback", //->把传递函数名的那个形参 callback，可省略
  success: function (data) {
    console.log(data);
  },
});

2. cors(跨源资源共享)

CORS 需要浏览器和后端同时支持。IE 8 和 9 需要通过 XDomainRequest 来实现。

浏览器会自动进行 CORS 通信，实现 CORS 通信的关键是后端。只要后端实现了 CORS，就实现了跨域。

服务端设置 Access-Control-Allow-Origin 就可以开启 CORS。该属性表示哪些域名可以访问资源，如果设置通配符则表示所有网站都可以访问资源。

虽然设置 CORS 和前端没什么关系，但是通过这种方式解决跨域问题的话，会在发送请求时出现两种情况，分别为简单请求和复杂请求。

(1)简单请求

只要同时满足以下两大条件，就属于简单请求

条件 1：使用下列方法之一：
GET
HEAD
POST

条件 2：Content-Type 的值仅限于下列三者之一：
text/plain
multipart/form-data
application/x-www-form-urlencoded
请求中的任意 XMLHttpRequestUpload 对象均没有注册任何事件监听器； XMLHttpRequestUpload 对象可以使用 XMLHttpRequest.upload 属性访问。

(2)复杂请求

不符合以上条件的请求就肯定是复杂请求了。
复杂请求的 CORS 请求，会在正式通信之前，增加一次 HTTP 查询请求，称为"预检"请求,该请求是 option 方法的，通过该请求来知道服务端是否允许跨域请求。

用 PUT 向后台请求时，属于复杂请求，后台需做如下配置：

// 允许哪个方法访问
res.setHeader('Access-Control-Allow-Methods', 'PUT')
// 预检的存活时间
res.setHeader('Access-Control-Max-Age', 6)
// OPTIONS请求不做任何处理
if (req.method === 'OPTIONS') {
  res.end()
}
// 定义后台返回的内容
app.put('/getData', function(req, res) {
  console.log(req.headers)
  res.end('不爱')
})

接下来看下一个完整复杂请求的例子，并且介绍下 CORS 请求相关的字段

// index.html
let xhr = new XMLHttpRequest();
document.cookie = "name=xiamen"; // cookie不能跨域
xhr.withCredentials = true; // 前端设置是否带cookie
xhr.open("PUT", "http://localhost:4000/getData", true);
xhr.setRequestHeader("name", "xiamen");
xhr.onreadystatechange = function () {
  if (xhr.readyState === 4) {
    if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) {
      console.log(xhr.response);
      //得到响应头，后台需设置Access-Control-Expose-Headers
      console.log(xhr.getResponseHeader("name"));
    }
  }
};
xhr.send();
//server1.js
let express = require("express");
let app = express();
app.use(express.static(__dirname));
app.listen(3000);
//server2.js
let express = require("express");
let app = express();
let whitList = ["http://localhost:3000"]; //设置白名单
app.use(function (req, res, next) {
  let origin = req.headers.origin;
  if (whitList.includes(origin)) {
    // 设置哪个源可以访问
    res.setHeader("Access-Control-Allow-Origin", origin);
    // 允许携带哪个头访问
    res.setHeader("Access-Control-Allow-Headers", "name");
    // 允许哪个方法访问
    res.setHeader("Access-Control-Allow-Methods", "PUT");
    // 允许携带cookie
    res.setHeader("Access-Control-Allow-Credentials", true);
    // 预检的存活时间
    res.setHeader("Access-Control-Max-Age", 6);
    // 允许返回的头
    res.setHeader("Access-Control-Expose-Headers", "name");
    if (req.method === "OPTIONS") {
      res.end(); // OPTIONS请求不做任何处理
    }
  }
  next();
});
app.put("/getData", function (req, res) {
  console.log(req.headers);
  res.setHeader("name", "jw"); //返回一个响应头，后台需设置
  res.end("不爱");
});
app.get("/getData", function (req, res) {
  console.log(req.headers);
  res.end("不爱");
});
app.use(express.static(__dirname));
app.listen(4000);

上述代码由 http://localhost:3000/index.html 向 http://localhost:4000/跨域请求，正如上面所说的，后端是实现 CORS 通信的关键。

3. postMessage

postMessage 是 HTML5 XMLHttpRequest Level 2 中的 API，且是为数不多可以跨域操作的 window 属性之一，它可用于解决以下方面的问题：
页面和其打开的新窗口的数据传递
多窗口之间消息传递
页面与嵌套的 iframe 消息传递
上面三个场景的跨域数据传递

postMessage()方法允许来自不同源的脚本采用异步方式进行有限的通信，可以实现跨文本档、多窗口、跨域消息传递。

otherWindow.postMessage(message, targetOrigin, [transfer]);

message: 将要发送到其他 window 的数据。
targetOrigin:通过窗口的 origin 属性来指定哪些窗口能接收到消息事件，其值可以是字符串"*"（表示无限制）或者一个 URI。在发送消息的时候，如果目标窗口的协议、主机地址或端口这三者的任意一项不匹配 targetOrigin 提供的值，那么消息就不会被发送；只有三者完全匹配，消息才会被发送。
transfer(可选)：是一串和 message 同时传递的 Transferable 对象. 这些对象的所有权将被转移给消息的接收方，而发送一方将不再保有所有权。

看个例子： http://localhost:3000/a.html 页面向 http://localhost:4000/b.html 传递“爱”,然后后者传回"不爱"。

<!-- // a.html -->
<iframe
  src="http://localhost:4000/b.html"
  frameborder="0"
  id="frame"
  onload="load()"
></iframe>
<!-- //等它加载完触发一个事件 //内嵌在http://localhost:3000/a.html -->
<script>
  function load() {
    let frame = document.getElementById("frame");
    frame.contentWindow.postMessage("爱", "http://localhost:4000"); //发送数据
    window.onmessage = function (e) {
      //接受返回数据
      console.log(e.data); //不爱
    };
  }
</script>

// b.html
window.onmessage = function (e) {
  console.log(e.data); //爱
  e.source.postMessage("不爱", e.origin);
};

4. websocket

Websocket 是 HTML5 的一个持久化的协议，它实现了浏览器与服务器的全双工通信，同时也是跨域的一种解决方案。WebSocket 和 HTTP 都是应用层协议，都基于 TCP 协议。但是 WebSocket 是一种双向通信协议，在建立连接之后，WebSocket 的 server 与 client 都能主动向对方发送或接收数据。同时，WebSocket 在建立连接时需要借助 HTTP 协议，连接建立好了之后 client 与 server 之间的双向通信就与 HTTP 无关了。

原生 WebSocket API 使用起来不太方便，使用 Socket.io，它很好地封装了 webSocket 接口，提供了更简单、灵活的接口，也对不支持 webSocket 的浏览器提供了向下兼容。

先来看个例子：本地文件 socket.html 向 localhost:3000 发生数据和接受数据

// socket.html
<script>
  let socket = new WebSocket('ws://localhost:3000');
  socket.onopen = function () {
    socket.send('爱');//向服务器发送数据
  }
  socket.onmessage = function (e) {
    console.log(e.data);//接收服务器返回的数据
  }
</script>

// server.js
let express = require('express');
let app = express();
let WebSocket = require('ws');//记得安装ws
let wss = new WebSocket.Server({port:3000});
wss.on('connection',function(ws) {
  ws.on('message', function (data) {
    console.log(data);
    ws.send('不爱')
  });
})

5. Node 中间件代理(两次跨域)

实现原理：同源策略是浏览器需要遵循的标准，而如果是服务器向服务器请求就无需遵循同源策略。
代理服务器，需要做以下几个步骤：
接受客户端请求。
将请求转发给服务器。
拿到服务器响应数据。
将响应转发给客户端。

看个例子：本地文件 index.html 文件，通过代理服务器 http://localhost:3000 向目标服务器 http://localhost:4000 请求数据。

// index.html(http://127.0.0.1:5500)
<script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.min.js"></script>
<script>
$.ajax({
    url: 'http://localhost:3000',
    type: 'post',
    data: { name: 'xiamen', password: '123456' },
    contentType: 'application/json;charset=utf-8',
    success: function(result) {
        console.log(result) // {"title":"fontend","password":"123456"}
    },
    error: function(msg) {
        console.log(msg)
    }
})
</script>


// server1.js 代理服务器(http://localhost:3000)
const http = require('http')
// 第一步：接受客户端请求
const server = http.createServer((request, response) => {
  // 代理服务器，直接和浏览器直接交互，需要设置CORS 的首部字段
  response.writeHead(200, {
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': '*',
    'Access-Control-Allow-Headers': 'Content-Type'
  })
  // 第二步：将请求转发给服务器
  const proxyRequest = http
    .request(
      {
        host: '127.0.0.1',
        port: 4000,
        url: '/',
        method: request.method,
        headers: request.headers
      },
      serverResponse => {
        // 第三步：收到服务器的响应
        let body = ''
        serverResponse.on('data', chunk => {
          body += chunk
        })
        serverResponse.on('end', () => {
          console.log('The data is ' + body)
          // 第四步：将响应结果转发给浏览器
          response.end(body)
        })
      }
    )
    .end()
})
server.listen(3000, () => {
  console.log('The proxyServer is running at http://localhost:3000')
})
// server2.js(http://localhost:4000)
const http = require('http')
const data = { title: 'fontend', password: '123456' }
const server = http.createServer((request, response) => {
  if (request.url === '/') {
    response.end(JSON.stringify(data))
  }
})
server.listen(4000, () => {
  console.log('The server is running at http://localhost:4000')
})

上述代码经过两次跨域，值得注意的是浏览器向代理服务器发送请求，也遵循同源策略，最后在 index.html 文件打印出{"title":"fontend","password":"123456"}

6. nginx 反向代理

实现原理类似于 Node 中间件代理，需要搭建一个中转 nginx 服务器，用于转发请求。

使用 nginx 反向代理实现跨域，是最简单的跨域方式。只需要修改 nginx 的配置即可解决跨域问题，支持所有浏览器，支持 session，不需要修改任何代码，并且不会影响服务器性能。

实现思路：通过 nginx 配置一个代理服务器（域名与 domain1 相同，端口不同）做跳板机，反向代理访问 domain2 接口，并且可以顺便修改 cookie 中 domain 信息，方便当前域 cookie 写入，实现跨域登录。

先下载 nginx，然后将 nginx 目录下的 nginx.conf 修改如下:

// proxy服务器
server {
    listen       80;
    server_name  www.domain1.com;
    location / {
        proxy_pass   http://www.domain2.com:8080;  #反向代理
        proxy_cookie_domain www.domain2.com www.domain1.com; #修改cookie里域名
        index  index.html index.htm;

        # 当用webpack-dev-server等中间件代理接口访问nignx时，此时无浏览器参与，故没有同源限制，下面的跨域配置可不启用
        add_header Access-Control-Allow-Origin http://www.domain1.com;  #当前端只跨域不带cookie时，可为*
        add_header Access-Control-Allow-Credentials true;
    }
}

最后通过命令行 nginx -s reload 启动 nginx

// index.html
let xhr = new XMLHttpRequest();
// 前端开关：浏览器是否读写cookie
xhr.withCredentials = true;
// 访问nginx中的代理服务器
xhr.open("get", "http://www.domain1.com:81/?user=admin", true);
xhr.send();
// server.js
let http = require("http");
let server = http.createServer();
let qs = require("querystring");
server.on("request", function (req, res) {
  let params = qs.parse(req.url.substring(2));
  // 向前台写cookie
  res.writeHead(200, {
    "Set-Cookie": "l=a123456;Path=/;Domain=www.domain2.com;HttpOnly", // HttpOnly:脚本无法读取
  });
  res.write(JSON.stringify(params));
  res.end();
});
server.listen("8080");
console.log("Server is running at port 8080...");

posted @ 2023-11-17 16:17 柯基与佩奇阅读(16) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 实现单点登录（SSO）

· 源码解析axios拦截器

· 9 种跨域方式实现原理

· 九种跨域方式实现原理

· 前端跨域问题

公告

昵称：柯基与佩奇
园龄： 6年
粉丝： 11
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

wp-leonard

跨域

跨域请求如何携带cookie

一. 搭建一个跨域请求的环境

1. 在前端请求的时候设置 request 对象的属性 withCredentials 为 true;

2. 在服务端设置 Access-Control-Allow-Origin

3. 在服务端设置 Access-Control-Allow-Credentials

三、总结

6种跨域方式实现原理

一、什么是跨域？

1. 什么是同源策略及其限制内容？

2. 常见跨域场景

二、跨域解决方案

1. jsonp

2. cors(跨源资源共享)

3. postMessage

4. websocket

5. Node 中间件代理(两次跨域)

6. nginx 反向代理

公告

搜索

常用链接

随笔分类

随笔档案

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论

wp-leonard

跨域

跨域请求如何携带cookie

一. 搭建一个跨域请求的环境

二、解决跨域携带 cookie 问题

1. 在前端请求的时候设置 request 对象的属性 withCredentials 为 true;

2. 在服务端设置 Access-Control-Allow-Origin

3. 在服务端设置 Access-Control-Allow-Credentials

三、总结

6种跨域方式实现原理

一、什么是跨域？

1. 什么是同源策略及其限制内容？

2. 常见跨域场景

二、跨域解决方案

1. jsonp

2. cors(跨源资源共享)

3. postMessage

4. websocket

5. Node 中间件代理(两次跨域)

6. nginx 反向代理

公告

搜索

常用链接

随笔分类

随笔档案

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论