這個世界上有太多的坑，如果我們不具備查閱資料的能力和對現實世界的思考能力，入坑是大概率的事情。

C/C++語言能做什麼？C/C++程序員在做什麼？企業需要什麼樣的C/C++程序員？對初學者來說，要搞清楚這些問題並不容易。

一個农民種菜之前，會考慮菜的行情（包括銷量和價錢），如果您打算學習C/C++語言，也應該先了解C/C++程序員的行情。

了解菜的行情要去菜市場，了解C/C++程序員的行情去人才市場，中國最大的IT人才市是前程無憂。

我們先來查一些資料。

一、中國編程語言的排名情況

登錄前程無憂的官網，分別輸入java、C++、python、javascript、.net、C#、PHP、SQL、IOS關鍵字，城市選擇北京、上海、廣州和深圳，查詢到的招聘職位分別是31032、22842、19274、14091、6956、8018、5284、21302、6014個。（這是2020年6月查到的數據，不同時期的查詢結果略有不同）

數據显示企業的JAVA和C++職位比例約6：4，培訓機構的主流課程是JAVA和Python等，進一步導致了C/C++程序員的缺乏。

培訓機構不願意開設C/C++課程，C/C++語言的教學對老師的能力要求非常高，普通講師難以信任。

編程語言的選擇是人生大事，必須慎重，誰都不希望在工作幾年後被迫從一種編程語言轉向另一種編程語言。

JAVA和C/C++是程序員可選的兩個方向（其它編程語言根本不在考慮範圍），無所謂哪一種更好，我個人偏向C/C++，因為JAVA程序員的工作太累了。

更多的人選擇學習JAVA，在較短的時間內就可以上手，從簡單的WEB頁面做起，所見即所得，容易有成就感，但是C/C++不一樣，學生在學完基礎知識后還是不知道它能做什麼，離企業需求仍然差得很遠，堅持下去的人很少，“從入門到放棄”是多數人的無奈的選擇。

二、企業對C/C++程序員的技能要求

從前程無憂的招聘數據看，中國企業對C/C++的技能要求主要有網絡通信、硬件驅動（嵌入式）、數據庫、視頻音頻、網絡遊戲、桌面圖形、機器學習、大數據、物聯網，如下圖。

以上數據可以從前程無憂的官網查詢，分別輸入“C++ 網絡”、“C++ 嵌入式”、“C++ 數據庫”、“C++ 遊戲”等關鍵字，範圍選北京、上海、廣州和深圳。

值得注意的是，近年來被媒體反覆炒作的人工智能、大數據、物聯網、區塊鏈等高大上的概念，企業需求其實很少，現在股票也不抄這個概念了。

輸入“ C++ Linux”關鍵字搜索，結果有9767條記錄，輸入“C++ Windows”關鍵字搜索，只有2500條記錄。這說明windows作為服務器的操作系統，正在被淘汰中。

目前，大部分的學校和培訓機構讓學生windows平台下學習C/C++語言，而企業要求的卻是linux。

我們應該學習主流技術，不能成為非主流，否則有被淘汰的風險。

三、數據比石油更珍貴

在我們的生活中，數據無處不在，但是，常人對它不敏感。

人口戶藉數據在公安局。

駕照數據和車輛數據也在公安局的交警支隊。

醫院保存了每個病人的基本資料和就診數據。每個產婦在醫院生了小孩子，計劃生育部門也會知道，它們與公安局和醫院有聯網交換數據。

銀行有開戶數據，轉帳記錄。

證券公司有行情數據、股東基本數據、持股數據和交易日誌。

電信公司有開戶數據、通話清單、帳單。

電力局有居民的基本數據和用電帳單。

火車票、機票都是數據。

騰訊公司有QQ帳戶數據、微信帳戶數據、聊天日誌、轉帳日誌等。

阿里公司有淘寶帳戶數據，商戶數據，商品數據、交易日誌等。

煤氣公司、自來水公司……

一個人的身高、體重、學歷、年齡是數據。

圖片、視頻、音頻、文章也是數據。

……

四、C/C++程序員在做什麼

用C/C++做桌面程序的比例約11%，其它的C/C++程序都運行在後台Linux服務器上，普通用戶看不見。

在很多培訓機構的教程中，把貪吃蛇、俄羅斯方塊、打地鼠、球球大作戰等程序當成項目實戰，太過兒戲，這些程序的源代碼網上到處都是，真正的程序員不玩這個。

真正的C/C++程序員在工作，掌握的是謀生的技能，不是在玩過家家。

我們每天都在用微信軟件聊天、付款、轉帳等，對普通用戶來說，只看到微信軟件的操作界面，不清楚有後台系統的存在，以轉帳功能為例。

1）付款人在手機微信中輸入轉帳金額和支付密碼；

2）手機微信軟件把轉帳金額和密碼發送給騰訊公司的微信服務器；

3）微信服務器核對用戶的密碼和轉帳金額，向中國銀聯發起轉帳請求，中國銀聯把轉帳請求轉發給付款方的開戶行銀行，開戶銀行從付款人的帳戶中扣除金額。

4）微信服務器把扣款成功信息返回給手機微信軟件，显示轉帳成功。

5）微信服務器向收款人的手機微信軟件發送收錢提醒，收款人點擊收款后，微信服務器把金額存入收款人的微信帳戶中。

在上述轉帳流程中，蘋果手機的微信軟件採用Objective-C語言開發，其它品牌手機的微信軟件採用JAVA開發；微信服務器、中國銀聯和開戶銀行都是非常龐大的系統，系統之間進行了多次數據傳輸，對數據庫進行了查詢、修改和插入操作，都是採用C/C++語言開發，系統運行在UNIX系統上，效率極高、穩定性極強，工程量巨大，是精英程序員們的心血之作。

對騰訊的開發團隊來說，手機上安裝的微信APP軟件，開發的工作量不會超過整個微信項目的5%。

五、總結一下

1）網絡通信和數據處理以C/C++語言為主，數據輸入、數據展示以java為主。

2）作為服務器的操作系統，必選Linux，Windows已被淘汰，以VC、QT等作為C程序的開發環境極不明智。

3）網絡通信是C/C++程序員的必備技能。

4）數據處理是C/C++程序員的必備技能。

5）嵌入式開發的職位比較多，技術上偏硬件（通信、电子等專業），軟件為輔，無硬件基礎者要慎重考慮。

6）放棄幻想，不要追逐那些高大上的潮流（區塊鏈、大數據、人工智能等），也不要聽那些從入門到精通的鬼話，踏實一點，先成為一個普通程序員，這個世界上從來就沒有捷徑。

7）要學會自己查資料，www.51job.com上的信息量非常大，不要視而不見，不能被別人隨便忽悠。

六、關於視頻教程

2019年五月，我計劃錄製C/C++語言基礎知識的視頻課程，打算採用知名的書藉作為教材，在翻閱多本書藉之後，我非常的失望。作為一個骨灰程序員，二十年來，我非常清楚如何成為一個合格的C/C++程序員，包括學習方向、企業的需求和必備技能等。書店裡能買到的C/C++
書藉，絕大部分是教授和講師編寫出來的，普遍存在三個方面的問題：

1）只介紹知識點，不結合應用的場景，示例代碼和課後作業與實際項目開發嚴重脫節；

2）重點內容不突出，C/C++的知識點非常多，很多內容已經過時，在工作中極少使用，這些內容增加了學習的負擔；

3）紙上談編程，不注重培養程序員的感覺。

從職業程序員的角度出發，我把C/C++語言的基礎知識內容寫成文章，在C語言技術網發布，本教程有以下特點：

1）以Linux平台為學習和開發環境，Linux是C/C++程序員的主流工作平台；

2）斷章取義，重點突出實際開發中常用的內容，略過不常用的知識；

3）設計了大量的課後作業，這些作業與實際開發內容息息相關，把培養程序員的感覺放在首位；

4）本教程的目標是為職業C/C++程序員打基礎，不合適在校大學生的畢業考試和計算機等級考試。

七、獲取視頻教程

百萬年薪程序員錄製，《C/C++高性能服務開發基礎》視頻教程已在CSDN學院發布，優惠價12元，地址如下：
https://edu.csdn.net/course/play/29402

八、版權聲明

C語言技術網原創文章，轉載請說明文章的來源、作者和原文的鏈接。

來源：C語言技術網（www.freecplus.net）

作者：碼農有道

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※新北清潔公司,居家、辦公、裝潢細清專業服務

※教你寫出一流的銷售文案?

SSH免密登錄詳解

SSH（Security Shell）安全外殼協議，是較為可靠的，專為遠程登錄會話和其他網絡服務提供安全保證的協議。

​ 對於傳統的網絡服務程序（例如，FTP，Telnet等）來說，其本質上並不是安全的，主要原因在於，這些網絡應用程序在網絡上都是直接使用明文傳輸口令和數據的，對於別有用心的人來說，這些口令和數據是很容易被截獲的。另外，這些網絡服務程序的安全驗證方式也是存在弱點的，非常容易受到中間人（Man-In-The-Middle）這種方式的攻擊，簡而言之，就是中間人冒充真正的服務器接收你傳輸的數據，然後，再將數據轉發給真正的服務器，通過這種方式中間人就可以神不知鬼不覺地拿到你所有數據。

​ 通過使用SSH，則可以將所有傳輸的數據及口令進行加密，從而防止中間人攻擊，還可以防止DNS和IP欺騙，另外，使用SSH還有加快傳輸速度的好處，原因在於，SSH是可以對數據進行壓縮的。

SSH安裝詳解

SSH是安全外殼協議，而open-ssh則是SSH的開源實現，CentOS通常是默認安裝了open-ssh的。

整個SSH服務是包含SSH服務端(openssh-server)和SSH客戶端(openssh-clients)的，常用的ssh命令就是客戶端一部分。

SSH服務端與SSH客戶端之間的關係：節點A想要控制節點B，則節點A上需要安裝SSH客戶端，而節點B上需要安裝相應的SSH服務端，這樣，節點A才能向節點B發送控制命令和數據。

# 安裝openssh-server
[root@cos1 ~]# yum install -y openssh-server
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.ustc.edu.cn
 * extras: mirrors.ustc.edu.cn
 * updates: mirrors.ustc.edu.cn
Package openssh-server-7.4p1-21.el7.x86_64 already installed and latest version
# 啟動openssh-server
[root@cos1 ~]# systemctl start sshd.service
# 安裝openssh-clients
[root@cos1 ~]# yum install -y openssh-clients
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.ustc.edu.cn
 * extras: mirrors.ustc.edu.cn
 * updates: mirrors.ustc.edu.cn
Package openssh-clients-7.4p1-21.el7.x86_64 already installed and latest version

openssh服務的主配置文件路徑：/etc/ssh/sshd_config。

# SSH-Server常見的配置項
# 如果SSH連接提示端口不可用，可以在改文件中查看SSH端口，端口沒問題，就要考慮SSH服務是否正常啟動了
# SSH客戶端與服務端連接的默認端口號
Port 22

默認情況下，SSH服務提供了以下兩個非常有用的功能：

1、類似Telnet遠程連接服務器功能，即SSH服務（安全可靠的遠程登錄會話服務）

# 遠程連接服務
ssh user@hostname/ip

2、類似FTP的sftp-server服務，藉助SSH協議來傳輸數據，提供更安全的SFTP服務(vsftp, proftp).

# 文件拷貝服務
scp files user@hostname:/path/

SSH免密登錄配置

​ 對於分佈式環境組件（例如，Hadoop，HBase等）來說，組件的主/從節點通常需要遠程登錄到集群中其他節點並執行Shell命令，如果不使用SSH，則集群安全就無法保證，使用SSH服務的話，又需要用戶輸入目標服務器的免密，而主/從節點何時訪問其他節點是不可控的，而且，頻繁的需要用戶輸入密碼也是不可行的，這時候，免密登錄就非常重要的。

主機A通過SSH實現免密登錄主機B所需的配置過程大致可以分為以下兩步：

1、主機A在本地通過加密算法生成公鑰和私鑰

通過rsa算法生成公鑰和私鑰key對，默認情況下，身份驗證信息（也就是私鑰）保存在/user/.ssh/id_rsa文件下，而公鑰信息則保存在/user/.ssh/id_rsa.pub文件中。

[root@cos1 .ssh]# pwd
/root/.ssh
[root@cos1 .ssh]# ll
total 8
-rw-------. 1 root root 1679 Jun 22 00:04 id_rsa
-rw-r--r--. 1 root root  391 Jun 22 00:04 id_rsa.pub

2、將主機A的公鑰拷貝到主機B的授權文件(authorized_keys)中

# 通過ssh-copy-id命令將本地服務器公鑰上傳到指定服務器
[root@cos1 ~]# ssh-copy-id root@cos
... ... ... ... ... ... 
Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'root@cos'"
and check to make sure that only the key(s) you wanted were added.
# 現在，可以通過ssh root@cos訪問主機cos了
[root@cos1 ~]# ssh root@cos
Last login: Thu Jun 18 06:38:25 2020 from 192.168.58.1
[root@cos ~]# 

為了安全起見，通常將保存具體哪些主機可以免密訪問當前主機的授權文件authorized_keys文件設置為及root具有查看和修改的權限，用戶組及其他人無權訪問。

通過ssh-copy-id將主機A的公鑰拷貝到主機B之後，本質上，是在主機B的授權文件中添加了主機A的公鑰。

[root@cos .ssh]# ll
total 8
-rw-------. 1 root root 781 Jun 22 00:16 authorized_keys
-rw-r--r--. 1 root root 176 Jun 18 07:34 known_hosts

注意：

1、免密登錄，是用戶對用戶的，切換為其他用戶時，仍需要輸入密碼

2、免密登錄是單向的，也就是說，主機A將公鑰拷貝到主機B后，主機A可以免密登錄主機A，而主機B登錄主機A時仍然需要輸入密碼

圖解SSH免密登錄原理

通過上面一頓操作，主機A就可以免密登錄到主機A了，感覺有點神奇，那麼，免密登錄到底是怎麼實現的呢？也就是說，SSH協議又到底是什麼樣子呢？且看下圖分解~

上圖便是整個SSH免密登錄的配置及原理圖：

1、ServerA生成公鑰並上傳到ServerB上

2、Step 1: ServerA發送鏈接請求到ServerB

3、Step 2: ServerB在authorized_key中檢索ServerA的公鑰，隨機生成字符串，隨後利用公鑰對字符串進行加密，併發送給ServerA

4、Step 3: ServerA接收到密文後，利用私鑰進行解密，並將內容以明文的形式發送給ServerB

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

梯度消失問題和梯度爆炸問題，總的來說可以稱為梯度不穩定問題。

【要背住的知識】：用ReLU代替Sigmoid，用BN層，用殘差結構解決梯度消失問題。梯度爆炸問題的話，可以用正則化來限制。sigmoid的導數是【0，0.25】.

出現原因

兩者出現原因都是因為鏈式法則。當模型的層數過多的時候，計算梯度的時候就會出現非常多的乘積項。用下面這個例子來理解：

這是每層只有1個神經元的例子，每個神經元的激活函數都是sigmoid，然後我們想要更新b1這個參數。
按照大家都公認的符號來表示：

• \(w_1\*x_1 + b_1 = z_1\)這就是z的含義；
• \(\sigma(z_1)=a_1\),這是a的含義。

可以得到這個偏導數：
\(\frac{\partial C}{\partial b_1} = \frac{\partial z_1}{\partial b_1}\frac{\partial a_1}{\partial z_1} \frac{\partial z_2}{\partial a_2}\frac{\partial a_2}{\partial z_2} \frac{\partial z_2}{\partial a_3}\frac{\partial a_3}{\partial z_3} \frac{\partial z_3}{\partial a_4}\frac{\partial a_4}{\partial z_4} \frac{\partial C}{\partial a_4}\)

然後化簡：
\(\frac{\partial C}{\partial b_1}=\sigma'(z_1)w_2\sigma'(z_2)w_3\sigma'(z_3)w_4\sigma'(z_4)\frac{\partial C}{\partial a_4}\)

關鍵在於這個\(\sigma'(z_1)\)，sigmoid函數的導數，是在0~0.25這個區間的，這意味着，當網絡層數越深，那麼對於前面幾層的梯度，就會非常的小。下圖是sigmoid函數的導數的函數圖：

因此經常會有這樣的現象：

圖中，分別表示4層隱含層的梯度變化幅度。可以看到，最淺的那個隱含層，梯度更新的速度，是非常小的。【圖中縱軸是指數變化的】。

那麼梯度爆炸也很好理解，就是\(w_j\sigma'(z_j)>1\)，這樣就爆炸了。
【注意：如果激活函數是sigmoid，那麼其導數最大也就0.25，而\(w_j\)一般不會大於4的，所以sigmoid函數而言，一般都是梯度消失問題】

【總結】：

1. 梯度消失和梯度爆炸是指前面幾層的梯度，因為鏈式法則不斷乘小於（大於）1的數，導致梯度非常小（大）的現象；
2. sigmoid導數最大0.25，一般都是梯度消失問題。

解決方案

更換激活函數

最常見的方案就是更改激活函數，現在神經網絡中，除了最後二分類問題的最後一層會用sigmoid之外，每一層的激活函數一般都是用ReLU。

【ReLU】：如果激活函數的導數是1，那麼就沒有梯度爆炸問題了。

【好處】：可以發現，relu函數的導數在正數部分，是等於1的，因此就可以避免梯度消失的問題。
【不好】：但是負數部分的導數等於0，這樣意味着，只要在鏈式法則中某一個\(z_j\)小於0，那麼這個神經元的梯度就是0，不會更新。

【leakyReLU】：在ReLU的負數部分，增加了一定的斜率：

解決了ReLU中會有死神經元的問題。

【elu】:跟LeakyReLU一樣是為了解決死神經元問題，但是增加的斜率不是固定的：

但是相比leakrelu，計算量更大。

batchnorm層

這個是非常給力的成功，在圖像處理中必用的層了。BN層提出來的本質就是為了解決反向傳播中的梯度問題。

在神經網絡中，有這樣的一個問題：Internal Covariate Shift。
假設第一層的輸入數據經過第一層的處理之後，得到第二層的輸入數據。這時候，第二層的輸入數據相對第一層的數據分佈，就會發生改變，所以這一個batch，第二層的參數更新是為了擬合第二層的輸入數據的那個分佈。然而到了下一個batch，因為第一層的參數也改變了，所以第二層的輸入數據的分佈相比上一個batch，又不太一樣了。然後第二層的參數更新方向也會發生改變。層數越多，這樣的問題就越明顯。

但是為了保證每一層的分佈不變的話，那麼如果把每一層輸出的數據都歸一化0均值，1方差不就好了？但是這樣就會完全學習不到輸入數據的特徵了。不管什麼數據都是服從標準正太分佈，想想也會覺得有點奇怪。所以BN就是增加了兩個自適應參數，可以通過訓練學習的那種參數。這樣吧每一層的數據都歸一化到\(\beta\)均值，\(\gamma\)標準差的正態分佈上。

【將輸入分佈變成正態分佈，是一種去除數據絕對差異，擴大相對差異的一種行為，所以BN層用在分類上效果的好的。對於Image-to-Image這種任務，數據的絕對差異也是非常重要的，所以BN層可能起不到相應的效果。】

殘差結構

殘差結構，簡單的理解，就是讓深層網絡通過走捷徑，讓網絡不那麼深層。這樣梯度消失的問題就緩解了。

正則化

之前提到的梯度爆炸問題，一般都是因為\(w_j\)過大造成的，那麼用L2正則化就可以解決問題。

喜歡的話請關注我們的微信公眾號~【你好世界煉丹師】。

• 公眾號主要講統計學，數據科學，機器學習，深度學習，以及一些參加Kaggle競賽的經驗。
• 公眾號內容建議作為課後的一些相關知識的補充，飯後甜點。
• 此外，為了不過多打擾，公眾號每周推送一次，每次4~6篇精選文章。

微信搜索公眾號：你好世界煉丹師。期待您的關注。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※新北清潔公司,居家、辦公、裝潢細清專業服務

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

Django rest framework源碼分析（3）—-節流

添加節流

自定義節流的方法

• 限制60s內只能訪問3次

（1）API文件夾下面新建throttle.py，代碼如下：

# utils/throttle.py

from rest_framework.throttling import BaseThrottle
import time
VISIT_RECORD = {}   #保存訪問記錄

class VisitThrottle(BaseThrottle):
    '''60s內只能訪問3次'''
    def __init__(self):
        self.history = None   #初始化訪問記錄

    def allow_request(self,request,view):
        #獲取用戶ip (get_ident)
        remote_addr = self.get_ident(request)
        ctime = time.time()
        #如果當前IP不在訪問記錄裏面，就添加到記錄
        if remote_addr not in VISIT_RECORD:
            VISIT_RECORD[remote_addr] = [ctime,]     #鍵值對的形式保存
            return True    #True表示可以訪問
        #獲取當前ip的歷史訪問記錄
        history = VISIT_RECORD.get(remote_addr)
        #初始化訪問記錄
        self.history = history

        #如果有歷史訪問記錄，並且最早一次的訪問記錄離當前時間超過60s，就刪除最早的那個訪問記錄，
        #只要為True，就一直循環刪除最早的一次訪問記錄
        while history and history[-1] < ctime - 60:
            history.pop()
        #如果訪問記錄不超過三次，就把當前的訪問記錄插到第一個位置（pop刪除最後一個）
        if len(history) < 3:
            history.insert(0,ctime)
            return True

    def wait(self):
        '''還需要等多久才能訪問'''
        ctime = time.time()
        return 60 - (ctime - self.history[-1])

（2）settings中全局配置節流

#全局
REST_FRAMEWORK = {
    #節流
    "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.VisitThrottle'],
}

（3）現在訪問auth看看結果：

• 60s內訪問次數超過三次，會限制訪問
• 提示剩餘多少時間可以訪問

接着訪問

節流源碼分析

（1）dispatch

def dispatch(self, request, *args, **kwargs):
    """
    `.dispatch()` is pretty much the same as Django's regular dispatch,
    but with extra hooks for startup, finalize, and exception handling.
    """
    self.args = args
    self.kwargs = kwargs
    #對原始request進行加工，豐富了一些功能
    #Request(
    #     request,
    #     parsers=self.get_parsers(),
    #     authenticators=self.get_authenticators(),
    #     negotiator=self.get_content_negotiator(),
    #     parser_context=parser_context
    # )
    #request(原始request,[BasicAuthentications對象，])
    #獲取原生request,request._request
    #獲取認證類的對象，request.authticators
    #1.封裝request
    request = self.initialize_request(request, *args, **kwargs)
    self.request = request
    self.headers = self.default_response_headers  # deprecate?

    try:
        #2.認證
        self.initial(request, *args, **kwargs)

        # Get the appropriate handler method
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed

        response = handler(request, *args, **kwargs)

    except Exception as exc:
        response = self.handle_exception(exc)

    self.response = self.finalize_response(request, response, *args, **kwargs)
    return self.response

（2）initial

def initial(self, request, *args, **kwargs):
    """
    Runs anything that needs to occur prior to calling the method handler.
    """
    self.format_kwarg = self.get_format_suffix(**kwargs)

    # Perform content negotiation and store the accepted info on the request
    neg = self.perform_content_negotiation(request)
    request.accepted_renderer, request.accepted_media_type = neg

    # Determine the API version, if versioning is in use.
    version, scheme = self.determine_version(request, *args, **kwargs)
    request.version, request.versioning_scheme = version, scheme

    # Ensure that the incoming request is permitted
    #4.實現認證
    self.perform_authentication(request)
    #5.權限判斷
    self.check_permissions(request)
    #6.控制訪問頻率
    self.check_throttles(request)

（3）check_throttles

裏面有個allow_request

def check_throttles(self, request):
    """
    Check if request should be throttled.
    Raises an appropriate exception if the request is throttled.
    """
    for throttle in self.get_throttles():
        if not throttle.allow_request(request, self):
            self.throttled(request, throttle.wait())

（4）get_throttles

def get_throttles(self):
    """
    Instantiates and returns the list of throttles that this view uses.
    """
    return [throttle() for throttle in self.throttle_classes]

（5）thtottle_classes

內置節流類

上面是寫的自定義節流，drf內置了很多節流的類，用起來比較方便。

（1）BaseThrottle

• 自己要寫allow_request和wait方法
• get_ident就是獲取ip

class BaseThrottle(object):
    """
    Rate throttling of requests.
    """

    def allow_request(self, request, view):
        """
        Return `True` if the request should be allowed, `False` otherwise.
        """
        raise NotImplementedError('.allow_request() must be overridden')

    def get_ident(self, request):
        """
        Identify the machine making the request by parsing HTTP_X_FORWARDED_FOR
        if present and number of proxies is > 0. If not use all of
        HTTP_X_FORWARDED_FOR if it is available, if not use REMOTE_ADDR.
        """
        xff = request.META.get('HTTP_X_FORWARDED_FOR')
        remote_addr = request.META.get('REMOTE_ADDR')
        num_proxies = api_settings.NUM_PROXIES

        if num_proxies is not None:
            if num_proxies == 0 or xff is None:
                return remote_addr
            addrs = xff.split(',')
            client_addr = addrs[-min(num_proxies, len(addrs))]
            return client_addr.strip()

        return ''.join(xff.split()) if xff else remote_addr

    def wait(self):
        """
        Optionally, return a recommended number of seconds to wait before
        the next request.
        """
        return None

（2）SimpleRateThrottle

class SimpleRateThrottle(BaseThrottle):
    """
    A simple cache implementation, that only requires `.get_cache_key()`
    to be overridden.

    The rate (requests / seconds) is set by a `rate` attribute on the View
    class.  The attribute is a string of the form 'number_of_requests/period'.

    Period should be one of: ('s', 'sec', 'm', 'min', 'h', 'hour', 'd', 'day')

    Previous request information used for throttling is stored in the cache.
    """
    cache = default_cache
    timer = time.time
    cache_format = 'throttle_%(scope)s_%(ident)s'
    scope = None   #這個值自定義，寫什麼都可以
    THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES

    def __init__(self):
        if not getattr(self, 'rate', None):
            self.rate = self.get_rate()
        self.num_requests, self.duration = self.parse_rate(self.rate)

    def get_cache_key(self, request, view):
        """
        Should return a unique cache-key which can be used for throttling.
        Must be overridden.

        May return `None` if the request should not be throttled.
        """
        raise NotImplementedError('.get_cache_key() must be overridden')

    def get_rate(self):
        """
        Determine the string representation of the allowed request rate.
        """
        if not getattr(self, 'scope', None):
            msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
                   self.__class__.__name__)
            raise ImproperlyConfigured(msg)

        try:
            return self.THROTTLE_RATES[self.scope]
        except KeyError:
            msg = "No default throttle rate set for '%s' scope" % self.scope
            raise ImproperlyConfigured(msg)

    def parse_rate(self, rate):
        """
        Given the request rate string, return a two tuple of:
        <allowed number of requests>, <period of time in seconds>
        """
        if rate is None:
            return (None, None)
        num, period = rate.split('/')
        num_requests = int(num)
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        return (num_requests, duration)

    def allow_request(self, request, view):
        """
        Implement the check to see if the request should be throttled.

        On success calls `throttle_success`.
        On failure calls `throttle_failure`.
        """
        if self.rate is None:
            return True

        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True

        self.history = self.cache.get(self.key, [])
        self.now = self.timer()

        # Drop any requests from the history which have now passed the
        # throttle duration
        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        if len(self.history) >= self.num_requests:
            return self.throttle_failure()
        return self.throttle_success()

    def throttle_success(self):
        """
        Inserts the current request's timestamp along with the key
        into the cache.
        """
        self.history.insert(0, self.now)
        self.cache.set(self.key, self.history, self.duration)
        return True

    def throttle_failure(self):
        """
        Called when a request to the API has failed due to throttling.
        """
        return False

    def wait(self):
        """
        Returns the recommended next request time in seconds.
        """
        if self.history:
            remaining_duration = self.duration - (self.now - self.history[-1])
        else:
            remaining_duration = self.duration

        available_requests = self.num_requests - len(self.history) + 1
        if available_requests <= 0:
            return None

        return remaining_duration / float(available_requests)

我們可以通過繼承SimpleRateThrottle類，來實現節流，會更加的簡單，因為SimpleRateThrottle裏面都幫我們寫好了

（1）throttle.py

from rest_framework.throttling import SimpleRateThrottle

class VisitThrottle(SimpleRateThrottle):
    '''匿名用戶60s只能訪問三次（根據ip）'''
    scope = 'NBA'   #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate

    def get_cache_key(self, request, view):
        #通過ip限制節流
        return self.get_ident(request)

class UserThrottle(SimpleRateThrottle):
    '''登錄用戶60s可以訪問10次'''
    scope = 'NBAUser'    #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate

    def get_cache_key(self, request, view):
        return request.user.username

（2）settings.py

#全局
REST_FRAMEWORK = {
    #節流
    "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'],   #全局配置，登錄用戶節流限制（10/m）
    "DEFAULT_THROTTLE_RATES":{
        'NBA':'3/m',         #沒登錄用戶3/m，NBA就是scope定義的值
        'NBAUser':'10/m',    #登錄用戶10/m，NBAUser就是scope定義的值
    }
}

（3）views.py

局部配置方法

class AuthView(APIView):
    .
    .    
    .
    # 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
    throttle_classes = [VisitThrottle,]　 　.    .

# views.py
from django.shortcuts import render,HttpResponse
from django.http import JsonResponse
from rest_framework.views import APIView
from API import models
from rest_framework.request import Request
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication
from API.utils.permission import SVIPPremission,MyPremission
from API.utils.throttle import  VisitThrottle

ORDER_DICT = {
    1:{
        'name':'apple',
        'price':15
    },
    2:{
        'name':'dog',
        'price':100
    }
}

def md5(user):
    import hashlib
    import time
    #當前時間，相當於生成一個隨機的字符串
    ctime = str(time.time())
    m = hashlib.md5(bytes(user,encoding='utf-8'))
    m.update(bytes(ctime,encoding='utf-8'))
    return m.hexdigest()


class AuthView(APIView):
    '''用於用戶登錄驗證'''

    authentication_classes = []      #裏面為空，代表不需要認證
    permission_classes = []          #不裏面為空，代表不需要權限
    # 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
    throttle_classes = [VisitThrottle,]

    def post(self,request,*args,**kwargs):
        ret = {'code':1000,'msg':None}
        try:
            user = request._request.POST.get('username')
            pwd = request._request.POST.get('password')
            obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
            if not obj:
                ret['code'] = 1001
                ret['msg'] = '用戶名或密碼錯誤'
            #為用戶創建token
            token = md5(user)
            #存在就更新，不存在就創建
            models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
            ret['token'] = token
        except Exception as e:
            ret['code'] = 1002
            ret['msg'] = '請求異常'
        return JsonResponse(ret)


class OrderView(APIView):
    '''
    訂單相關業務(只有SVIP用戶才能看)
    '''

    def get(self,request,*args,**kwargs):
        self.dispatch
        #request.user
        #request.auth
        ret = {'code':1000,'msg':None,'data':None}
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)


class UserInfoView(APIView):
    '''
       訂單相關業務(普通用戶和VIP用戶可以看)
       '''
    permission_classes = [MyPremission,]    #不用全局的權限配置的話，這裏就要寫自己的局部權限
    def get(self,request,*args,**kwargs):

        print(request.user)
        return HttpResponse('用戶信息')

說明：

• API.utils.throttle.UserThrottle 這個是全局配置（根據ip限制，10/m）
• DEFAULT_THROTTLE_RATES —>>>設置訪問頻率的
• throttle_classes = [VisitThrottle,] —>>>局部配置（不適用settings裏面默認的全局配置）

總結

基本使用

• 創建類，繼承BaseThrottle, 實現：allow_request ，wait
• 創建類，繼承SimpleRateThrottle, 實現： get_cache_key， scope=’NBA’ (配置文件中的key)

全局

   #節流
    "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'],   #全局配置，登錄用戶節流限制（10/m）
    "DEFAULT_THROTTLE_RATES":{
        'NBA':'3/m',         #沒登錄用戶3/m，NBA就是scope定義的值
        'NBAUser':'10/m',    #登錄用戶10/m，NBAUser就是scope定義的值
    }
}

局部

throttle_classes = [VisitThrottle,]

所有代碼

認證、權限和節流

# MyProject/urls.py

from django.contrib import admin
from django.urls import path
from API.views import AuthView,OrderView,UserInfoView

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/auth/',AuthView.as_view()),
    path('api/v1/order/',OrderView.as_view()),
    path('api/v1/info/',UserInfoView.as_view()),
]

#全局 settings.py
REST_FRAMEWORK = {
    #認證
    "DEFAULT_AUTHENTICATION_CLASSES":['API.utils.auth.Authentication',],
    #權限
    "DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPermission'],
    #節流
    "DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'],   #全局配置，登錄用戶節流限制（10/m）
    "DEFAULT_THROTTLE_RATES":{
        'NBA':'3/m',         #沒登錄用戶3/m，NBA就是scope定義的值
        'NBAUser':'10/m',    #登錄用戶10/m，NBAUser就是scope定義的值
    }
}

# API/models.py


from django.db import models

class UserInfo(models.Model):
    USER_TYPE = (
        (1,'普通用戶'),
        (2,'VIP'),
        (3,'SVIP')
    )

    user_type = models.IntegerField(choices=USER_TYPE)
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=64)

class UserToken(models.Model):
    user = models.OneToOneField(UserInfo,on_delete=models.CASCADE)
    token = models.CharField(max_length=64)

# API/views.py

from django.shortcuts import render,HttpResponse
from django.http import JsonResponse
from rest_framework.views import APIView
from API import models
from rest_framework.request import Request
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication
from API.utils.permission import SVIPPermission,MyPermission
from API.utils.throttle import  VisitThrottle

ORDER_DICT = {
    1:{
        'name':'apple',
        'price':15
    },
    2:{
        'name':'dog',
        'price':100
    }
}

def md5(user):
    import hashlib
    import time
    #當前時間，相當於生成一個隨機的字符串
    ctime = str(time.time())
    m = hashlib.md5(bytes(user,encoding='utf-8'))
    m.update(bytes(ctime,encoding='utf-8'))
    return m.hexdigest()


class AuthView(APIView):
    '''用於用戶登錄驗證'''

    authentication_classes = []      #裏面為空，代表不需要認證
    permission_classes = []          #不裏面為空，代表不需要權限
    # 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
    throttle_classes = [VisitThrottle,]

    def post(self,request,*args,**kwargs):
        ret = {'code':1000,'msg':None}
        try:
            user = request._request.POST.get('username')
            pwd = request._request.POST.get('password')
            obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
            if not obj:
                ret['code'] = 1001
                ret['msg'] = '用戶名或密碼錯誤'
            #為用戶創建token
            token = md5(user)
            #存在就更新，不存在就創建
            models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
            ret['token'] = token
        except Exception as e:
            ret['code'] = 1002
            ret['msg'] = '請求異常'
        return JsonResponse(ret)


class OrderView(APIView):
    '''
    訂單相關業務(只有SVIP用戶才能看)
    '''

    def get(self,request,*args,**kwargs):
        self.dispatch
        #request.user
        #request.auth
        ret = {'code':1000,'msg':None,'data':None}
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)


class UserInfoView(APIView):
    '''
       訂單相關業務(普通用戶和VIP用戶可以看)
       '''
    permission_classes = [MyPermission,]    #不用全局的權限配置的話，這裏就要寫自己的局部權限
    def get(self,request,*args,**kwargs):

        print(request.user)
        return HttpResponse('用戶信息')

# API/utils/auth/py

from rest_framework import exceptions
from API import models
from rest_framework.authentication import BaseAuthentication


class Authentication(BaseAuthentication):
    '''用於用戶登錄驗證'''
    def authenticate(self,request):
        token = request._request.GET.get('token')
        token_obj = models.UserToken.objects.filter(token=token).first()
        if not token_obj:
            raise exceptions.AuthenticationFailed('用戶認證失敗')
        #在rest framework內部會將這兩個字段賦值給request，以供後續操作使用
        return (token_obj.user,token_obj)

    def authenticate_header(self, request):
        pass

# utils/permission.py

from rest_framework.permissions import BasePermission

class SVIPPermission(BasePermission):
    message = "必須是SVIP才能訪問"
    def has_permission(self,request,view):
        if request.user.user_type != 3:
            return False
        return True


class MyPermission(BasePermission):
    def has_permission(self,request,view):
        if request.user.user_type == 3:
            return False
        return True

# utils/throttle.py
#
# from rest_framework.throttling import BaseThrottle
# import time
# VISIT_RECORD = {}   #保存訪問記錄
#
# class VisitThrottle(BaseThrottle):
#     '''60s內只能訪問3次'''
#     def __init__(self):
#         self.history = None   #初始化訪問記錄
#
#     def allow_request(self,request,view):
#         #獲取用戶ip (get_ident)
#         remote_addr = self.get_ident(request)
#         ctime = time.time()
#         #如果當前IP不在訪問記錄裏面，就添加到記錄
#         if remote_addr not in VISIT_RECORD:
#             VISIT_RECORD[remote_addr] = [ctime,]     #鍵值對的形式保存
#             return True    #True表示可以訪問
#         #獲取當前ip的歷史訪問記錄
#         history = VISIT_RECORD.get(remote_addr)
#         #初始化訪問記錄
#         self.history = history
#
#         #如果有歷史訪問記錄，並且最早一次的訪問記錄離當前時間超過60s，就刪除最早的那個訪問記錄，
#         #只要為True，就一直循環刪除最早的一次訪問記錄
#         while history and history[-1] < ctime - 60:
#             history.pop()
#         #如果訪問記錄不超過三次，就把當前的訪問記錄插到第一個位置（pop刪除最後一個）
#         if len(history) < 3:
#             history.insert(0,ctime)
#             return True
#
#     def wait(self):
#         '''還需要等多久才能訪問'''
#         ctime = time.time()
#         return 60 - (ctime - self.history[-1])

from rest_framework.throttling import SimpleRateThrottle

class VisitThrottle(SimpleRateThrottle):
    '''匿名用戶60s只能訪問三次（根據ip）'''
    scope = 'NBA'   #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate

    def get_cache_key(self, request, view):
        #通過ip限制節流
        return self.get_ident(request)

class UserThrottle(SimpleRateThrottle):
    '''登錄用戶60s可以訪問10次'''
    scope = 'NBAUser'    #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate

    def get_cache_key(self, request, view):
        return request.user.username

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※教你寫出一流的銷售文案?

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

※產品缺大量曝光嗎?你需要的是一流包裝設計!