JSONP_跨域

2017-12-27 本文已影响52人熊蛋子17

1. 什么是同源策略

浏览器限制不同源的两个网站间脚本和文本的相互访问，只允许访问同源下的内容。所谓同源，就是指两个页面具有相同的协议，主机（也常说域名），端口，三个要素缺一不可。同源政策的目的，是为了保证用户信息的安全，防止恶意的网站窃取数据。

2. 什么是跨域？跨域有几种实现形式

关于跨域
说白点就是post、get的url不是你当前的网站，域名不同。例如在aaa.com/a.html里面，表单的提交action是bbb.com/b.html。
不仅如此www.aaa.com和aaa.com之间也属于跨域，因为www.aaa.com是二级域名，aaa.com是根域名。
JavaScript出于安全方面的考虑，是不允许跨域调用其他页面的对象的
[图片上传失败...(image-b1caef-1514307447090)]
[图片上传失败...(image-50a6ca-1514307447091)]
关于跨域的原因
跨域这东西其实很常见，例如我们可以把网站的一些脚本、图片或其他资源放到另外一个站点。例如我们可以使用Google提供的jQuery，加载时间少了，而且减少了服务器的流量，如下

<script type="text/java script"src="https://aja x.googleapis.com/aj ax/libs/jquery/1.4.2/jquery.min.js"></script>

有时候不仅仅是一些脚本、图片这样的资源，我们也会希望从另外的站点调用一些数据（有时候是不得不这样），例如我希望获取一些blog的RSS来生成一些内容，再或者说我在“人人开放平台”上开发一个应用，需要调用人人的数据。
然而，很不幸的是，直接用XMLHttpRequest来Get或者Post是不行的。

跨域的实现方式
1. 在服务器端进行通信，因为服务器端不受跨域的限制。跨域的安全限制是对浏览器端来说的。
2. 用 script 标签来解决，因为它的 src 属性是可以跨域的。
eg. 往常用 script 引入外部的 js
eg. 也可以用 js 动态创建 script 标签，并将其 append 到 body 里，就可以用这个 js 了。
1. jsonp：它其实是一个非官方的协议，有特定的通信逻辑，但平时原生用的不多，因为 jQuery 本身就支持了 jsonp。
2. $.ajax()，$.getJSON()：jQuery 提供的现成函数来实现跨域。这两种方式（其实就是一种调用方式，需要传特定的参数）的原理是将 json 数据填充进回调函数，即创建一个回调函数，在远程服务器上调用这个函数并将 json 数据形式作为参数，完成回调。
3. iFrame 实现跨域
4. HTML5 的 postMessage 和 onmessage

其实 jsonp 里面也是创建了 script 标签，然后通过 js 回调的形式实现了跨域访问。而 jQuery 对 jsonp 也仅仅是支持，其核心也是 jsonp。所以，归根结底，这三种方式都是常见又经常被忽略的 script 标签。

3. JSONP 的原理是什么

jsonp是一种跨域通信的手段，它的原理其实很简单：
首先是利用script标签的src属性来实现跨域。
通过将前端方法作为参数传递到服务器端，然后由服务器端注入参数之后再返回，实现服务器端向客户端通信。
由于使用script标签的src属性，因此只支持get方法

4. CORS是什么

CORS 全称是跨域资源共享（Cross-Origin Resource Sharing），是一种 ajax 跨域请求资源的方式，支持现代浏览器，IE支持10以上。实现方式很简单，当你使用 XMLHttpRequest 发送请求时，浏览器发现该请求不符合同源策略，会给该请求加一个请求头：Origin，后台进行一系列处理，如果确定接受请求则在返回结果中加入一个响应头：Access-Control-Allow-Origin; 浏览器判断该相应头中是否包含 Origin 的值，如果有则浏览器会处理响应，我们就可以拿到响应数据，如果不包含浏览器直接驳回，这时我们无法拿到响应数据。所以 CORS 的表象是让你觉得它与同源的 ajax 请求没啥区别，代码完全一样。
整个CORS通信过程，都是浏览器自动完成，不需要用户参与。对于开发者来说，CORS通信与同源的AJAX通信没有差别，代码完全一样。浏览器一旦发现AJAX请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。
实现CORS通信的关键是服务器。只要服务器实现了CORS接口，就可以跨源通信。
浏览器将CORS请求分为两类：简单请求和非简单请求

5. 演示三种以上跨域的解决方式

1.JSONP实现跨域

Web 页面上调用 js 文件不受浏览器同源策略的影响，所以通过 Script 便签可以进行跨域的请求：

首先前端先设置好回调函数，并将其作为 url 的参数。
服务端接收到请求后，通过该参数获得回调函数名，并将数据放在参数中将其返回
收到结果后因为是 script 标签，所以浏览器会当做是脚本进行运行，从而达到跨域获取数据的目的。
实例演示:
后端逻辑:文件名server.js

//后端逻辑
var url = require('url')
var http = require('http')
http.createServer(function (req, res) {
    var data = {
        name: "haha"
    };
    var callback = url.parse(req.url,true).query.callback;
    //url.parse(req.url,true).query即{callback:jsonpCallback} ----------------获取函数名callback
    res.writeHead(200)
    res.end(`${callback}(${JSON.stringify(data)})`)

}).listen(3000, '127.0.0.1')
//服务端接收到请求后获取到回调函数名callback,
将数据放在参数中将其返回,即返回callback({"name" : "haha"}) 函数调用
console.log('监听127.0.0.1:3000端口') 
 //注意这里文字一定要引号包裹不然会报错
//注意终端提示：SyntaxError: Invalid or unexpected token 无效或意外的标记，
出现这种情况一般是中文的标点符号或者漏写了符号导致的

前端页面:文件名index.html

<!--前端页面-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JSONP实现跨域</title>
</head>
<body>
    <script>
       function jsonpCallback(data) {
           console.log(JSON.stringfy(data))
       }   
    //定义回调函数jsonpCallback,收到服务端返回结果
   callback({"name" : "haha"}),callback=jsonpCallback
    </script>
    <script src="http://127.0.0.1:3000?callback=jsonpCallback"></script>  
   //web页面上调用js文件不收同源策略影响

</body>
</html>

验证过程:

终端在后端文件server.js目录下，node server.js启动服务,监听端口3000
我们通过端口号的不同来模拟跨域的场景，通过127.0.0.1:8080端口来访问页面.
这里我们打开另一个终端,在页面同目录下输入http-server启动端口

这样就可以通过端口 8080 访问 index.html 刚才那个页面了，相当于是开启两个监听不同端口的 http 服务器，通过页面中的请求来模拟跨域的场景。打开浏览器，访问 http://127.0.0.1:8080就可以看到从http://127.0.0.1:3000获取到的数据了。

至此，通过 JSONP 跨域获取数据已经成功了，但是通过这种事方式也存在着一定的优缺点：

优点：
1.它不像XMLHttpRequest 对象实现 Ajax 请求那样受到同源策略的限制
2.兼容性很好，在古老的浏览器也能很好的运行
3.不需要 XMLHttpRequest 或 ActiveX 的支持；并且在请求完毕后可以通过调用 callback 的方式回传结果。

缺点：
1.它支持 GET 请求而不支持 POST 等其它类型的 HTTP 请求。
2.它只支持跨域 HTTP 请求这种情况，不能解决不同域的两个页面或 iframe 之间进行数据通信的问题
3.容易遭受XSS攻击，因为我们拿到的是对方接口的数据作为js执行，如果得到的是一个很危险js，获取了用户信息和cookies，这时执行了js就会出现安全问题。

2. CORS实现跨域

CORS 是一个 W3C 标准，全称是"跨域资源共享"（Cross-origin resource sharing）它允许浏览器向跨源服务器，发出 XMLHttpRequest 请求，从而克服了 ajax 只能同源使用的限制。

CORS 需要浏览器和服务器同时支持才可以生效，对于开发者来说，CORS 通信与同源的 ajax 通信没有差别，代码完全一样。浏览器一旦发现 ajax 请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。参考阮一峰

因此，实现 CORS 通信的关键是服务器。只要服务器实现了 CORS 接口，就可以跨源通信。

<!--前端页面-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <script>
        var xhr = new XMLHttpRequest()
        xhr.open('GET', 'http://127.0.0.1:3000', true)
        xhr.send()
        xhr.onload = function () {
            console.log(xhr.responseText)
        }
    </script>
</body>
</html>

这似乎跟一次正常的异步 ajax 请求没有什么区别，关键是在服务端收到请求后的处理：

var http = require('http')
http.createServer(function(req,res){
    res.writeHead(200,{
        'Acess-Control-Allow-Origin':'http://127.0.0.1:8080'
    })
    res.end('这是你要的数据: haha')
}).listen(3000,'127.0.0.1')
console.log('监听127.0.0.1:3000端口')

关键是在于设置相应头中的 Access-Control-Allow-Origin，该值要与请求头中 Origin 一致才能生效，否则将跨域失败。
开启两个http服务器

打开浏览器访问localhost:8080,

成功的关键在于 Access-Control-Allow-Origin是否包含请求页面的域名，如果不包含的话，浏览器认为是跨域请求,会拦截返回的信息.
另外如果服务器设置:

res.writeHead(200,{
        'Acess-Control-Allow-Origin': *   //开放接口,任何人都能跨域调用该接口内的数据
    })

CORS 的优缺点：

优点：

使用简单方便，更为安全
支持 POST 请求方式
精确控制资源访问权限
客户端无需增加额外代码

缺点：
1. CORS仅兼容 IE 10 以上

3.Server Proxy服务器代理

需要跨域的请求操作时发送请求给后端，让后端帮你代为请求，然后将获取的结果发送给你。

假设你的页面需要获取 CNode：Node.js专业中文社区论坛上一些数据，如通过 https://cnodejs.org/api/v1/topics，因为不同域，所以你可以请求后端让其代为转发请求。

var url = require('url');
var http = require('http');
var https = require('https');

var server = http.createServer((req, res) => {   // =>前面是参数,后面是函数体
    var path = url.parse(req.url).path.slice(1);
    if(path === 'topics'){
        https.get('https://cnodejs.org/api/v1/topics',(resp) => {
            var data = "";
            resp.on('data',chunk => {
                data += chunk;
            })
            resp.on('end', () => {
                res.writeHead(200, {
                    'Content-Type': 'application/json; charset=utf-8'
                });
                res.end(data);
            })
        })
    }
}).listen(3000,'127.0.0.1');
console.log('启动服务，监听 127.0.0.1:3000');

开启服务器:

打开浏览器访问http://localhost:3000/topics就可以看到:

获取到数据,跨域成功

总结

四种iframe跨域

1.postMessage实现跨域

postMessage 是 HTML5 新增加的一项功能，跨文档消息传输(Cross Document Messaging)，目前：Chrome 2.0+、Internet Explorer 8.0+, Firefox 3.0+, Opera 9.6+, 和 Safari 4.0+ 都支持这项功能，使用起来也特别简单。

首先创建 a.html 文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>a.html</title>
</head>
<body>
    <iframe src="http://localhost:8081/b.html" style='display: none;'></iframe>
    <script>
        window.onload = function(){
            var targetOrigin = 'http://localhost:8081';
            window.frames[0].postMessage('看到我发给你的信息没',targetOrigin) //window.frames[0]是内嵌的窗口
        }
        window.addEventListener('message',function(e){
            console.log('a.html接收到信息:',e.data)
        });
    </script>
</body>
</html>

创建内嵌b.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>b.html</title>
</head>
<body>
    <script>
        window.addEventListener('message',function(e){
            if(e.source != window.parent){
                return;
            }
            var data = e.data;
            console.log('b.html 接收到的消息:', data);
            parent.postMessage('我看到你发的消息了!',e.origin)
        })
    </script>
</body>
</html>

然后同时开启服务器:注意b.html服务器开启更改接口命令:http-server -p 8081

在浏览器中打开http://127.0.0.1:8080/a.html

跨域成功.
参考教程:Window.postMessage()

2.document.domain实现跨域:(降域)

对于主域相同而子域不同的情况下，可以通过设置 document.domain 的办法来解决，具体做法是可以在 http://www.example.com/a.html和http://sub.example.com/b.html两个文件分别加上 document.domain = "a.com"；然后通过 a.html 文件创建一个 iframe，去控制 iframe 的 window，从而进行交互，当然这种方法只能解决主域相同而二级域名不同的情况

测试的方式稍微复杂点，需要安装 nginx 做域名映射，如果你电脑没有安装 nginx，请先去安装一下: nginx news

安装教程:https://www.cnblogs.com/chuncn/archive/2011/10/14/2212291.html
先创建一个 a.html 文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>a.html</title>
</head>
<body>
    <script>
        document.domain = 'example.com'   //a,b分别加上 document.domain = "example.com"
        var ifr = document.createElement('iframe');  //创建一个iframe 内嵌窗
        ifr.src = 'http://sub.example.com/b.html';
        ifr.style.display = 'none';
        document.body.append(ifr)
        ifr.onload = function(){
            var win = ifr.contentWindow;  //控制内嵌iframe的窗口信息
            alert(win.data)
        }
    </script>
</body>
</html>

创建b.html文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>b.html</title>
</head>
<body>
    <script>
        document.domain = 'example.com';
        window.data = '传送的数据：1111';
    </script>
</body>
</html>

开启服务器

这时候只是开启了两个 http 服务器，还需要通过 nginx 做域名映射，将 Example Domain映射到 localhost:8080，sub.example.com 映射到localhost:8081上打开操作系统下的 hosts 文件：mac 是位于 /etc/hosts 文件，并添加：

127.0.0.1 www.example.com
127.0.0.1 sub.example.com

windows修改host参考:

http://chongzhuang.windowszj.com/faq/164.html

修改好后保存,这样在浏览器打开两个网址后就会访问本地的服务器.

之后打开 nginx 的配置文件：/usr/local/etc/nginx/nginx.conf，并在 http 模块里添加：

server {
    listen 80;
    server_name www.example.com;
    location / {
        proxy_pass http://127.0.0.1:8080/;
    }
}
server {
    listen 80;
    server_name sub.example.com;
    location / {
        proxy_pass http://127.0.0.1:8081/;
    }
}

如果访问本地的域名是www.example.com，就由 localhost:8080 代理该请求。所以我们这时候在打开浏览器访问www.example.com的时候其实访问的就是本地服务器 localhost:8080。

3.location.hash实现跨域

在 url 中，http://www.baidu.com#helloworld的#helloworld 就是 location.hash，改变 hash 值不会导致页面刷新，所以可以利用 hash 值来进行数据的传递，当然数据量是有限的。
假设localhost:8080下有文件 cs1.html要和 localhost:8081 下的 cs2.html传递消息，cs1.html首先创建一个隐藏的iframe，iframe 的 src指向 localhost:8081/cs2.html，这时的 hash 值就可以做参数传递。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CS1</title>
</head>
<body>
    <script>
    // http://localhost:8080/cs1.html
    let ifr = document.createElement('iframe');
    ifr.style.display = 'none';
    ifr.src = "http://localhost:8081/cs2.html#data";
    document.body.appendChild(ifr);
        
    function checkHash() {
        try {
        let data = location.hash ? location.hash.substring(1) : '';
        console.log('获得到的数据是：', data);
        }catch(e) {

        }
    }
    window.addEventListener('hashchange', function(e) {
        console.log('获得的数据是：', location.hash.substring(1));
        });
    </script>
</body>
</html>

cs2.html 收到消息后通过 parent.location.hash 值来修改 cs1.html 的 hash 值，从而达到数据传递。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CS2</title>
</head>
<body>
    <script>
    // http://locahost:8081/cs2.html
    switch(location.hash) {
        case "#data":
        callback();
        break;
    }
    function callback() {
    const data = "some number: 1111"
    try {
        parent.location.hash = data;
    }catch(e) {
        // ie, chrome 下的安全机制无法修改 parent.location.hash
        // 所以要利用一个中间的代理 iframe 
        var ifrproxy = document.createElement('iframe');
        ifrproxy.style.display = 'none';
        ifrproxy.src = 'http://localhost:8080/cs3.html#' + data;     // 该文件在请求域名的域下
        document.body.appendChild(ifrproxy);
        }
       }
    </script>
</body>
</html>

作者：FLYSASA
链接：https://www.jianshu.com/p/211cace53f04
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CS2</title>
</head>
<body>
    <script>
    // http://locahost:8081/cs2.html
    switch(location.hash) {
        case "#data":
        callback();
        break;
    }
    function callback() {
    const data = "some number: 1111"
    try {
        parent.location.hash = data;
    }catch(e) {
        // ie, chrome 下的安全机制无法修改 parent.location.hash
        // 所以要利用一个中间的代理 iframe 
        var ifrproxy = document.createElement('iframe');
        ifrproxy.style.display = 'none';
        ifrproxy.src = 'http://localhost:8080/cs3.html#' + data;     // 该文件在请求域名的域下
        document.body.appendChild(ifrproxy);
        }
       }
    </script>
</body>
</html>

由于两个页面不在同一个域下IE、Chrome不允许修改parent.location.hash的值，所以要借助于 localhost:8080 域名下的一个代理 iframe 的 cs3.html 页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>cs3</title>
</head>
<body>
    <script>
        parent.parent.location.hash = self.location.hash.substring(1);
    </script>
</body>
</html>

同样开启服务器

这里为了图方便，将 cs1,2,3 都放在同个文件夹下，实际情况的话 cs1.html 和 cs3.html 要与 cs2.html 分别放在不同的服务器才对。
之后打开浏览器访问 localhost:8080/cs1.html，注意不是 8081，就可以看到获取到的数据了，此时页面的 hash 值也已经改变。

缺点:

数据直接暴露在了 url 中
数据容量和类型都有限

4.window.name实现跨域

window.name（一般在 js 代码里出现）的值不是一个普通的全局变量，而是当前窗口的名字，这里要注意的是每个 iframe 都有包裹它的window，而这个 window 是top window 的子窗口，而它自然也有 window.name 的属性，window.name 属性的神奇之处在于 name 值在不同的页面（甚至不同域名）加载后依旧存在（如果没修改则值不会变化），并且可以支持非常长的 name 值（2MB）。
举个简单的例子：
你在某个页面的控制台输入：

window.name = "Hello World";
window.location = "http://www.baidu.com";

页面跳转到了百度首页，但是window.name却被保存了下来，还是 Hello World，跨域解决方案似乎可以呼之欲出了：
页面跳转到了百度首页，但是window.name却被保存了下来，还是 Hello World，跨域解决方案似乎可以呼之欲出了：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>a.html</title>
</head>
<body>
<script>
    var data = '';
    const ifr = document.createElement('iframe');
    ifr.src = "http://localhost:8081/b.html";
    ifr.style.display = 'none';
    document.body.appendChild(ifr);
    ifr.onload = function() {
        ifr.onload = function() {
            data = ifr.contentWindow.name;
            console.log('收到数据:', data);
        }
       ifr.src = "about:blank";
    }
</script>
</body>
</html>

再创建b文件:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>b.html</title>
</head>
<body>
    <script>
        window.name = "你想要的数据!";
    </script>
</body>
</html>

http://localhost:8080/a.html在请求远端服务器http://localhost:8081/b.html的数据，我们可以在该页面下新建一个 iframe，该iframe 的 src 属性指向服务器地址(利用 iframe 标签的跨域能力)，服务器文件 b.html 设置好 window.name 的值。
但是由于 a.html页面和该页面iframe 的 src 如果不同源的话，则无法操作iframe里的任何东西，所以就取不到 iframe 的 name值，所以我们需要在b.html加载完后重新换个src设置成'about:blank;' ,如果不重新指向 src的话直接获取 window.name 的话会获取不到数据.

在a.html中重新设置ifr.src = "about:blank";后,打开两个http服务器,访问http://127.0.0.1:8080/a.html