看完这篇,我再也不问跨域的问题了

跨域这两个字就像一块狗皮膏药一样黏在每一个前端开发者身上，无论你在工作上或者面试中无可避免会遇到这个问题。为了应付面试，我每次都随便背几个方案，也不知道为什么要这样干，反正面完就可以扔了，我想工作上也不会用到那么多乱七八糟的方案。到了真正工作，开发环境有webpack-dev-server搞定，上线了服务端的大佬们也会配好，配了什么我不管，反正不会跨域就是了。日子也就这么混过去了，终于有一天，我觉得不能再继续这样混下去了，我一定要彻底搞懂这个东西！于是就有了这篇文章。

要掌握跨域，首先要知道为什么会有跨域这个问题出现

确实，我们这种搬砖工人就是为了混口饭吃嘛，好好的调个接口告诉我跨域了，这种阻碍我们轻松搬砖的事情真恶心！为什么会跨域？是谁在搞事情？为了找到这个问题的始作俑者，请点击：浏览器的同源策略。

这么官方的东西真难懂，没关系，至少你知道了，因为浏览器的同源策略导致了跨域，就是浏览器在搞事情。

所以，浏览器为什么要搞事情？就是不想给好日子我们过？对于这样的质问，浏览器甩锅道：“同源策略限制了从同一个源加载的文档或脚本如何与来自另一个源的资源进行交互。这是一个用于隔离潜在恶意文件的重要安全机制。”

这么官方的话术真难懂，没关系，至少你知道了，似乎这是个安全机制。

所以，究竟为什么需要这样的安全机制？这样的安全机制解决了什么问题？别急，让我们继续研究下去。

没有同源策略限制的两大危险场景

据我了解，浏览器是从两个方面去做这个同源策略的，一是针对接口的请求，二是针对Dom的查询。试想一下没有这样的限制上述两种动作有什么危险。

没有同源策略限制的接口请求

有一个小小的东西叫cookie大家应该知道，一般用来处理登录等场景，目的是让服务端知道谁发出的这次请求。如果你请求了接口进行登录，服务端验证通过后会在响应头加入Set-Cookie字段，然后下次再发请求的时候，浏览器会自动将cookie附加在HTTP请求的头字段Cookie中，服务端就能知道这个用户已经登录过了。知道这个之后，我们来看场景：

1. 你准备去清空你的购物车，于是打开了买买买网站www.maimaimai.com，然后登录成功，一看，购物车东西这么少，不行，还得买多点。

2. 你在看有什么东西买的过程中，你的好基友发给你一个链接www.nidongde.com，一脸yin笑地跟你说：“你懂的”，你毫不犹豫打开了。

3. 你饶有兴致地浏览着www.nidongde.com，谁知这个网站暗地里做了些不可描述的事情！由于没有同源策略的限制，它向www.maimaimai.com发起了请求！聪明的你一定想到上面的话“服务端验证通过后会在响应头加入Set-Cookie字段，然后下次再发请求的时候，浏览器会自动将cookie附加在HTTP请求的头字段Cookie中”，这样一来，这个不法网站就相当于登录了你的账号，可以为所欲为了！如果这不是一个买买买账号，而是你的银行账号，那……

这就是传说中的CSRF攻击（浅谈CSRF攻击方式）。

看了这波CSRF攻击我在想，即使有了同源策略限制，但cookie是明文的，还不是一样能拿下来。于是我看了一些cookie相关的文章：聊一聊 cookie、Cookie/Session的机制与安全，知道了服务端可以设置httpOnly，使得前端无法操作cookie，如果没有这样的设置，像XSS攻击就可以去获取到cookie（Web安全测试之XSS）；设置secure，则保证在https的加密通信中传输以防截获。

没有同源策略限制的Dom查询

1. 有一天你刚睡醒，收到一封邮件，说是你的银行账号有风险，赶紧点进www.yinghang.com改密码。你吓尿了，赶紧点进去，还是熟悉的银行登录界面，你果断输入你的账号密码，登录进去看看钱有没有少了。

2. 睡眼朦胧的你没看清楚，平时访问的银行网站是www.yinhang.com，而现在访问的是www.yinghang.com，这个钓鱼网站做了什么呢？

1. // HTML

2. <iframe name="yinhang" src="www.yinhang.com">iframe>

3. // JS

4. // 由于没有同源策略的限制，钓鱼网站可以直接拿到别的网站的Dom

5. const iframe = window.frames['yinhang']

6. const node = iframe.document.getElementById('你输入账号密码的Input')

7. console.log(`拿到了这个${node}，我还拿不到你刚刚输入的账号密码吗`)

1.    

由此我们知道，同源策略确实能规避一些危险，不是说有了同源策略就安全，只是说同源策略是一种浏览器最基本的安全机制，毕竟能提高一点攻击的成本。其实没有刺不穿的盾，只是攻击的成本和攻击成功后获得的利益成不成正比。

跨域正确的打开方式

经过对同源策略的了解，我们应该要消除对浏览器的误解，同源策略是浏览器做的一件好事，是用来防御来自邪门歪道的攻击，但总不能为了不让坏人进门而把全部人都拒之门外吧。没错，我们这种正人君子只要打开方式正确，就应该可以跨域。

下面将一个个演示正确打开方式，但在此之前，有些准备工作要做。为了本地演示跨域，我们需要：

1. 随便跑起一份前端代码（以下前端是随便跑起来的vue），地址是http://localhost:9099。

2. 随便跑起一份后端代码（以下后端是随便跑起来的node koa2），地址是http://localhost:9971。

同源策略限制下接口请求的正确打开方式

1.JSONP

在HTML标签里，一些标签比如script、img这样的获取资源的标签是没有跨域限制的，利用这一点，我们可以这样干。

后端写个小接口：

1. // 处理成功失败返回格式的工具

2. const{successBody}=require('../utli')

3. classCrossDomain{

4.  staticasync jsonp (ctx){

5.    // 前端传过来的参数

6.    const query = ctx.request.query

7.    // 设置一个cookies

8.    ctx.cookies.set('tokenId','1')

9.    // query.cb是前后端约定的方法名字，其实就是后端返回一个直接执行的方法给前端，由于前端是用script标签发起的请求，所以返回了这个方法后相当于立马执行，并且把要返回的数据放在方法的参数里。

10.    ctx.body =`${query.cb}(${JSON.stringify(successBody({msg: query.msg}, 'success'))})`

11.  }

12. }

13. module.exports =CrossDomain

简单版前端：

3.  

4.    charset="utf-8">

5.  

6.  

7.    

8.    

9.  

简单封装一下前端这个套路：

1. /**

2. * JSONP请求工具

3. * @param url 请求的地址

4. * @param data 请求的参数

5. * @returns {Promise}

6. */

7. const request =({url, data})=>{

8.  returnnewPromise((resolve, reject)=>{

9.    // 处理传参成xx=yy&aa=bb的形式

10.    const handleData =(data)=>{

11.      const keys =Object.keys(data)

12.      const keysLen = keys.length

13.      return keys.reduce((pre, cur, index)=>{

14.        const value = data[cur]

15.        const flag = index !== keysLen -1?'&':''

16.        return`${pre}${cur}=${value}${flag}`

17.      },'')

18.    }

19.    // 动态创建script标签

20.    const script = document.createElement('script')

21.    // 接口返回的数据获取

22.    window.jsonpCb =(res)=>{

23.      document.body.removeChild(script)

24.      delete window.jsonpCb

25.      resolve(res)

26.    }

27.    script.src =`${url}?${handleData(data)}&cb=jsonpCb`

28.    document.body.appendChild(script)

29.  })

30. }

31. // 使用方式

32. request({

33.  url:'http://localhost:9871/api/jsonp',

34.  data:{

35.    // 传参

36.    msg:'helloJsonp'

37.  }

38. }).then(res =>{

39.  console.log(res)

40. })

2.空iframe加form

细心的朋友可能发现，JSONP只能发GET请求，因为本质上script加载资源就是GET，那么如果要发POST请求怎么办呢？

后端写个小接口：

1. // 处理成功失败返回格式的工具

2. const{successBody}=require('../utli')

3. classCrossDomain{

4.  staticasync iframePost (ctx){

5.    let postData = ctx.request.body

6.    console.log(postData)

7.    ctx.body = successBody({postData: postData},'success')

8.  }

9. }

10. module.exports =CrossDomain

前端：

1. const requestPost =({url, data})=>{

2.  // 首先创建一个用来发送数据的iframe.

3.  const iframe = document.createElement('iframe')

4.  iframe.name ='iframePost'

5.  iframe.style.display ='none'

6.  document.body.appendChild(iframe)

7.  const form = document.createElement('form')

8.  const node = document.createElement('input')

9.  // 注册iframe的load事件处理程序,如果你需要在响应返回时执行一些操作的话.

10.  iframe.addEventListener('load',function(){

11.    console.log('post success')

12.  })

13. 
    

14.  form.action = url

15.  // 在指定的iframe中执行form

16.  form.target = iframe.name

17.  form.method ='post'

18.  for(let name in data){

19.    node.name = name

20.    node.value = data[name].toString()

21.    form.appendChild(node.cloneNode())

22.  }

23.  // 表单元素需要添加到主文档中.

24.  form.style.display ='none'

25.  document.body.appendChild(form)

26.  form.submit()

27. 
    

28.  // 表单提交后,就可以删除这个表单,不影响下次的数据发送.

29.  document.body.removeChild(form)

30. }

31. // 使用方式

32. requestPost({

33.  url:'http://localhost:9871/api/iframePost',

34.  data:{

35.    msg:'helloIframePost'

36.  }

37. })

3.CORS

CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）跨域资源共享 CORS 详解。看名字就知道这是处理跨域问题的标准做法。CORS有两种请求，简单请求和非简单请求。

这里引用上面链接阮一峰老师的文章说明一下简单请求和非简单请求。

浏览器将CORS请求分成两类：简单请求（simple request）和非简单请求（not-so-simple request）。

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

（1）请求方法是以下三种方法之一：

• HEAD

• GET

• POST

（2）HTTP的头信息不超出以下几种字段：

• Accept

• Accept-Language

• Content-Language

• Last-Event-ID

• Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain

1、简单请求

后端：

1. // 处理成功失败返回格式的工具

2. const{successBody}=require('../utli')

3. classCrossDomain{

4.  staticasync cors (ctx){

5.    const query = ctx.request.query

6.    // *时cookie不会在http请求中带上

7.    ctx.set('Access-Control-Allow-Origin','*')

8.    ctx.cookies.set('tokenId','2')

9.    ctx.body = successBody({msg: query.msg},'success')

10.  }

11. }

12. module.exports =CrossDomain

前端什么也不用干，就是正常发请求就可以，如果需要带cookie的话，前后端都要设置一下，下面那个非简单请求例子会看到。

1. fetch(`http://localhost:9871/api/cors?msg=helloCors`).then(res =>{

2.  console.log(res)

3. })

2、非简单请求 非简单请求会发出一次预检测请求，返回码是204，预检测通过才会真正发出请求，这才返回200。这里通过前端发请求的时候增加一个额外的headers来触发非简单请求。

后端：

1. // 处理成功失败返回格式的工具

2. const{successBody}=require('../utli')

3. classCrossDomain{

4.  staticasync cors (ctx){

5.    const query = ctx.request.query

6.    // 如果需要http请求中带上cookie，需要前后端都设置credentials，且后端设置指定的origin

7.    ctx.set('Access-Control-Allow-Origin','http://localhost:9099')

8.    ctx.set('Access-Control-Allow-Credentials',true)

9.    // 非简单请求的CORS请求，会在正式通信之前，增加一次HTTP查询请求，称为"预检"请求（preflight）

10.    // 这种情况下除了设置origin，还需要设置Access-Control-Request-Method以及Access-Control-Request-Headers

11.    ctx.set('Access-Control-Request-Method','PUT,POST,GET,DELETE,OPTIONS')

12.    ctx.set('Access-Control-Allow-Headers','Origin, X-Requested-With, Content-Type, Accept, t')

13.    ctx.cookies.set('tokenId','2')

14. 
    

15.    ctx.body = successBody({msg: query.msg},'success')

16.  }

17. }

18. module.exports =CrossDomain

一个接口就要写这么多代码，如果想所有接口都统一处理，有什么更优雅的方式呢？见下面的koa2-cors。

1. const path =require('path')

2. constKoa=require('koa')

3. const koaStatic =require('koa-static')

4. const bodyParser =require('koa-bodyparser')

5. const router =require('./router')

6. const cors =require('koa2-cors')

7. const app =newKoa()

8. const port =9871

9. app.use(bodyParser())

10. // 处理静态资源 这里是前端build好之后的目录

11. app.use(koaStatic(

12.  path.resolve(__dirname,'../dist')

13. ))

14. // 处理cors

15. app.use(cors({

16.  origin:function(ctx){

17.    return'http://localhost:9099'

18.  },

19.  credentials:true,

20.  allowMethods:['GET','POST','DELETE'],

21.  allowHeaders:['t','Content-Type']

22. }))

23. // 路由

24. app.use(router.routes()).use(router.allowedMethods())

25. // 监听端口

26. app.listen(9871)

27. console.log(`[demo] start-quick is starting at port ${port}`)

前端：

1. fetch(`http://localhost:9871/api/cors?msg=helloCors`,{

2.  // 需要带上cookie

3.  credentials:'include',

4.  // 这里添加额外的headers来触发非简单请求

5.  headers:{

6.    't':'extra headers'

7.  }

8. }).then(res =>{

9.  console.log(res)

10. })

4.代理

想一下，如果我们请求的时候还是用前端的域名，然后有个东西帮我们把这个请求转发到真正的后端域名上，不就避免跨域了吗？这时候，Nginx出场了。

Nginx配置：

1. server{

2.    # 监听9099端口

3.    listen 9099;

4.    # 域名是localhost

5.    server_name localhost;

6.    #凡是localhost:9099/api这个样子的，都转发到真正的服务端地址http://localhost:9871

7.    location ^~/api {

8.        proxy_pass http://localhost:9871;

9.    }  

10. }

前端就不用干什么事情了，除了写接口，也没后端什么事情了。

1. // 请求的时候直接用回前端这边的域名http://localhost:9099，这就不会跨域，然后Nginx监听到凡是localhost:9099/api这个样子的，都转发到真正的服务端地址http://localhost:9871

2. fetch('http://localhost:9099/api/iframePost',{

3.  method:'POST',

4.  headers:{

5.    'Accept':'application/json',

6.    'Content-Type':'application/json'

7.  },

8.  body: JSON.stringify({

9.    msg:'helloIframePost'

10.  })

11. })

Nginx转发的方式似乎很方便！但这种使用也是看场景的，如果后端接口是一个公共的API，比如一些公共服务获取天气什么的，前端调用的时候总不能让运维去配置一下Nginx，如果兼容性没问题（IE 10或者以上），CROS才是更通用的做法吧。

同源策略限制下Dom查询的正确打开方式

1.postMessage

window.postMessage() 是HTML5的一个接口，专注实现不同窗口不同页面的跨域通讯。

为了演示方便，我们将hosts改一下：127.0.0.1 crossDomain.com，现在访问域名crossDomain.com就等于访问127.0.0.1。

这里是http://localhost:9099/#/crossDomain，发消息方：

2. 
   

这里是http://crossdomain.com:9099，接收消息方：

2. 
   

结果可以看到：

2.document.domain

这种方式只适合主域名相同，但子域名不同的iframe跨域。

比如主域名是http://crossdomain.com:9099，子域名是http://child.crossdomain.com:9099，这种情况下给两个页面指定一下document.domain即document.domain = crossdomain.com就可以访问各自的window对象了。

3.canvas操作图片的跨域问题

这个应该是一个比较冷门的跨域问题，张大神已经写过了我就不再班门弄斧了：解决canvas图片getImageData,toDataURL跨域问题

最后

希望看完这篇文章之后，再有人问跨域的问题，你可以嘴角微微上扬，冷笑一声，“不要再问我跨域的问题了”，扬长而去。

源自：https://segmentfault.com/a/1190000015597029

声明：文章著作权归作者所有，如有侵权，请联系小编删除。