## 简单唠唠

某乎问题：人这一生，应该养成哪些好习惯？

问题链接：[https://www.zhihu.com/question/460674063](https://www.zhihu.com/question/460674063) 

如果我来回答肯定会有**定期运动**的字眼。

平日里也有煅练的习惯，时间久了后一直想把运动数据公开，可惜某运动软件未开放公共的接口出来。

幸运的是，在Github平台冲浪我发现了有同行和我有类似的想法，并且已经用Python实现了他自己的运动主页。

项目链接：[https://github.com/yihong0618/running_page](https://github.com/yihong0618/running_page)

Python嘛简单，看明白后用Node.js折腾一波，自己撸两个接口玩玩。

完成的运动页面挂在我的博客网址。
![](https://files.mdnice.com/user/38618/ff756bdb-4444-4e91-aa90-875f4cc7f6a3.png)
![](https://files.mdnice.com/user/38618/94e3062e-ec1c-4e4d-93dc-18eef8f63420.png)

我的博客：[https://www.linglan01.cn](https://www.linglan01.cn/c/keep/index.html)

我的运动主页：[https://www.linglan01.cn/c/keep/index.html](https://www.linglan01.cn/c/keep/index.html)

Github地址：[https://github.com/CatsAndMice/keep](https://github.com/CatsAndMice/keep)




## 梳理思路

平时跑步、骑行这两项活动多，所以我只需要调用这两个接口，再调用这两个接口前需要先登录获取到token。

```Bash
1. 登陆接口: https://api.gotokeep.com/v1.1/users/login 
   请求方法:post   
   Content-Type: "application/x-www-form-urlencoded;charset=utf-8"

2. 骑行数据接口：https://api.gotokeep.com/pd/v3/stats/detail?dateUnit=all&type=cycling&lastDate={last_date}
   请求方法: get   
   Content-Type: "application/x-www-form-urlencoded;charset=utf-8"
   Authorization：`Bearer ${token}`
   
3. 跑步数据接口：https://api.gotokeep.com/pd/v3/stats/detail?dateUnit=all&type=running&lastDate={last_date}
   请求方法: get   
   Content-Type: "application/x-www-form-urlencoded;charset=utf-8"
   Authorization：`Bearer ${token}`
```

Node.js服务属于代理层，解决跨域问题并再对数据包裹一层逻辑处理，最后发给客户端。

![](https://files.mdnice.com/user/38618/a0ee38b8-b1e8-43b9-a47f-d639045ba47b.png)

不明白代理的同学可以看看这篇《Nginx之正、反向代理》

文章链接：[https://linglan01.cn/post/47](https://linglan01.cn/post/47)

## 运动数据总和

请求跑步接口方法：

`getRunning.js`文件链接[https://github.com/CatsAndMice/keep/blob/master/src/getRunning.js](https://github.com/CatsAndMice/keep/blob/master/src/getRunning.js)

```JavaScript
const { headers } = require('./config');
const { isEmpty } = require("medash");
const axios = require('axios');

module.exports = async (token, last_date = 0) => {
    if (isEmpty(token)) return {}
    headers["Authorization"] = `Bearer ${token}`;
    const result = await axios.get(`https://api.gotokeep.com/pd/v3/stats/detail?dateUnit=all&type=running&lastDate=${last_date}`, { headers })
    if (result.status === 200) {
        const { data: loginResult } = result;
        return loginResult.data;
    }

    return {};
}
```

请求骑行接口方法：

`getRunning.js`文件链接 [https://github.com/CatsAndMice/keep/blob/master/src/getCycling.js](https://github.com/CatsAndMice/keep/blob/master/src/getCycling.js)

```JavaScript
const { headers } = require('./config');
const { isEmpty } = require("medash");
const axios = require('axios');

module.exports = async (token, last_date = 0) => {
    if (isEmpty(token)) return {}
    headers["Authorization"] = `Bearer ${token}`;
    const result = await axios.get(`https://api.gotokeep.com/pd/v3/stats/detail?dateUnit=all&type=cycling&lastDate=${last_date}`, { headers })
    if (result.status === 200) {
        const { data: loginResult } = result;
        return loginResult.data;
    }

    return {};
}
```

现在要计算跑步、骑行的总数据，因此需要分别请求跑步、骑行的接口获取到所有的数据。

`getAllLogs.js`文件链接[https://github.com/CatsAndMice/keep/blob/master/src/getAllLogs.js](https://github.com/CatsAndMice/keep/blob/master/src/getAllLogs.js)

```JavaScript
const { isEmpty } = require('medash');

module.exports = async (token, firstResult, callback) => {
    if (isEmpty(firstResult)||isEmpty(token)) {
        console.warn('请求中断');
        return;
    }
    
    let { lastTimestamp, records = [] } = firstResult;
    while (1) {
        if (isEmpty(lastTimestamp)) break;
        const result = await callback(token, lastTimestamp)
        if (isEmpty(result)) break;
        const { lastTimestamp: lastTime, records: nextRecords } = result
        records.push(...nextRecords);
        if (isEmpty(lastTime)) break;
        lastTimestamp = lastTime
    }
    return records
}
```

一个`while`循环干到底，所有的数据都会被`push`到`records`数组中。

返回的`records`数据再按年份分类计算某年的总骑行数或总跑步数，使用`Map`做这类事别提多爽了。

`getYearTotal.js`文件链接 [https://github.com/CatsAndMice/keep/blob/master/src/getYearTotal.js](https://github.com/CatsAndMice/keep/blob/master/src/getYearTotal.js)

```JavaScript
const { getYmdHms, mapToObj, each, isEmpty } = require('medash');
module.exports = (totals = []) => {
    const yearMap = new Map()
    totals.forEach((t) => {
        const { logs = [] } = t
        logs.forEach(log => {
            if(isEmpty(log))return
            const { stats: { endTime, kmDistance } } = log
            const { year } = getYmdHms(endTime);
            const mapValue = yearMap.get(year);
            if (mapValue) {
                yearMap.set(year, mapValue + kmDistance);
                return
            }
            yearMap.set(year, kmDistance);
        })
    })
    let keepRunningTotals = [];
    each(mapToObj(yearMap), (key, value) => {
        keepRunningTotals.push({ year: key, kmDistance:  Math.ceil(value) });
    })
    return keepRunningTotals.sort((a, b) => {
        return b.year - a.year;
    });
}
```

处理过后的数据是这样子的：

```JSON
[
  {year:2023,kmDistance:99},
  {year:2022,kmDistance:66},
  //...
]
```

计算跑步、骑行的逻辑，唯一的变量为请求接口方法的不同，`getAllLogs.js、getYearTotal.js`我们可以复用。

骑行计算总和：

`cycling.js`文件链接[https://github.com/CatsAndMice/keep/blob/master/src/cycling.js](https://github.com/CatsAndMice/keep/blob/master/src/cycling.js)

```JavaScript
const getCycling = require('./getCycling');
const getAllLogs = require('./getAllLogs');
const getYearTotal = require('./getYearTotal');

module.exports = async (token) => {
    const result = await getCycling(token)
    const allCycling = await getAllLogs(token, result, getCycling);
    const yearCycling = getYearTotal(allCycling)
    return yearCycling
}
```

跑步计算总和：

`run.js`文件链接 [https://github.com/CatsAndMice/keep/blob/master/src/run.js](https://github.com/CatsAndMice/keep/blob/master/src/run.js)

```JavaScript
const getRunning = require('./getRunning');
const getAllRunning = require('./getAllLogs');
const getYearTotal = require('./getYearTotal');

module.exports = async (token) => {
    const result = await getRunning(token)
    // 获取全部的跑步数据
    const allRunning = await getAllRunning(token, result, getRunning);
    // 按年份计算跑步运动量
    const yearRunning = getYearTotal(allRunning)
    return yearRunning
}
```

最后一步，骑行、跑步同年份数据汇总。

`src/index.js`文件链接[https://github.com/CatsAndMice/keep/blob/master/src/index.js](https://github.com/CatsAndMice/keep/blob/master/src/index.js)

```JavaScript
const login = require('./login');
const getRunTotal = require('./run');
const getCycleTotal = require('./cycling');
const { isEmpty, toArray } = require("medash");
require('dotenv').config();
const query = {
    token: '',
    date: 0
}
const two = 2 * 24 * 60 * 60 * 1000
const data = { mobile: process.env.MOBILE, password: process.env.PASSWORD };
const getTotal = async () => {
    const diff = Math.abs(Date.now() - query.date);
    if (diff > two) {
        const token = await login(data);
        query.token = token;
        query.date = Date.now();
    }
    //Promise.all并行请求
    const result = await Promise.all([getRunTotal(query.token), getCycleTotal(query.token)])
    const yearMap = new Map();
    if (isEmpty(result)) return;
    if (isEmpty(result[0])) return;
    result[0].forEach(r => {
        const { year, kmDistance } = r;
        const mapValue = yearMap.get(year);
        if (mapValue) {
            mapValue.year = year
            mapValue.data.runKmDistance = kmDistance
        } else {
            yearMap.set(year, {
                year, data: {
                    runKmDistance: kmDistance,
                    cycleKmDistance: 0
                }
            })
        }
    })
    if (isEmpty(result[1])) return;
    result[1].forEach(r => {
        const { year, kmDistance } = r;
        const mapValue = yearMap.get(year);
        if (mapValue) {
            mapValue.year = year
            mapValue.data.cycleKmDistance = kmDistance
        } else {
            yearMap.set(year, {
                year, data: {
                    runKmDistance: 0,
                    cycleKmDistance: kmDistance
                }
            })
        }
    })
    return toArray(yearMap.values())
}
module.exports = {
    getTotal
}

```

`getTotal`方法会将跑步、骑行数据汇总成这样：

```JSON
[
  {
     year:2023,
     runKmDistance: 999,//2023年，跑步总数据
     cycleKmDistance: 666//2023年，骑行总数据
  },
  {
     year:2022,
     runKmDistance: 99,
     cycleKmDistance: 66
  },
  //...
]
```

每次调用`getTotal`方法都会调用`login`方法获取一次token。这里做了一个优化，获取的token会被缓存2天省得每次都调，调多了登陆接口会出问题。

```JavaScript
//省略
const query = {
    token: '',
    date: 0
}
const two = 2 * 24 * 60 * 60 * 1000
const data = { mobile: process.env.MOBILE, password: process.env.PASSWORD };
const getTotal = async () => {
    const diff = Math.abs(Date.now() - query.date);
    if (diff > two) {
        const token = await login(data);
        query.token = token;
        query.date = Date.now();
    }
   //省略   
}

//省略
```

## 最新动态

骑行、跑步接口都只请求一次，同年同月同日的骑行、跑步数据放在一起，最后按`endTime`字段的时间倒序返回结果。

`getRecentUpdates.js`文件链接 [https://github.com/CatsAndMice/keep/blob/master/src/getRecentUpdates.js](https://github.com/CatsAndMice/keep/blob/master/src/getRecentUpdates.js)

```JavaScript
const getRunning = require('./getRunning');
const getCycling = require('./getCycling');
const { isEmpty, getYmdHms, toArray } = require('medash');
module.exports = async (token) => {
    if (isEmpty(token)) return
    const recentUpdateMap = new Map();
    const result = await Promise.all([getRunning(token), getCycling(token)]);
    result.forEach((r) => {
        if (isEmpty(r)) return;
        const records = r.records || [];
        if (isEmpty(r.records)) return;
        records.forEach(rs => {
            rs.logs.forEach(l => {
                const { stats } = l;
                if (isEmpty(stats)) return;
                // 运动距离小于1km 则忽略该动态
                if (stats.kmDistance < 1) return;
                const { year, month, date, } = getYmdHms(stats.endTime);
                const key = `${year}年${month + 1}月${date}日`;
                const mapValue = recentUpdateMap.get(key);
                const value = `${stats.name} ${stats.kmDistance}km`;
                if (mapValue) {
                    mapValue.data.push(value)
                } else {
                    recentUpdateMap.set(key, {
                        date: key,
                        endTime: stats.endTime,
                        data: [
                            value
                        ]
                    });
                }
            })
        })
    })
    return toArray(recentUpdateMap.values()).sort((a, b) => {
        return b.endTime - a.endTime
    })
}
```

得到的数据是这样的：

```JSON
[
  {
    date: '2023年8月12',
    endTime: 1691834351501,
    data: [
        '户外跑步 99km',
        '户外骑行 99km'
    ]
  },
  //...
]
```

同样的要先获取token，在`src/index.js`文件：

```JavaScript
const login = require('./login');
const getRecentUpdates = require('./getRecentUpdates');
//省略
const getFirstPageRecentUpdates = async () => {
    const diff = Math.abs(Date.now() - query.date);
    if (diff > two) {
        const token = await login(data);
        query.token = token;
        query.date = Date.now();
    }

    return await getRecentUpdates(query.token);
}

//省略
```

最新动态这个接口还是简单的。

## express创建接口

运动主页由于我要将其挂到我的博客，因为端口不同会出现跨域问题，所以要开启跨源资源共享（CORS）。

```JavaScript
app.use((req, res, next) => {
    res.setHeader("Access-Control-Allow-Origin", "*");
    res.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    res.setHeader('Content-Type', 'application/json;charset=utf8');
    next();
})
```

另外，我的博客网址使用的是https协议，Node.js服务也需要升级为https，否则会请求出错。以前写过一篇文章介绍Node.js升级https协议，不清楚的同学可以看看这篇《Node.js搭建Https服务 》文章链接[https://linglan01.cn/post/47](https://linglan01.cn/post/47)。

`index.js`文件链接[https://github.com/CatsAndMice/keep/blob/master/index.js](https://github.com/CatsAndMice/keep/blob/master/index.js)

```JavaScript
const express = require('express');
const { getTotal, getFirstPageRecentUpdates } = require("./src")
const { to } = require('await-to-js');
const fs = require('fs');
const https = require('https');
const path = require('path');
const app = express();
const port = 3000;
app.use((req, res, next) => {
    res.setHeader("Access-Control-Allow-Origin", "*");
    res.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    res.setHeader('Content-Type', 'application/json;charset=utf8');
    next();
})
app.get('/total', async (req, res) => {
    const [err, result] = await to(getTotal())
    if (result) {
        res.send(JSON.stringify({ code: 200, data: result, msg: '请求成功' }));
        return
    }
    res.send(JSON.stringify({ code: 400, data: null, msg: '请求失败' }));
})
app.get('/recent-updates', async (req, res) => {
    const [err, result] = await to(getFirstPageRecentUpdates())
    if (result) {
        res.send(JSON.stringify({ code: 200, data: result, msg: '请求成功' }));
        return
    }
    res.send(JSON.stringify({ code: 400, data: null, msg: '请求失败' }));
})
const options = {
    key: fs.readFileSync(path.join(__dirname, './ssl/9499016_www.linglan01.cn.key')),
    cert: fs.readFileSync(path.join(__dirname, './ssl/9499016_www.linglan01.cn.pem')),
};
const server = https.createServer(options, app);
server.listen(port, () => {
    console.log('服务已开启');
})
```

## 最后的话

贵在坚持，做好「简单而正确」的事情，坚持是一项稀缺的能力，不仅仅是运动、写文章，在其他领域，也是如此。

这段时间对投资、理财小有研究，坚持运动也是一种对身体健康的投资。

又完成了一篇文章，奖励自己一顿火锅。
![](https://files.mdnice.com/user/38618/f8c8c8a8-0d97-4fac-a89c-43fbdf34e989.png)
如果我的文章对你有帮助，您的👍就是对我的最大支持^_^。

更多文章：[http://linglan01.cn/about](http://linglan01.cn/about)

用Node.js吭哧吭哧撸一个运动主页

作者哈维·艾克，世界顶级商业教练。

作者从小家境窘困，十三岁就开始打工，曾经送报、卖冰淇淋、摆摊子卖货物，还到海滩上兜售防晒油。在[约克大学](https://baike.baidu.com/item/约克大学/327057?fromModule=lemma_inlink)读了一年之后，决定开始全心追求他致富的梦想。他辗转在美国西岸和东岸几个城市里做过许多工作，甚至自己当老板，创业十几次却都无法成功。




多年的挫败没有把他打垮。他又开了一家贩售体育用品的公司，在两年半里快速成长为连锁企业，开设了十家分店。然后，他把这项事业卖给一家名列《财星》五百大的企业。他赚了一笔大钱。可是，由于他的错误投资和大肆挥霍，不到两年就把钱莫名其妙用光了。他又回到了起点。

他痛定思痛，回顾自己的成长背景和金钱观，分析各种与致富有关的内在思惟，体会到许多与金钱、致富梦想和人生态度有关的道理。他发现，每一个人心里都有一张**金钱蓝图**，假如不修改这张蓝图，那么就算赚了大钱，这笔钱也不会留在身边太久。

带着这样的信念，他彻底修改了自己的**金钱蓝图**，最后成为了超级大富翁，并且越来越有钱。

成功之后，他致力于帮助更多人实现致富的梦想，超越现有生活，让人生变得不同。他的潜能开发公司红遍全美，以独特的平民气息吸引了来自世界各地的无数普罗大众，一堂课经常塞满了两千人。很多上过他课的人表示，这堂课大大改变了他们的人生，使他们开始累积财富，得到快乐与成功。

### 现实社会

大多数人的现状：

- 对其财政状况担忧而夜不能寐，早上睁眼起来，就去上班
- 怀抱希望，自己马上就能赚到可以付清账单的钱。而当他们收入提高时，开支又梦魇般地同步增多
- 唯一解决方法就是努力工作。希望通过多赚钱，最终变得节俭。但是生活水平同收入平行增长。负债日益增加。

这部分人就必须越来越努力而长时间地工作才能保持生活水平，以偿还债务和账单。

像仓鼠的轮子：尽管他们尽全力，却没有进步。同理一些人不管多努力地工作，只要处于仓鼠的轮子中，他就是原地踏步，这种现象在《财务自由之路2》被称为仓鼠之轮。

### 财富档案

书里讲了17个有钱人的思维习惯，其实书里有钱人17个思维习惯和大多数成功人士书籍所讲大同小异。我摘录几种我认为重要的：

1. 有钱人相信："我创造我的人生"。穷人相信："人生发生在我的身上"。必须相信，只有你能造成自己的成功，也只有你能造成你的平庸，只有你能造成自己为钱辛苦或是前途茫茫。不管出于自觉还是不自觉的原因，你的人生状态都是自己造成的。行动上远离负面能量的人，每天检视自己的行为
2. 有钱人努力让自己有钱。穷人一直想着要变得有钱。如果你并没有达到你嘴巴上所说的很渴望达到的财富成就，很可能是1. 潜意识时并不真的想变得有钱；2. 并不想付出应有的代价去创造财富
3. 有钱人专注于机会。穷人专注于障碍。有钱人冒的是经过计划的风险，他们会做研究，付出必要的努力，再根据具体的资讯和事实做出决定。穷人，他们期待失败。他们对于自己和自己的能力都没有信心。穷人相信，如果事情行不通，就像世界末日来临。而正因为他们总是看见阻碍，所以他们通常都不愿意冒险。
4. 有钱人欣赏其他的有钱人和成功人士，穷人讨厌有钱人和成功人士。不论你现在什么状态，首先做到不讨厌其他人，积极从其他人身上学到优点或教训
5. 有钱人乐意宣传自己和自己价值观，穷人把推销和宣传看成不好的事。敢于推销自己和自己的产品，学习推销能力，不会或不敢推销一定不会成功。
6. 有钱人大于他们的问题，穷人小于他们的问题。遇到问题不要急于去抱怨和责怪，因为抱怨和责怪来自于恐惧，要明白如果遇到了一个很大的问题，说明自己很小，要么列出多条解决方案去解决问题，要么行动起来去将自己变大。不要专注于问题，而专注于目标。
7. 有钱人选择根据结果拿酬劳。穷人选择根据时间拿酬劳。稳定的薪酬会阻碍你挣更多的钱。要么选择可以以自己的成果或者公司的运营来领薪的工作，要么自己当老板，可以从兼职做起。
8. 有钱人专注于自己的净值。穷人专注于自己的工作收入。净值指你所拥有的所有东西，现金，不动产，股票等等可以转化成现金的东西。提高收入，不乱花钱增加存款，有了存款加强投资，简化不必要的花销。看理财类书籍
9. 有钱人管理他们的钱，穷人很会搞丢他们的钱。不是等我拥有了很多钱后我再开始管理，而是我开始管理我的钱了以后，我才会拥有很多钱。所以会管理钱很重要，不要在乎他们的多少。
10. 有钱人让钱帮他们工作。穷人幸苦工作挣钱。一开始你努力工作挣钱，之后就要让钱为你努力工作。被动收入很重要，一定要去培养和开发。被动收入大于你的支出时，你才算真正的财务自由
11. 有钱人就算恐惧也会采取行动，穷人却会让恐惧阻止他们行动有些事一开始做起来是痛苦的，但是你坚持下去就可以穿过痛苦区到达舒适区，不断的扩大你的舒适区因为舒适区和财务区是成正比的，如果一直待在舒适区你是不会成长的
12. 有钱人持续学习成长，穷人以为他们知道了一切。一件事只有你经历了才有资格说你知道，否则你只是听说过看到过或读到过。如果能学到一个知识或者有了一点进步就是值得的。

### 最后

- 行动比不行动好，只会YY没卵用
- 培养财商很重要，有点小钱绝对不是只有买！买！买！
- 月光族没希望，劳碌命，学会储蓄，积累一笔初始资金
- 巴菲特说的：世界上最好的投资，就是投资你自己

如果我的文章对你有帮助，您的👍就是对我的最大支持^_^。

更多文章：[http://linglan01.cn/about](http://linglan01.cn/about)

《有钱人和你想的不一样》阅读笔记

## 什么是代理

A同学在Ai大时代背景下开启他的创业之路，目前他遇到的最大的一个问题就是启动资金，于是他决定去找马云爸爸借钱，可想而知，最后碰一鼻子灰回来了，情急之下，他想到一个办法，找关系开后门，经过一番消息打探，原来A同学的大学老师王老师是马云的同学，于是A同学找到王老师，托王老师帮忙去马云那借500万过来，当然最后事成了。不过马云并不知道这钱是A同学借的，马云是借给王老师的，最后由王老师转交给A同学。这里的王老师在这个过程中扮演了一个非常关键的角色，这就是**代理**，也可以说是正向代理，王老师代替A同学办这件事，这个过程中，真正借钱的人是谁，马云是不知道的，这点非常关键。




## 正向代理

我们常用的VPN，一般为正向代理。

正向代理特点为隐藏真实的客户端，服务端不知道请求的客户端是谁，客户端请求的服务都是代理服务器代替请求。

举个例子，国内的用户想要访问 Google 时，会被阻挡。 于是我们可以在国外搭建一台代理服务器（可以访问 Google 的服务器），让代理帮我去请求google.com，代理把请求返回的相应结构再返回给我。

![](https://linglan008-blog.oss-cn-hangzhou.aliyuncs.com/image.png)

当出现多个客户端时，是这样的：

![](https://linglan008-blog.oss-cn-hangzhou.aliyuncs.com/image%20%282%29.png)

### Nginx正向代理配置

通过proxy\_pass配置代理地址http://google.com。当我们请求www.example.com将会被转发至http://google.com。
```shell
    server {
        server_name www.example.com;
        listen 80;
        location / {
            proxy_pass http://google.com;     #设定代理服务器的协议和地址 
            proxy_set_header HOST $host;
        }
    }
```
### 小结

正向代理代理的对象是客户端，正向代理真正服务的是客户端。不论是一对一，还是多对一，客户端与服务端请求的过程始终隐藏了客户端IP，服务端不清楚客户端是谁。

以客户端的角度来看它有以下优点：

*   可以突破访问限制，由此我们可以访问外网，如：YouTube、Google。它是由客户端控制的代理（想开就开、不想开就不开），做到科学上网
    
*   正向代理可以隐藏自己的真实IP，只有代理服务器才能知道客户端的IP
    
*   提高访问速度，代理服务器可以缓存资源，当多个用户访问同一资源时，代理服务器直接把缓存的资源返回，没有必要向目标服务器重复请求同一份资源
    

## 反向代理

很久以前，老王去饭店吃饭，需要先到饭店，七荤八素点好菜，坐等饭菜上桌，然后大快朵颐，不亦乐乎。

有了第三方订餐外卖平台（代理），老王懒得动身前往饭店，老王打个电话或用APP，先选好某个饭店，再点好菜，外卖小哥会送上门来。

由于某个品牌的饭店口碑特别好，食客络绎不绝涌入，第三方订餐电话也不绝于耳，但是限于饭店接待能力有限，无法提供及时服务，很多食客等得不耐烦了，纷纷铩羽而归，饭店老总看着煮熟的鸭子飞走了，心疼不已。

痛定思痛，老总又成立了几个连锁饭店，形成一个集群，对外提供统一标准的菜品服务，电话订餐电话400-xxx-7777，当食客涌入饭店总台，总台将食客用大巴运到各个连锁店，这样食客既不需要排队，各连锁店都能高速运转起来，一举两得，老总乐开了花，并为此种运作模式，起名为"反向代理"。

在互联网中，单个服务器处理客户端请求能力有限，当客户端发送的请求过多，会造成服务器忙不过来。这时，我们可以设置多个服务器来共同分担请求，这些服务器提供相同的服务，对于用户来说，根本感觉不到差别。我们只需要知道反向代理服务器是谁就好了。如：`www.baidu.com` 就是我们的反向代理服务器，反向代理服务器会帮我们把请求转发到真实的服务器那里去。Nginx就是性能非常好的反向代理服务器，用来做**负载均衡**

![](https://linglan008-blog.oss-cn-hangzhou.aliyuncs.com/image%20%283%29.png)

当出现多个客户端(多对多)时，是这样的：

![](https://linglan008-blog.oss-cn-hangzhou.aliyuncs.com/image%20%284%29.png)

### Nginx反向代理配置

不考虑复杂的配置，仅仅是完成一个 http 反向代理

nginx.conf配置文件如下：

> `conf/nginx.conf` **是 nginx 的默认配置文件。你也可以使用 nginx -c 指定你的配置件**
```shell
    
    //省略
    http {
        #连接超时时间
        keepalive_timeout  120;
        tcp_nodelay        on;
    
    
        #设定实际的服务器列表
        upstream my_server{
            server 127.0.0.1:8089;
        }
    
        #HTTP服务器
        server {
            #监听80端口，80端口是知名端口号，用于HTTP协议
            listen       80;
    
            #定义使用www.xx.com访问
            server_name  www.baidu.com;
    
    		#编码格式
    		charset utf-8;
            #反向代理的路径（和upstream绑定），location 后面设置映射的路径
            location / {
                proxy_pass http://my_server;
            }
            
            //省略
        }
    }
```
上述例子中，代理仅指向一个服务器。然而，网站在实际运营过程中，多数是以集群的方式运行，这时需要使用负载均衡来分流。
```shell
    
    //省略
    http {
        keepalive_timeout  120;
        tcp_nodelay        on;
        #设定实际的服务器列表
        upstream my_server{
            #weigth参数表示权值，权值越高被分配到的几率越大
            server 192.168.1.11:80   weight=5;
            server 192.168.1.12:80   weight=1;
            server 192.168.1.13:80   weight=6;
        }
    
        server {
            listen       80;
            server_name  www.baidu.com;
    		charset utf-8;
            location / {
                proxy_pass http://my_server;
            }
            
            //省略
        }
    }
```
Nginx提供了多种负载均衡策略，这里不再过多描述。

### 小结

反向代理代理的对象是服务端，反向代理真正服务的是服务端。不论是一对多，还是多对多，客户端与服务端请求的过程始终隐藏了服务端IP，客户端不清楚服务端是谁。

以服务端的角度来看它有以下优点：

*   隐藏服务端IP
    
*   负载均衡，反向代理服务器可以根据负载情况，将请求分发到不同的真实服务器上
    
*   安全防护，反向代理服务器可以作为应用层防火墙，为网站提供对基于Web的攻击行为的防护
    

## 总结

反向代理与正向代理区别：

*   正向代理和反向代理面向的服务群体不同，正向代理代理的对象是客户端，反向代理代理的是服务端
    
*   正向代理和反向代理中各自的“视野”不同，正向代理下服务端不知道客户端真实IP，反向代理下客户端不清楚服务端真实IP。
    

## 参考资料
[https://github.com/dunwu/nginx-tutorial](https://github.com/dunwu/nginx-tutorial)  
[https://zhuanlan.zhihu.com/p/500768064](https://zhuanlan.zhihu.com/p/500768064)  
[https://zhuanlan.zhihu.com/p/25707362](https://zhuanlan.zhihu.com/p/25707362)

Nginx之正、反向代理

![image.png](http://www.linglan01.cn/static/img/438d73de219af20de038c88aa3bbf8d4.image.webp)

能够赚钱的五种方式：1. 雇员或者工人 （A）；2.自由职业者（ F）；3. 投资家（I）；4. 企业家 （U）；5. 专家 （E）。



I、U、E能赚到的钱是A、F的好几倍。

当赚钱方式为雇员或者工人、自由职业者时，要想尽方法为自己升职加薪，然后进行储蓄。

学习做一名投资者，这非常重要因为：

-   如果不是投资者，加薪没有任何作用，花销与生活水平同收入并行提高，收入很难满足支出
-   只有当靠资产产生利息生活时，才能感到完全有保障
-   必须攒钱，必须用攒下来的钱做点什么
-   节约+增值=投资者，真正的投资者懂得：“房子可能是一种负债” 买入正确的投资项目，包括无形资产（股票、基金、股权）
-   开发经济头脑，最大的财富是知识，最大的风险是一无所知，努力创造一台属于自己的印钞机
-   堵住孔洞，停止欠下消费债务
 
    ![image.png](http://www.linglan01.cn/static/img/09974948de050b1d3fc469dadcdd6a2c.image.webp)
-   学会区分负债还是资产

    
    ![image.png](http://www.linglan01.cn/static/img/88f7201bda380c309e175bd7de95ba84.image.webp)


    ![image.png](http://www.linglan01.cn/static/img/3f245366f5d21a24782f56c524a73f2b.image.webp)  
    
我想这是大多数人的现状：

-   对其财政状况担忧而夜不能寐，早上睁眼起来，就去上班
-   怀抱希望，自己马上就能赚到可以付清账单的钱。而当他们收入提高时，开支又梦魇般地同步增多
-   唯一解决方法就是努力工作。希望通过多赚钱，最终变得节俭。但是生活水平同收入平行增长。负债日益增加。

这部分人就必须越来越努力而长时间地工作才能保持生活水平，以偿还债务和账单。

像仓鼠的轮子：尽管他们尽全力，却没有进步。同理一些人不管多努力地工作，只要处于仓鼠之轮中，他就是原地踏步。

《财务自由之路2》阅读笔记

# 已读书籍
* 小狗钱钱
* 富爸爸穷爸爸
* JavaScript高级程序设计(红宝书)
* JavaScript权威指南
* Vue.js设计与实现
* JavaScript设计模式与开发实践
* 图解HTTP
* 数据结构与算法JavaScript
* [技术写作指南(掘金小册)](https://s.juejin.cn/ds/iTkge22/)
* [前端缓存技术与方案解析(掘金小册)](https://s.juejin.cn/ds/iTkvs6h/)
* 软能力—吴军
* [《软技能：代码以外的生存指南》阅读总结](https://linglan01.cn/post/23)
* [《影响力》阅读总结+一些产品推广的思考](http://www.linglan01.cn/post/43)
* [《财务自由之路2》阅读笔记](http://www.linglan01.cn/post/46)  
* 《账务自由之路3》不符合本国国情，不推荐
* [人性的弱点](https://www.linglan01.cn/post/50)
* [《有钱人和你想的不一样》阅读笔记](https://linglan01.cn/post/48)
* [微信背后的产品观](https://linglan01.cn/post/53)
* [富有的习惯](https://linglan01.cn/post/54)

# 想读书籍
* 大胆投资自己
* 半小时漫画股票实战法
* 穷查理宝典（难懂，先暂停）