前端常见的跨域解决方案

一、什么是跨域

跨域也称为非同源策略请求，就是去非同源地址获取数据的行为
只要页面，向非同源地址，发出了ajax / fetch请求，此时就出现了跨域问题。

专业的解释是，两个不同源的服务去访问对方的资源，就是所谓的跨域，而浏览器处于安全方面的考虑是不允许跨域请求的

二、什么是同源

同源是指协议、域名、端口都相同,其中有一个不同就是非同源

URL                                      说明                    是否允许通信
http://www.domain.com/a.js
http://www.domain.com/b.js         同一域名，不同文件或路径           允许
http://www.domain.com/lab/c.js

http://www.domain.com:8000/a.js
http://www.domain.com/b.js         同一域名，不同端口                不允许
 
http://www.domain.com/a.js
https://www.domain.com/b.js        同一域名，不同协议                不允许
 
http://www.domain.com/a.js
http://192.168.4.12/b.js           域名和域名对应相同ip              不允许
 
http://www.domain.com/a.js
http://x.domain.com/b.js           主域相同，子域不同                不允许
http://domain.com/c.js（一级域名）
 
http://www.domain1.com/a.js
http://www.domain2.com/b.js        不同域名                         不允许

跨域非服务端控制的，而是浏览器的安全策略，当发生跨域请求时候，请求是可以正常发送到对方服务器的，只是浏览器会根据 ”Access-Control-Allow-Origin" 来判断当前域名是否有访问权限，从而决定是否解析返回的数据信息。 其中简单的说就是浏览器不会解析跨域请求返回的数据。

非同源策略的限制

（1）无法读取非同源网页的 Cookie、LocalStorage 。 （解决cookie跨域时一定要是域名才行）
（2）无法接触非同源网页的 DOM。
（3）无法向非同源地址发送 AJAX 请求。（XMLHttpRequest 发送请求到服务端了，但是返回的时候，浏览器出于安全考虑，给拦截了）

三、跨域解决方案(后台使用node express框架)

1、 通过jsonp跨域
2、 跨域资源共享（CORS）
3、 document.domain + iframe跨域
4、 location.hash + iframe
5、 window.name + iframe跨域 (name值在不同的页面（甚至不同域名）加载后依旧存在)
6、 postMessage跨域
7、 nginx代理跨域
8、 node代理跨域（主要是通过http-proxy-middleware实现的跨域）
9、 WebSocket协议跨域

3.1 通过jsonp实现跨域（jsonp 只能发送 get 请求）

JSONP 实现跨域请求的原理简单的说，就是动态创建script标签，然后利用script的 src 不受同源策略约束来跨域获取数据。回调函数和参数在 src 中传递

封装的jsonp函数
function jsonp({ url, params, cb }) {
  let script = document.createElement("script")
  return new Promise((resolve, reject) => {
    window[cb] = function (data) {
      resolve(data);
      document.body.removeChild(script);//拿到数据之后删除这个标签
    }
    params = { ...params, cb };//cb对象简写{cb:cb}
    let arr = [];
    for (let key in params) {
      arr.push(`${key}=${params[key]}`);
    }
    script.src = `${url}?${arr.join("&")}`;
    document.body.appendChild(script);
  })
}
 //调取jsonp函数 会在body添加一个<script src="http://localhost:3000/jsonp/say?wd=你吃了吗&cb=show"></script>
jsonp({
  url: "http://localhost:3000/jsonp/say",
  params: { wd: "你吃了吗" },//参数
  cb: "show",//回调函数名
}).then(res => {
  console.log(res);
})

node接口

let express = require('express') 
let app = express()
app.use('/jsonp/say', function (req, res, next) {   
	let { wd, cb } = req.query   
	res.end(`${cb}('我吃过了')`) 
	//如果传递对象的话，
	// let obj = { name: '张三', age: 18, sex: '男' }
  	// res.end(`${cb}(${JSON.stringify(obj)})`)
}) 
app.listen(3000)

3.2 跨域资源共享（CORS）

CORS 是一个 W3C 标准，全称是“跨域资源共享”（Cross-origin resource sharing）。

1.普通跨域请求：只服务端设置Access-Control-Allow-Origin即可，前端无须设置
2.若要带cookie请求：前后端都需要设置。（而且一定要把接口写成域名形式的，不然cookie还是带不上的  测试的的时候我改了hosts文件）

如果想要携带cookie前后端交互的一些规则
1、同域名下发送ajax请求，请求中默认会携带cookie
2、ajax在发送跨域请求时，默认情况下是不会携带cookie的
3、ajax在发送跨域请求时如果想携带cookie，必须将请求对象的withcredentials属性设置为true。
4、此时服务端的响应头Access-Control-Allow-Origin不能为*（星号）了
5、除了对响应头Access-Control-Allow-Origin的设置，还必须设置另外一个响应头：Access-Control-Allow-Credentials:true。
6.访问前端界面url也一定要用域名访问才可以拿到（用a.didichuxing.com:5500 访问）

两种请求
一种是简单请求(get,post)
另一种是非简单请求(put,delete) （这个会请求两次）

非简单请求
会在正式通信之前，增加一次HTTP查询请求，称为"预检"请求。
"预检"请求用的请求方法是OPTIONS，表示这个请求是用来询问的
服务器收到"预检"请求以后，检查了Origin、Access-Control-Request-Method和Access-Control-Request-Headers字段以后，确认允许跨源请求，就可以做出回应

1.原生ajax

xhr.withCredentials = true;	

示例代码

let xhr = new XMLHttpRequest();
  xhr.withCredentials = true;
  // document.cookie = "name=zhangsan" //cookie 不允许跨域的
  xhr.open("put", "http://localhost:3000/cors", true);
  // xhr.setRequestHeader("name", "zhangsan")
  xhr.onreadystatechange = function () {
    if (xhr.readyState === 4) {
      if (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
        //console.log(xhr.response);
        //console.log(xhr.getResponseHeader("name"))
      }
    }
  }
  xhr.send();

jQuery ajax

$.ajax({
   xhrFields: {
       withCredentials: true    // 前端设置是否带cookie
   },
});

axios设置：

axios.defaults.withCredentials = true

服务端设置：(node + express)
//设置cors白名单

let express = require('express') 
let app = express()
let whiteList = ['http://127.0.0.1:5500', 'http://a.didichuxing.com:5500']
app.use(function (req, res, next) {
  console.log(req.headers)
  let origin = req.headers.origin
  if (whiteList.includes(origin)) {
    //设置哪个源可以访问我
    res.setHeader('Access-Control-Allow-Origin', origin) //如果把origin 变成* 是不能携带cookie
    //允许携带哪个头访问我
    res.setHeader('Access-Control-Allow-Headers', 'name,age') //如果是多个请求头 就name,age...
    //允许哪个方法访问我
    res.setHeader('Access-Control-Allow-Methods', 'PUT')
    //预检的存活时间
    // res.setHeader('Access-Control-Max-Age', 6000)
    //允许跨域携带cookie
    res.setHeader('Access-Control-Allow-Credentials', true)
    //允许前段获取哪个头
    res.setHeader('Access-Control-Expose-Headers', 'name')
    if (req.method === 'OPTIONS') { //预检
      res.end() //options请求不做任何处理
    }
  }
  next()
})

app.get('/cors', function (req, res, next) {
  res.setHeader('name', 'lisi')
  res.end('我吃过了')
})

app.listen(3000)

3.3 document.domain + iframe 跨域（访问的时候一定要用域名）

这种跨域的方式最主要的是要求主域名相同。什么是主域名相同呢？
www.didichuxing.com a.didichuxing.com b.didichuxing.com 这三个主域名都是didichuxing.com
而主域名不同的就不能用此方法。

假设目前a.didichuxing.com 和 b.didichuxing.com 分别对应指向不同ip的服务器

a.html

<body>
  hello a
  <iframe src="http://b.didichuxing.com:8000/b.html" frameborder="0" id="frame" onload="load()"></iframe>
</body>
<script>
  document.domain = "didichuxing.com";
  function load() {
    let frame = document.getElementById("frame");
    console.log(frame.contentWindow.bData); //会打印出”我吃过了“
  }
</script>

b.html

<body>
  hello b
</body>
<script>
  document.domain = "didichuxing.com";
  var bData = "我吃过了"
</script>

3.4 location.hash + iframe 跨域

有三个页面：（a,b同域，c不同域）
a.didichuxing.com:5050/a.html：应用页面。
b.didichuxing.com:5050/b.html：代理文件，一般是一个没有任何内容的html文件，需要和应用页面在同一域下。
c.didichuxing.com:8080/c.html：应用页面需要获取数据的页面，可称为数据页面。
实现原理： a与c 跨域相互通信，通过代理文件 b 来实现。 三个页面，不同域之间利用iframe的location.hash传值，相同域之间直接js访问来通信。
具体实现：a和c不同域只能通过hash值单向通信，c与b也不同域也只能单向通信，但b与a同域，所以b可通过parent.parent访问a页面所有对象
a.html

<body>
  <iframe src="http://localhost:8080/c.html#name=zhangsan&age=18" id="frame" frameborder="0"></iframe>
</body>
<script>
  window.onhashchange = function () {
    console.log(location.hash)
  }
</script>

c.html

<body>

</body>
<script>
  let hash = location.hash;
  let result = "no"
  if (hash === "#name=zhangsan&age=18") {
    result = "yes";
  }
  let frame = document.createElement("iframe");
  frame.src = "http://localhost:5050/b.html#" + result
  document.body.appendChild(frame);
</script>

b.html

<body>

</body>
<script>
  window.parent.parent.location.hash = location.hash;
</script>

3.5、 window.name + iframe跨域

window.name属性的独特之处：name值在不同的页面（甚至不同域名）加载后依旧存在
a,b页面是同源 http://localhost:5050
c页面是独立的http://localhost:8080
a页面获取c页面的数据
a页面先引入c页面,c页面把值放在window.name 把a页面引入的地址变成b页面 利用name值依旧存在的特性就能拿到值了

a.html

<body>
  <iframe src="http://localhost:8080/c.html" id="frame" frameborder="0" onload="load()"></iframe>
</body>
<script>

 //iframe在现实中的表现是一直不停地刷新， 也很好理解，每次触发onload时间后，重置src，相当于重新载入页面，又触发onload事件，于是           就不停地刷新了
  let first = true; //解决一直不停地刷新
  function load() {
    let frame = document.getElementById("frame");
    if (first) {
      frame.src = "http://localhost:5050/b.html";
      first = false;
    } else {
      console.log(frame.contentWindow.name);//这个name不会消失
    }
  }
</script>

c.html

<body>

</body>
<script>
  // let obj = { name: "zhangsan", age: 18 }
  // window.name = JSON.stringify(obj);
  window.name = "晚上吃啥饭"
</script>

b页面（空页面）

<body>

</body>

3.6、 postMessage跨域

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

用法：postMessage(data,origin)方法接受两个参数
data： html5规范支持任意基本类型或可复制的对象，但部分浏览器只支持字符串，所以传参时最好用JSON.stringify()序列化。
origin： 协议+主机+端口号，也可以设置为"*"，表示可以传递给任意窗口，如果要指定和当前窗口同源的话设置为"/"。

a.html

<body>
  <iframe src="http://localhost:5000/b.html" id="frame" frameborder="0" onload="load()"></iframe>
  <script>
    function load() {
      let frame = document.getElementById("frame");
      frame.contentWindow.postMessage("中午吃啥", "http://localhost:5000")
    }
    window.onmessage = function (e) {
      console.log(e.data)
    }
  </script>
</body>

b.html

<body>
  <script>
    window.onmessage = function (e) {
      console.log(e.data);
      e.source.postMessage("吃鸡蛋面吧", e.origin);
    }
  </script>
</body>

3.7、nginx代理跨域

跨域问题：同源策略仅是针对浏览器的安全策略。
服务器端调用HTTP接口只是使用HTTP协议（服务端通信不存在跨域），不需要同源策略，也就不存在跨域问题。

nginx 主要是通过 proxy_pass 进行反向代理的
那我先稍微讲一下这个参数

在nginx中配置proxy_pass代理转发时，
如果在proxy_pass后面的url加/，表示绝对根路径；
如果没有/，表示相对路径，把匹配的路径部分也给代理走。

假设用 http://127.0.0.1/proxy/test.html 进行访问
第一种：
location /proxy/ {
proxy_pass http://127.0.0.1/;
}
代理到URL：http://127.0.0.1/test.html

第二种（相对于第一种，最后少一个 / ）
location /proxy/ {
proxy_pass http://127.0.0.1;
}
代理到URL：http://127.0.0.1/proxy/test.html

server {
   listen       8000 ;//端口号
   server_name  127.0.0.1;#域名可以有多个，用空格隔开
   # Load configuration files for the default server block.
   include /etc/nginx/default.d/*.conf;
   location / {
	  root   /usr/share/nginx/html/test;
	  index  index.html index.htm;
	  try_files $uri $uri/ /index.html;
	}
	location /nginx {
      proxy_pass http://172.22.108.66:3000;#这个ip是我后台接口的ip地址
      proxy_set_header X-Real-IP $remote_addr;    # 获取客户端真实IP
      proxy_set_header REMOTE-HOST $remote_addr;  # 获取客户端浏览器的主机名
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; # 获取代理者的真实ip
      proxy_set_header Host $host:$server_port;    
   }
}

前端代码

<body>
  <div id="main"></div>
</body>
<script>
  axios({
    url: "/api/nginx/say",
    method: "get",
    //withCredentials: true,//表示跨域请求时是否需要使用凭证
    headers: { "name": "zhangsan", age: 18 }
  }).then(res => {
    console.log(res);
    if (typeof (res.data) === "string") {
      document.getElementById("main").innerHTML = res.data
    }
  })
</script>

服务端代码

app.use('/nginx/say', function (req, res, next) {
  let { wd, cb } = req.query
  res.send("我吃过了")
})

nginx之Location语法规则

3.8 nodejs中间件代理跨域

node中间件实现跨域代理，原理大致与nginx相同，都是通过启一个代理服务器，实现数据的转发。

1）非vue框架的跨域
  使用node + express + http-proxy-middleware搭建一个proxy服务器。
（http://a.didichuxing.com 实际我是在hosts文件添加了 127.0.0.1 a.didichuxing.com）
前端代码：

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<body></body>
<script>
  axios({
    url: "http://a.didichuxing.com:3001/httpProxy",
    methods: "get",
    withCredentials: true,//表示跨域请求时是否需要使用凭证 携带cookie
  }).then(res => {
    console.log(res);
  })
</script>

中间件服务器代码：

var express = require('express')
const { createProxyMiddleware } = require('http-proxy-middleware')
var app = express()

app.use(
  '/httpProxy',
  createProxyMiddleware({
    // 代理跨域目标接口
    target: 'http://192.168.199.101:3000',
    changeOrigin: true,
    ws: false, // proxy websockets
    // pathRewrite: {
    //   '^/httpProxy': '/httpProxy', // rewrite path
    // },
    // 修改响应头信息，实现跨域并允许带cookie
    onProxyRes: function (onProxyRes, req, res) {
      res.header('Access-Control-Allow-Origin', 'http://a.didichuxing.com:3001')
      res.header('Access-Control-Allow-Credentials', 'true')
    },
  })
)

app.listen(3001)

调取接口的真正服务

let express = require('express')
let app = express()
app.use('/httpProxy', function (req, res, next) {
  res.send({ name: 'xiaoming', like: '喜欢吃鸡蛋面' })
})
app.listen(3000)

2）vue框架的跨域

node + vue + webpack + webpack-dev-server搭建的项目，跨域请求接口，直接修改proxyTable配置。开发环境下，vue渲染服务和接口代理服务都是webpack-dev-server同一个，所以页面与代理接口之间不再跨域。

proxyTable: {
  "/risk": {
    target: "http://ip:端口", //代理的后台接口地址
    changeOrigin: true,         
    ws: false, 
    secure: false, // 如果是https接口，需要配置这个参数
    pathRewrite: {
      "^/risk": "/risk"
    }
  },
}

3.9、WebSocket协议跨域

WebSocket protocol是HTML5一种新的协议。它实现了浏览器与服务器全双工通信，同时允许跨域通讯

前端代码

<body>

</body>
<script>
  let socket = new WebSocket("ws://localhost:8050");
  //连接建立时触发
  socket.onopen = function () {
    socket.send("中午吃啥");//使用连接发送数据
  }
  //客户端接收服务端数据时触发
  socket.onmessage = function (data) {
    console.log(data)
  }
</script>

服务端代码

let express = require('express')
let app = express()
//需要先安装ws
let websocket = require('ws')
let wss = new websocket.Server({ port: 8050 })
wss.on('connection', function (ws) {
  ws.on('message', function (data) {
    console.log(data)
    ws.send('咱们去吃鸡蛋面吧');
  })
})
app.listen()

总结

以上就是9种常见的跨域解决方案，jsonp（只支持get请求，支持老的IE浏览器）适合加载不同域名的js、css，img等静态资源；CORS（支持所有类型的HTTP请求，但浏览器IE10以下不支持）适合做ajax各种跨域请求；Nginx代理跨域和nodejs中间件跨域原理都相似，都是搭建一个服务器，直接在服务器端请求HTTP接口，这适合前后端分离的前端项目调后端接口。document.domain+iframe适合主域名相同，子域名不同的跨域请求。postMessage、websocket都是HTML5新特性，兼容性不是很好，只适用于主流浏览器和IE10+。