# 浏览器同源策略
## 什么是浏览器同源策略？
“同源策略”（Same Origin Policy）是浏览器安全的基础。
> 同源策略限制从一个源加载的文档或脚本如何与来自另一个源的资源进行交互。这是一个用于隔离潜在恶意文件的关键的安全机制。
在判断两个页面的url是否具有相同的源之前，我们先来看一下一个url（统一资源定位符）的基本组成部分。
> 对于一个url，它的基本组成部分是：协议 :// 域名（或者是ip） : 端口（如果指定了） / 路径。
那么下面我们来举个例子：
对于`http://www.example.com/static`来说，协议就是`http`，它的域名是`www.example.com`，它的路径是`static`，这里的端口号省略了（默认为80）。
值得一提的是，在这个域名下面，`example.com`是主域名，而`www.example.com`是子域名，同样的`a.example.com`也是一个与前面所述不同的另一个子域名。并且，上面这三个域名**互不相同**。
这里不再展开赘述，相关知识请查阅与计算机网络有关的知识。
那如何判断页面是否具有相同的源呢？
> 如果协议，端口（如果指定了）和域名对于两个页面是相同的，则两个页面具有相同的源。
也就是说，判断同源的三要素是：**协议**、**端口**、**域名**。
需要注意的是，如果是一个域名二级域名，比如上面提到的`www.example.com`，它与另外一个二级域名`a.example.com`，虽然他们的主域相同，但是子域不同，于是这两个就**不是同一个域名**，所以也不能说是同源。三级域名依次类推...
下表给出了相对`http://store.company.com/dir/page.html`同源检测的示例：
## 关于Cookie和Session
说到同源策略，必不可少的就是Cookie这个东西了。
而讲到Cookie，跟它关联在一起的又有Session。
对于这两者，这里不做大篇幅的介绍，具体去[传送门](http://www.cnblogs.com/linguoguo/p/5106618.html)查阅。
这里我们做一下简要的总结：
* Cookie受到浏览器同源策略的限制，A页面的Cookie无法被B页面的Cookie访问和操作。
* Cookie最大存储容量一般为4KB，由服务器生成，在HTTP报文首部设置`Set-Cookie`可以指定生成Cookie的内容和生命周期，如果由浏览器生成则在关掉浏览器后失效。
* Cookie存储在浏览器端，由于每次发送HTTP请求默认会把Cookie附到HTTP首部上去，所以Cookie主要用来身份认证，而不用来存储其他信息，防止HTTP报文过大。
* Session存储在服务器，主要与Cookie配合使用完成身份认证和状态保持的功能。只有Cookie或只有Session都无法完成身份认证和状态保持的功能。
最后，对Cookie和Session实现的身份认证和状态保持功能做一个举例。
假设现在有一个学生信息管理系统，此时数据库已经有学生的相关信息。（账号、密码、个人信息等等）
然后当学生登录这个系统，通过POST请求把用户的账户密码发送到后台服务器。当后台服务器接收到这些参数的时候，会跟数据库保存的记录进行匹配。
一旦匹配成功，也就是用户的账号密码都正确的情况下，这个时候后台服务器会在Session中记录一个值，可以是用户名或者其他能够唯一标识用户的字段。
当把这个值保存在Session中后，后台服务器会返回响应告知客户端登录成功，可以进行后续的操作。此时，后台服务器会在HTTP响应报文中添加一个字段`Set-Cookie`，它的值是当前Session的SessionID，（这个SessionID是指向我们当前的那个Session的，在Node的Express中express-session会封装好这个过程）当然还会设置Cookie的其他属性，比如说过期时间`Expires`等等。
当浏览器接收到这个HTTP响应报文的时候，就会在本地设置一个Cookie，它的过期时间由响应报文中`Set-Cookie`中的`Expires`字段的值决定，如果为空，则关闭浏览器（即会话结束时）后失效。
之后，每次向后台服务器发送请求的时候，浏览器默认会把这个Cookie加在HTTP请求报文的Cookie中。这样，每次后台服务器接收到请求的时候，会根据Cookie中的SessionID去找到我们的Session。
假如这个SessionID映射得到Session，那么这个时候说明浏览器是已经登录过了。于是，就可以进行后续的一些相关的操作。
另外，值得一提的是，**Session机制决定了当前客户只会获取到自己的Session，而不会获取到别人的Session。各客户的Session也彼此独立，互不可见。**也就是说，当多个客户端执行程序时，服务器会保存多个客户端的Session。获取Session的时候也不需要声明获取谁的Session。
这就是Cookie和Session做状态保持和身份验证的一个具体的例子。
## 关于iframe
说到同源限制，还有一个不得不提的就是iframe。
iframe可以在父页面中嵌入一个子页面，在日常开发中一旦使用，避免不了的就要涉及到不同的iframe页面进行通信的问题，可能是获得其他iframe的DOM，或者是获取其他iframe上的全局变量或方法等等。
同源下的iframe，也就是iframe中的`src`属性的URL符合同源的条件，那么通过iframe的`contentDocument`和`contentWindow`获取其他iframe的DOM或者全局变量、方法都是很简单的事情。
那如果是非同源的两个iframe，单纯的通过变量访问的方式就受到同源限制了。
为了解决这个问题，HTML5引入了一个新的API：**`postMessage`**，主要就是用来解决存在跨域问题的iframe页面之间通信的问题。
下面简单的举一个例子，假如现在有两个不同的页面，A页面的url是`http://localhost:4002/parent.html`，B页面的url的是`http://localhost:4003/child.html`，现在我把B页面用iframe嵌在A页面下面，代码（精简）是这样子的。现在我要实现的是向子页面B传递一个消息：
A页面代码：
~~~
<body>
<h1>A页面</h1>
<iframe src="http://localhost:4003/child.html" id="child">
</iframe>
<script>
window.onload = function() {
document.getElementById("child").contentWindow.postMessage("父页面发来贺电", "http://localhost:4003");
}
</script>
</body>
~~~
B页面代码：
~~~
<body>
<h1>B页面</h1>
<script>
window.onload = function() {
window.addEventListener("message", function(e) {
//判断信息的来源是否来自于父页面，保证信息源的安全
if(e.source != window.parent) return;
alert(e.data);
});
};
</script>
</body>
~~~
结果如图：
`postMessage`接受两个参数，一个是要传送的`data`，另外一个是目标窗口的源，如果想传给任何窗口，可以设置成`*`。
目标页面接收信息的时候，使用的是`window.addEventListener("message", function() {})`。
## 不受同源限制的情况
当然也有不受同源限制的情况存在，主要有以下列举的：
1. `script`标签允许跨域嵌入脚本，稍后介绍的JSONP就是利用这个“漏洞”来实现。
2. `img`标签、`link`标签、`@font-face`不受跨域影响。
3. `video`和`audio`嵌入的资源。
4. `iframe`载入的任何资源。（不是iframe之间的通信）
5. `<object>`、`<embed>`和`<applet>`的插件。
6. `WebSocket`不受同源策略的限制。
# 开发时常用解决方案
## CORS——跨域资源共享
注：以下跨域资源共享的两种请求辨析内容摘抄至阮一峰的[《跨域资源共享》](http://www.ruanyifeng.com/blog/2016/04/cors.html)一文。
### 什么是跨域资源共享？
> CORS是一个W3C标准，全称是“跨域资源共享”（Cross-origin resource sharing）。
它允许浏览器向跨源服务器发出XMLHttpRequest请求，从而客克服了AJAX只能同源发送请求的限制。
实现CORS主要在于**服务器**的设置，关键在于服务器**HTTP响应报文首部**的设置。前端部分大致还是跟原来发AJAX请求没什么区别，只是需要对AJAX进行一些相关的设置，稍后我们都会讲到。
### CORS的两种请求
在讲解如何实现跨域资源共享的时候，我们先来看一下CORS的两种请求。
浏览器将CORS分为两种请求，一种是简单请求，另外一种对应的肯定就是非简单请求。
只要同时满足下面两大条件，就属于简单请求：
1. 请求的方法是一下的三种方法之一。
* HEAD
* GET
* POST
1. HTTP的头信息不超过以下几种字段：
* Accept
* Accept-Language
* Content-Language
* Last-Event-ID
* Content-Type: 只限于三个值：`application/x-www-form-urlencoded`、`multipart/formdata`、`text/plain`。
凡是不同时满足以上两种条件，就属于非简单请求。
浏览器对于两种请求处理是不一样的。
#### 简单请求
对于简单请求，浏览器直接发出CORS请求。具体来说，就是在HTTP请求报文首部，增加一个`Origin`字段。如下：
~~~
GET /cors HTTP/1.1
Origin: http://api.bob.com
Host: api.alice.com
Accept-Language: en-US
Connection: keep-alive
User-Agent: Mozilla/5.0...
~~~
上面`Origin`字段的用来说明本次请求来自哪个源（协议+域名+端口）。服务器根据这个值，决定是否同意这次请求。
如果`Origin`指定的源，不在许可范围内，服务器会返回一个正常的HTTP回应。浏览器发现，这个回应的头信息没有包含`Access-Control-Allow-Origin`字段（详见下文），就知道出错了，从而抛出一个错误，被XMLHttpRequest的`onerror`回调函数捕获。注意，这种错误无法通过状态码识别，因为HTTP回应的状态码有可能是200。
如果`Origin`指定的域名在许可范围内，服务器返回的响应，会多出几个头信息字段。
~~~
Access-Control-Allow-Origin: http://api.bob.com
Access-Control-Allow-Credentials: true
Access-Control-Expose-Headers: FooBar
Content-Type: text/html; charset=utf-8
~~~
上面的HTTP响应报文首部信息中，有三个与CORS请求相关的字段，都是以`Access-Control-`开头。
**Access-Control-Allow-Origin**
该字段是必须的，它的值要么是请求`Origin`字段，要么是一个`*`，表示接受任意域名的请求。
**Access-Control-Allow-Credentials**
该字段可选。它的值是一个布尔值，表示是否允许发送Cookie。默认情况下，Cookie**不包括**在CORS请求之中。设为`true`，即表示服务器明确许可，Cookie可以包含在请求中，一起发给服务器。这个值也只能设为`true`，如果服务器不要浏览器发送Cookie，删除该字段即可。
值得一提的是，如果想要CORS支持Cookie，不仅要在服务器指定HTTP响应报文首部字段，还需要在AJAX中打开`withCredentials`的属性。（jQuery中AJAX设置后面会讲到）
~~~
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
~~~
有些浏览器在省略`withCredentials`设置的时候，还是会发送Cookie。于是，可以显式关闭这个属性。
~~~
xhr.withCredentials = false;
~~~
**需要注意的是，如果要发送Cookie，`Acess-Control-Allow-Origin`不能设置为`*`，必须设置成具体的域名，如果是本地调试的话可以考虑设置成`null`。**
**Access-Control-Expose-Headers**
该字段可选。CORS请求时，XMLHttpRequest对象的`getResponseHeader()`方法只能拿到6个基本字段：`Cache-Control`、`Content-Language`、`Content-Type`、`Expires`、`Last-Modified`、`Pragma`。如果想拿到其他字段，就必须在`Access-Control-Expose-Headers`里面指定。上面的例子指定，`getResponseHeader('FooBar')`可以返回`FooBar`字段的值。
#### 非简单请求
非简单请求是那种对服务器有特殊要求的请求，比如请求方法是PUT或DELETE，或者`Content-Type`字段的类型是`application/json`。
非简单请求的CORS请求，会在正式通信之前，增加一次HTTP查询请求，称为"预检"请求（preflight）。
浏览器先询问服务器，当前网页所在的域名是否在服务器的许可名单之中，以及可以使用哪些HTTP动词和头信息字段。只有得到肯定答复，浏览器才会发出正式的XMLHttpRequest请求，否则就报错。
下面是一段JavaScript脚本：
~~~
var url = 'http://api.alice.com/cors';
var xhr = new XMLHttpRequest();
xhr.open('PUT', url, true);
xhr.setRequestHeader('X-Custom-Header', 'value');
xhr.send();
~~~
很明显，这是一个非简单请求，使用了PUT方法来发送请求，并且自定义了一个HTTP请求报文的首部字段。
于是，浏览器发现这是一个非简单的请求，就自动发出了一个“预检”请求，要求服务器确认可以这样请求。下面是这个“预检”请求的HTTP头信息。
~~~
OPTIONS /cors HTTP/1.1
Origin: http://api.bob.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: X-Custom-Header
Host: api.alice.com
Accept-Language: en-US
Connection: keep-alive
User-Agent: Mozilla/5.0...
~~~
"预检"请求用的请求方法是OPTIONS，表示这个请求是用来询问的。头信息里面，关键字段是`Origin`，表示请求来自哪个源。
除了`Origin`字段，“预检”请求的头信息还包括两个特殊字段。
**Access-Control-Request-Method**
该字段是必须的，用来列出浏览器的CORS会用到哪些HTTP方法，上面是PUT。
**Access-Control-Request-Headers**
该字段是一个用逗号分隔的字符串，指定浏览器CORS请求会额外发送的头信息。上面的例子是`X-Custom-Header`。
于是，服务器收到“预检”请求之后，检查了`Origin`、`Access-Control-Request-Method`和`Access-Control-Request-Headers`字段以后，确认允许跨域请求，就可以做出回应。
~~~
HTTP/1.1 200 OK
Date: Mon, 01 Dec 2008 01:15:39 GMT
Server: Apache/2.0.61 (Unix)
Access-Control-Allow-Origin: http://api.bob.com
Access-Control-Allow-Methods: GET, POST, PUT
Access-Control-Allow-Headers: X-Custom-Header
Content-Type: text/html; charset=utf-8
Content-Encoding: gzip
Content-Length: 0
Keep-Alive: timeout=2, max=100
Connection: Keep-Alive
Content-Type: text/plain
~~~
如果浏览器否定了"预检"请求，会返回一个正常的HTTP回应，但是没有任何CORS相关的头信息字段。这时，浏览器就会认定，服务器不同意预检请求，因此触发一个错误，被XMLHttpRequest对象的`onerror`回调函数捕获。控制台会打印出如下的报错信息。
~~~
XMLHttpRequest cannot load http://api.alice.com.
Origin http://api.bob.com is not allowed by Access-Control-Allow-Origin.
~~~
服务器回应的其他CORS相关字段如下：
~~~
Access-Control-Allow-Methods: GET, POST, PUT
Access-Control-Allow-Headers: X-Custom-Header
Access-Control-Allow-Credentials: true
Access-Control-Max-Age: 1728000
~~~
对比简单请求服务器响应的CORS字段，发现多了三个：
**Access-Control-Allow-Methods**
该字段必需，它的值是逗号分隔的一个字符串，表明服务器支持的所有跨域请求的方法。注意，返回的是所有支持的方法，而不单是浏览器请求的那个方法。这是为了避免多次"预检"请求。
**Access-Control-Allow-Headers**
如果浏览器请求包括`Access-Control-Request-Headers`字段，则`Access-Control-Allow-Headers`字段是必需的。它也是一个逗号分隔的字符串，表明服务器支持的所有头信息字段，不限于浏览器在"预检"中请求的字段。
**Access-Control-Max-Age**
该字段可选，用来指定本次预检请求的有效期，单位为秒。上面结果中，有效期是20天（1728000秒），即允许缓存该条回应1728000秒（即20天），在此期间，不用发出另一条预检请求。
于是，一旦浏览器通过了“预检”，以后每次浏览器正常的CORS请求，都跟简单请求一样，会有一个`Origin`头信息字段。服务器的回应，也都有一个`Access-Control-Allow-Origin`头信息字段。如果开启了Cookie设置，那还有一个`Access-Control-Allow-Credentials:true`。
### 如何在Node实现跨域资源共享？
那怎么在Node中结合Express设置后台的跨域部分呢？
其实很简单，需要设置的就是上面所述的几个响应首部的字段，主要考虑两种类型的请求和是否需要使用Cookie。具体设置如下：
~~~
app.all("*", function(req, res, next) {
res.header("Access-Control-Allow-Origin", /* url | * | null */);
res.header("Access-Control-Allow-Headers", "Authorization, X-Requested-With");
res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS"); /* 服务器支持的所有字段 */
res.header("Access-Control-Allow-Credentials", "true"); /* 当使用Cookie时 */
res.header("Access-Control-Max-Age", 300000); /* 设置预检请求的有效期 */
if (req.method === "OPTIONS") return res.send(200); /*让options请求快速返回*/
else next();
});
~~~
上面的设置有几个需要注意的地方：
1. 如果需要本地调试，也就是在本地HTML页面发请求（类似`file://...`之类的url），可以把`Access-Control-Allwo-Origin`的值设置为Null，这样子就能够使用Cookie。如果设置成`*`，虽然也可以跨域发送请求，但是这个时候**没有办法使用Cookie**。
2. `Access-Control-Allow-Headers`字段不是必须的，仅当发送的请求有`Access-Control-Request-Headers`时需要设置。
3. 使用Cookie的时候要配置`Access-Control-Allow-Methods`字段。
4. “预检”请求可设置缓存时间，可以保证不多次发送“预检”请求。
5. 需要判断是否为“预检”请求，当拦截“预检”请求的时候直接返回。
如果使用jQuery封装的AJAX发送请求，那么需要在相应的JS代码设置：
~~~
$.ajaxSetup({ xhrFields: { withCredentials: true }, crossDomain: true });
~~~
`withCredentials`是设置CORS发送Cookie，默认是不发送的。
`crossDomain`告知AJAX允许跨域。
以上就是CORS设置跨域的具体介绍。
## 基于JSONP技术实现跨域
### JSONP原理
对于JSONP来说，前面也已经提到了，其实它是利用了某些不受同源限制的标签的所谓“漏洞”，来实现“曲线救国”式的跨域的方案。
它借用`script`标签不受同源限制的这个特性，通过**动态的给页面添加一个`script`标签，利用事先声明好的数据处理函数来获取数据。**
值得一提的是，JSONP这种方法其实和CORS有很大的区别，它并不属于一种规范。所谓的JSONP是应用JSON数据的一种新方法，它只不过是被包含在函数调用中的JSON。
在JSONP中包含两部分：**回调函数和数据**。其中，回调函数是当响应到来时要放在当前页面被调用的函数。而数据，就是传入回调函数中的JSON字符串，也就是回调函数的参数了。下面我们简单模拟一下JSONP的通信过程。
JSONP的原理详细讲解可以看这个[传送门](https://www.cnblogs.com/dowinning/archive/2012/04/19/json-jsonp-jquery.html)。
我们来简单的模拟一下JSONP的通信过程。
~~~
function handleResponse(response) {
console.log(response.data);
}
var script = document.createElement("script");
script.src = "http://example.com/jsonp/getSomething?uid=123&callback=hadleResponse"
document.body.insertBefore(script, document.body.firstChild);
/*handleResponse({"data": "hey"})*/
~~~
它的过程是这样子的：
1. 当我们通过新建一个`script`标签请求时，后台会根据相应的参数来生成相应的JSON数据。比如说上面这个链接，传递了`handleResponse`给后台，然后后台根据这个参数再结合数据生成了`handleResponse({"data": "hey"})`。
2. 紧接着，这个返回的JSON数据其实就可以被当成一个js脚本，就是对一个函数的调用。
3. 由于我们事先已经声明了这么一个回调函数，于是当资源加载进来的时候，直接就对函数进行调用，于是数据当然就能获取到了。
4. 至此，跨域通信完成。
另外，想要实现JSONP，后台服务器也必须做相应的设置。
值得一提的是，JSONP是存在一定的局限性的：
* 只能用于GET请求
* 存在安全问题，请求代码中可能存在安全隐患
* 要确定JSONP请求是否失败并不容易
### 一个简单的JSONP实现
下面是一个实现JSONP的库，我们来一起分析一下它的源代码。这是源码的[github地址](https://github.com/webmodules/jsonp)。
~~~
/**
* Module dependencies
*/
var debug = require('debug')('jsonp');
//使用依赖
/**
* Module exports.
*/
module.exports = jsonp;
//输出模块
/**
* Callback index.
*/
var count = 0;
//回调函数的index值，便于取名。
/**
* Noop function.
*/
function noop(){}
//无操作空函数，以便使用后把window[id]置空
/**
* JSONP handler
*
* Options:
* - param {String} qs parameter (`callback`)
* - prefix {String} qs parameter (`__jp`)
* - name {String} qs parameter (`prefix` + incr)
* - timeout {Number} how long after a timeout error is emitted (`60000`)
*
* @param {String} url
* @param {Object|Function} optional options / callback //这里的callback是取得数据后的callback，不是传给服务器的callback
* @param {Function} optional callback
*/
function jsonp(url, opts, fn){
if ('function' == typeof opts) {
fn = opts;
opts = {};
}
if (!opts) opts = {};
var prefix = opts.prefix || '__jp';
// use the callback name that was passed if one was provided.
// otherwise generate a unique name by incrementing our counter.
var id = opts.name || (prefix + (count++));
var param = opts.param || 'callback';
var timeout = null != opts.timeout ? opts.timeout : 60000;
var enc = encodeURIComponent;
var target = document.getElementsByTagName('script')[0] || document.head;
var script;
var timer;
//一定时间内后台服务器没有返回视为超时
if (timeout) {
timer = setTimeout(function(){
cleanup();
if (fn) fn(new Error('Timeout'));
}, timeout);
}
//回复原始设置、清空状态
function cleanup(){
if (script.parentNode) script.parentNode.removeChild(script);
window[id] = noop;
if (timer) clearTimeout(timer);
}
//取消操作
function cancel(){
if (window[id]) {
cleanup();
}
}
//声明函数，等待script标签加载的url引入完毕后调用
window[id] = function(data){
debug('jsonp got', data);
cleanup();
if (fn) fn(null, data);//node中约定第一个参数为err，但是这里不传，直接就置为null
};
// add qs component
url += (~url.indexOf('?') ? '&' : '?') + param + '=' + enc(id);
url = url.replace('?&', '?');
debug('jsonp req "%s"', url);
// create script
script = document.createElement('script');
script.src = url;
target.parentNode.insertBefore(script, target);
//引入script标签后会直接去调用声明的函数，然后函数会把script标签带有的data给传出去
return cancel;
//返回初始状态
}
~~~
### 基于JSONP库的封装
接着，我们可以利用上面的这个库，给它进行一个封装，下面是我们自己写的`_jsonp`函数：
~~~
/* 这个是自己定义的一个_jsonp */
/**
* @param {String} url
* @param {Object} data
* @param {Object} option
* @returns
*/
function _jsonp(url, data, option) {
url += (url.indexOf('?') < 0 ? '?' : '&') + param(data);
return new Promise((resolve, reject) => {
jsonp(url, option, (err, data) => {
if (!err) {
resolve(data);
} else {
reject(err);
}
});
});
/* 这里把jsonp封装成了一个promise对象，回调函数中如果成功的话会把数据带回来然后resolve出去 */
}
//紧接着是对参数的一个序列化
function param(data) {
let url = '';
for (var k in data) {
let value = data[k] !== undefined ? data[k] : '';
url += `&${k}=${encodeURIComponent(value)}`;
}
return url ? url.substring(1) : '';/* 这里的substring保证不会有多余的& */
}
~~~
### 在jQuery中使用JSONP
另外，在jQuery中的AJAX中，已经封装了JSONP，下面简单介绍一下如何去使用。
~~~
$.ajax({
type: "get",
url: "http://example.com",
dataType: "jsonp",
jsonp: "callback",
jsonpCallback: "responseCallback",
success: function (data) {
console.log(data);
},
error: function (data) {
console.log(data);
}
});
~~~
在AJAX中，主要设置`dataType`类型为`jsonp`。对于`jsonp`参数来说，默认值是`callback`，而`jsonpCallback`参数的值默认是jQuery自己生成的。如果想自己指定一个回调函数，可像代码中对`jsonpCallback`进行设置。上面的代码中，最终的url将会是`http://example.com?callback=responseCallback`。
## 使用代理服务器转发请求
由于同源策略仅存在于**浏览器**。对于服务器与服务器之间的通讯，是不存在任何同源限制的说法的。
因此，使用代理服务器来转发请求也是我们在日常开发中解决跨域的一个常用的手段。
实现的方法很简单，只要你会使用Node和Express。
需要注意的是，通常后台服务器都会自己的一个验证的机制，比如说微信文章在`iframe`中图片是加载不出来的，因为其后台对`referer`进行了验证。另外，有些服务器也会通过发送一些`uid`等等之类的字符串供后台校验。因此，我们在使用代理服务器的时候，要重点关注**请求的参数**，这样才能准确的模拟出请求并转发。
下面简单介绍如何使用代理服务器转发请求。
* 分析url请求所需要的参数。
* 代理服务器暴露出一个api，这个路由实际的功能是去请求真正的服务器。
* 之后，我们只要请求这个api，我们所建的代理服务器就会默认的帮我们去转发请求到真正的服务器上，其中会加上一些相应的参数。
最后，我们来利用反微信图片防盗链这个实例来写一个代理服务器。
### 如何使用代理服务器反微信图片防盗链？
当我们上线了一个网站的时候，然后`img`标签引用了微信图片的地址，会出现下面的这种情况。
这就是所谓的防盗链。
现在我们给它加上一个代理，代码如下：
~~~
var express = require("express");
var superagent = require("superagent");
var app = express();
app.use("/static", express.static("public"));
app.get("/getwxImg", (req, res) => {
//如果单纯的去获取会出现参数丢失的情况，因为出现了两个问号
var url = req.url.substring(req.url.indexOf("param=") + 6);
res.writeHead(200, {
'Content-Type': 'image/*'
});
superagent.get(url)
.set('Referer', '')
.set("User-Agent",
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
)
.end(function (err, result) {
if (err) {
return false;
}
res.end(result.body);
return;
});
});
app.listen(4001, (err) => {
if (err) {
console.log(err);
} else {
console.log("server run!");
}
});
~~~
这样子，我们就可以把链接修改成我们服务器的地址，然后把真正的url作为我们的参数。
~~~
<!-- 这是有代理的情况 -->
<img src="http://localhost:4001/getwxImg?param=http://mmbiz.qpic.cn/mmbiz/CoJreiaicGKekEsuheJJ7Xh53AFe1BJKibyaQzsFiaxfHHdYibsHzfnicbcsj6yBmtYoJXxia9tFufsPxyn48UxiaccaAA/640?wx_fmt=jpeg&wxfrom=5&wx_lazy=1&tp=webp">
<!-- 下面是没有代理的情况 -->
<img src="http://mmbiz.qpic.cn/mmbiz/CoJreiaicGKekEsuheJJ7Xh53AFe1BJKibyaQzsFiaxfHHdYibsHzfnicbcsj6yBmtYoJXxia9tFufsPxyn48UxiaccaAA/640?wx_fmt=jpeg&wxfrom=5&wx_lazy=1&tp=webp">
~~~
结果如下：
结果显而易见，这就是所谓的代理服务器，附上gitub[项目地址](https://github.com/Devinnn/weixinPictureReverseUrl)。
- 关于我
- nginx
- 代理
- 实例1
- 使用Nginx实现反向代理
- nginx反向代理配置
- Nginx缓存原理及配置
- nginx 信号集
- rewrite
- nginx rewrite规则
- nginx rewrite 正则规则详解
- nginx+php-fpm fastcgi防止跨站、跨目录的安全设置
- 写了个shell脚本，实现nginx日志自动切割，并利用goaccess分析成HTML报表，然后通知管理人员查阅
- nginx禁止一些常见的不应该让用户访问的文件
- PHP
- 实现PHP多进程管理
- php代码规范
- PHP性能优化
- PHP结构优化大全
- PHP编码规范
- 常见的PHP安全性攻击
- Linux
- 常用命令
- scp
- touch
- nohup
- rsync
- ssh命令 远程登录
- chmod
- nginx日志切割脚本
- Linux使用ssh公钥实现免密码登录Linux
- 使用ssh公钥密钥自动登陆linux服务器
- Linux查看程序端口占用情况
- ssh 公钥私钥认证原理
- 路由图
- CentOS7防火墙设置
- linux下用户管理
- Linux 服务器安全技巧
- Linux shell 提取文件名和目录名
- Linux环境下设置命令别名（alias）
- Git
- 搭建Git服务器
- 手把手教你搭建git服务器
- Git 基本操作
- git删除文件夹/文件(不删除本地文件)
- git忽略文件和文件夹以及文件权限
- Git的四个区五种状态
- git init 和 git init --bare 的区别
- git仓库删除所有提交历史记录，成为一个干净的新仓库
- 如何正确使用Git Flow
- HTTP
- 前端跨域解决方案
- HTTP基本概念
- Redis
- Redis 数据类型及应用场景
- JavaScript
- WebSocket探秘
- socket与websocket的区别
- 基于 Swoole 的微信扫码登录
- Web前端开发规范手册
- 简单的学习了一下ES6
- ES6模块的import和export用法
- MySql
- MySql重置root密码的方法
- mysql 5.6.30 开启慢查询日志
- mysql查看锁表情况
- 我的设计稿
- 会计出纳系统
- 上门宝ERP系统
- 社交应用七大需求
- 出纳系统
- 利用SdfMpp搭建中大行软件系统
- B2C库存商品系统
- 软件
- 网上商城
- 思维逻辑
- 系统架构分层图
- 代码检查规范
- 研发计划
- 系统架构
- 我设计的架构架构图
- 电商网站架构案例
- 大型网站架构
- 服务熔断、降级、限流、异步RPC
- 软件版本号规范
- 第三方服务引擎
- kafka
- ElasticSearch
- 阿里云 推荐引擎
- 随记
- 人生最大的投资
- 产品研发团队管理的6个方面
- 我感觉自己根本不是一个创业者，更谈不上企业家，果然还是屌丝这个称呼更适合我。
- 学什么语音都应该养成的编程习惯
- 2018年5月23日 多云转阴 15-24°C 离职信
- 2017年12月25日
- 对“目标”的认知
- 个人简历
- API设计
- 理解OAuth 2.0
- OAuth 2.0四种授权方式小结
- 对 REST 的理解
- RESTful API 设计指南
- RESTful API 设计
- RPC
- 微服务架构方案
- SOA
- 理解RESTful架构
- RESTful API GET，DELETE，PUT和POST的响应状态码
- MongoDB
- MongoDB-无法启动的一个问题