簡介

說到OSI參考模型，理解網絡與網絡之間的關係，不說太深入難以理解的東西，只求能最大程度上理解與使用。

參考模型是國際標準化組織（ISO）制定的一個用於計算機或通信系統間互聯的標準體系，一般稱為OSI參考模型或七層模型。

概念性的東西，先知道這些就夠了，我們先來聊一聊一個常見的一個模型。

 

局域網與互聯網

互聯網就是許許多多個局域網組成的，從我們最簡單的一個局域網入手，開始理解

這裏舉例兩個不同的局域網，計算機用網線接入交換機、交換機連接網關路由器，另一處

也是通過相同的方式進行連接。先來了解一下OSI參考模型是如何定義這七層的

OSI 參考模型

參考：

這裏定義的七層只是為了方便我們去理解，實際上是不存在的。

簡單的了解一下這七層是如何定義的，具體的功能還是得舉例子來理解說明。

從最上層的應用層開始說起：如何一步步的封裝數據，到最後進行發送。

應用層

應用層是直接面向用戶的最高層，但它卻不是應用程序，它只是為引用程序提供服務的

就好比，我們用的電腦版微信吧！它就是一個實實在在的應用程序，假設要與一個遠方的小姐姐進行聊天會話，這個時候呢，發送一個Hello給遠方的小姐姐。

當你點擊發送的時候，其實做了很多事情，我們就來梳理一下。

需要發送的數據就是：Hello ,當然，應用層首先給這個數據拼接一個AH,這裏就是應用層的報頭，就好比是微信的一個特有的數據，就這樣先理解。

 

表示層

當然，我們總不能發送明文吧，將發送的文本數據進行編碼，平常我們計算機使用的萬國碼UTF-8,肯定要進行一下加密吧

表示層更關心的是所傳送數據的語法和語義，主要包括數據格式變化、與解密、與解壓等

 

會話層

字面意思，就可以理解出這一層表示的意思，建立一個會話，就好比使用Http訪問web的時候，都會存在一個Session 作為標識

讓服務器來區別訪問的計算機。主要功能是負責維護兩個節點之間的傳輸聯接，確保點到點傳輸不中斷，以及管理數據交換等功能。

會話層在應用進程中建立、管理和終止會話。會話層還可以通過對話控制來決定使用何種通信方式，通信或通信。會話層通過自身協議對請求與應答進行協調

 

傳輸層 端到端

傳輸層作為OSI參考模型中，最重要的一層，這裏主要是以端口到端口來區分。這裏涉及到兩個特別重要的協議TCP 以及UDP

一太計算機上同時運行着QQ、微信、以及瀏覽器等。發送數據報，這個數據包到底是哪個程序發出去的呢？當然要從指定的一個端口發出去

計算機的端口範圍 0-65535

0-1023 就是1024個端口為系統佔用端口

了解到這些，就該先來說說UDP協議

UDP 協議

UDP協議定義了端口，同一個主機上的每個應用程序都需要指定唯一的端口號，並且規定網絡中傳輸的數據包必須加上端口信息，當數據包到達主機以後，就可以根據端口號找到對應的應用程序了。UDP協議比較簡單，實現容易，但它沒有確認機制，數據包一旦發出，無法知道對方是否收到，因此可靠性較差，為了解決這個問題，提高網絡可靠性，TCP協議就誕生了。

 

參考：

一個UDP報文包含首部與數據部分，UDP首部佔用8個字節，數據部分最長長度為65535B（字節） 即 64KB

UDP協議是無連接，不保證穩定傳輸的協議，但處理速度較快，通常的音頻、視頻在傳送時候使用UDP較多。

我們這裏的例子是微信，微信能保證數據百分百到達，所以我們採用TCP來具體說明數據的封裝

 

TCP 協議

TCP即傳輸控制協議，是一種面向連接的、可靠的、基於字節流的通信協議。簡單來說TCP就是有確認機制的UDP協議，每發出一個數據包都要求確認，如果有一個數據包丟失，就收不到確認，發送方就必須重發這個數據包。為了保證傳輸的可靠性，TCP協議在UDP基礎之上建立了三次對話的確認機制，即在正式收發數據前，必須和對方建立可靠的連接。TCP數據包和UDP一樣，都是由首部和數據兩部分組成，唯一不同的是，TCP數據包沒有長度限制，理論上可以無限長，但是為了保證網絡的效率，通常TCP數據包的長度不會超過IP數據包的長度，以確保單個TCP數據包不必再分割

 

參考：

 這裏只需要了解的是TCP的基本封裝過程，這裏只涉及到源端口以及目的端口，還未涉及到IP相關的內容。它和UDP協議一樣。就好像是一個改進版的

UDP協議，它能保證數據的可靠傳輸，這個特點記住即可。這裏模擬一下，我們數據的封裝過程。假設微信使用的端口是6666，目標端口就是遠方小姐姐微信

的端口，當然也是一樣的。這裏我為了理解只做簡寫

 

網絡層

從上面幾層來看，我們已經將微信的數據封裝成來一個TCP數據報，裡面包含來微信的端口 假設是6666，當然，就好比寫信一樣，我的信封

已經準備好勒，裏面要發送的內容我也已經準備好了，接下來就是地址了。肯定要指定這個報文我要發送到哪裡去。所以呢IP 網際協議，就誕生了。

IP 網際協議

網絡層引入了IP協議，制定了一套新地址，使得我們能夠區分兩台主機是否同屬一個網絡，這套地址就是網絡地址，也就是所謂的IP地址。IP協議將這個32位的地址分為兩部分，前面部分代表網絡地址，後面部分表示該主機在局域網中的地址。如果兩個IP地址在同一個子網內，則網絡地址一定相同。為了判斷IP地址中的網絡地址，IP協議還引入了子網掩碼，IP地址和子網掩碼通過按位與運算后就可以得到網絡地址

IP地址在這裏我們就比較好理解了。我們平時的生活中都會涉及到。一個IP指向的就是互聯網當中的一台機器或者就是一台路由器了。

我們來封裝數據。再把上面的圖拿下來，說明一下，我們要給E電腦的小姐姐發送消息。比如我是A電腦，小姐姐在另外一個網關下的E電腦

 

 

比較重要的兩個參數：

源地址：192.168.0.120

目標地址：192.168.1.135

進行封裝后的數據，這裏將源地址，告訴路由器（郵局） 發件人 就是源地址，以及收件人 也就是目標地址

 

ARP 協議

這裏暫時不細說這個ARP協議的內容。我們只需要知道 ARP協議是用來拿IP換MAC地址的，上面的IP協議也已經提過了，通過子網掩碼和IP地址的換算，可以得到

網絡號，網絡號就可以區別這兩個IP是否在同一個局域網內。 參考這個秒懂：

數據鏈路層

到這一層，就已經到網卡、網絡設備（交換機）的範疇了。數據鏈路層最重要的協議是以太網協議，數據鏈路層最重要的一點就是數據成幀。

以太網協議

接入以太網的設備必須包含一塊以太網網卡，也就是我們常用的網卡，一組電信號稱作是一個數據幀 、或者叫做一個數據包

網卡都包含一個全球唯一的MAC地址，發送端的和接收端的地址便是指網卡的地址，即Mac地址。 

每塊網卡出廠時都被燒錄上一個實際上唯一的Mac地址，長度為48位2進制，通常由12位16進制數表示，（前六位是廠商編碼，后六位是流水線號）

 進行數據鏈路層的封裝，將本機的MAC(源MAC地址) 和目標MAC地址封裝在頭部，在尾部加入DT報尾，這樣 一個數據幀算是封裝完成了！

等等。我們好像還不知道小姐姐那邊的目標MAC地址，這時候就需要用ARP協議了。我們知道ARP協議就是用來用IP來換MAC地址的。

 

ARP協議

上面已經簡單的了解過了，我們要和在B局域網下的E電腦進行通信，但是我們不知道它的MAC地址，於是我們發送一個ARP請求，來獲取目標的MAC地址

目標MAC 為FF:FF:FF:FF:FF:FF 表示的是廣播地址，這個數據包發出去后，所有的子網機器都會收到，收到的機器判斷目標MAC是否是自己，若不是，則直接丟棄

若是，收到報文的主機會通過單播的形式，將MAC地址回傳給我們。

通過路由協議我們可以得知，若不在一個一個子網內，則會交給路由器

 路由器返回的包裏面，目標MAC就會變成路由器的MAC地址，我們拿路由器的MAC地址組裝數據鏈路層報文即可。

物理層 

經過以上的每一層的層層包裝，這時候，我們已經包裝好了一個以太網數據幀，包含源MAC，目標MAC，源IP,目標IP等等一系列數據。

物理層就是將這個數據通過電信號、光信號的方式傳遞過去的，物理層一般都是我么所說的光纜以及網線這些硬件設備。

 

 

 不同子網間的通信

通過上面的知識，我們已經了解到如何封裝成一個數據幀，以及一些協議的相關內容。那麼這裏就會有一個問題，同一子網、

不同子網、以及相隔很遠的兩個子網是如何進行通信的呢？以及我們撥號上網后，公網IP與內網IP是怎麼一回事呢？

 

同一子網通信

我們先來看一個圖，計算機A要與計算機B進行通信，這時候他們是同處於一個子網內的，這個時候就很簡單了。

按照上面的七層進行封裝數據，這裏的具體參數需要說明一下：

源IP: 0.120（簡寫）

目標IP:0.113

源MAC : A電腦的MAC

目標MAC:B電腦MAC(這裏若不知道就先發送ARP請求)

 

 

A將數據報發送出去后，交換機直接查詢目標MAC所轉發的端口，將這個數據報準確的推送到B電腦連接的那個端口即可。

不同子網通信

A電腦需要與E電腦進行通信，這時候發現A與E不在一個子網內，這時候呢，就需要路由器來協助了

源IP: A的IP

目標IP: E的IP

源MAC:A的 MAC

目標MAC: 路由器C的MAC

 

 

因為不在一個子網內，需要路由器來進行路由這個數據包，送至D路由器后，D路由器拿出數據報中目標的IP,發送ARP請求，

請求E的MAC地址，知道后，將數據報裏面的目標MAC進行替換，然後發送給E即可。

 

公網IP與內網IP通信的方式理解

我們在使用路由器上網后，運營商就會給我們分配一個公網IP,按照圖上的指示，C路由器在進行撥號后，就會給C路由器分配一個公網IP

我這裏假設有這樣兩個。這時候需要封裝數據，該如何封裝呢，還是以A電腦與E電腦進行通信，大家肯定會很迷惑。

這裏就需要了解一個協議：網路地址轉換協議：

以下簡稱NAT，NAT 在IPV4 之前起到很大的作用，我們現在也在用，因為IPV4 IP數量的限制，但接入互聯網的電腦又那麼多

該怎麼辦呢。就是給一個路由下分配一個公網IP,路由器下面的IP與公網IP進行一個轉換，這裏面說的轉換就是：NAT

圖中黑色的就是轉換部分，通過端口的轉換，將多個子網IP映射到公網的一個IP上面

 

網絡地址端口轉換（NAPT）

這種方式支持端口的映射，並允許多台主機共享一個公網IP地址。 支持端口轉換的NAT又可以分為兩類：源地址轉換和目的地址轉換。前一種情形下發起連接的計算機的IP地址將會被重寫，使得內網主機發出的數據包能夠到達外網主機。后一種情況下被連接計算機的IP地址將被重寫，使得外網主機發出的數據包能夠到達內網主機。實際上，以上兩種方式通常會一起被使用以支持雙向通信。 還是舉例，這時候，我們的A電腦需要與E電腦進行通信，E電腦在廣東省，他們撥號后，都會分配一個公網IP，並且已經在路由器裏面完成了NAT映射，
源IP: A電腦IP
目標IP: E電腦映射后的公網IP
源MAC ：A電腦MAC
目標MAC :  本地路由器MAC地址   封裝完成后，將數據報送到C路由器，路由器通過映射表，將源IP進行一個替換

 

替換后，交給互聯網上的路由器進行數據報的轉發，這就好像發快遞時候一樣，經過一系列的中轉站，到達目的路由。

到達D路由后，D路由將數據報中的目標地址也進行一個轉換，這個地址是可以相互轉的。現在就是公網映射轉到本機IP

 

轉換后就輕鬆了。按照ARP請求到E機器的MAC地址，然後發報即可。

 

小結

以上內容皆是自己查看一些博主的總結，通過學習后，能夠加深自己對OIS模型、以及TCP、IP、ARP

這些非常重要的協議的一個認識。以及了解到不同層級下面。兩台電腦如何完成一個通行。這裏講的比較淺，

互聯網的奧妙不是那麼容易就可以理解透的。還是那句，不要停止學習的腳步。就好

 

參考：

• ARP請求 
• 不同子網內兩台機器的通信方式 
• OSI 參考模型 
• 內網端口與外網端口的理解 
• 網絡地址轉換協議：

 

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

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

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

11月19日，業界應用最為廣泛的Kubernetes管理平台創建者Rancher Labs（以下簡稱Rancher）宣布Rio發布了beta版本，這是基於Kubernetes的應用程序部署引擎。它於今年5月份推出，現在最新的版本是v0.6.0。Rio結合了多種雲原生技術，從而簡化了將代碼從測試環境發布到生產環境的流程，同時保證了強大而安全的代碼體驗。

什麼是Rio？

下圖是Rio的架構：

Rio採用了諸如Kubernetes、knative、linkerd、cert-manager、buildkit以及gloo等技術，並將它們結合起來為用戶提供一個完整的應用程序部署環境。

Rio具有以下功能：

1. 從源代碼構建代碼，並將其部署到Kubernetes集群

2. 自動為應用程序創建DNS記錄，並使用Let’s Encrypt的TLS證書保護這些端點

3. 基於QPS以及工作負載的指標自動擴縮容

4. 支持金絲雀發布、藍綠髮布以及A/B部署

5. 支持通過服務網格路由流量

6. 支持縮容至零的serverless工作負載

7. Git觸發的部署

Rancher的產品生態

Rio屬於Rancher整套產品生態的一部分，這些產品支持從操作系統到應用程序的應用程序部署和容器運維。當Rio和諸如Rancher 2.3、k3s和RKE等產品結合使用時，企業可以獲得完整的部署和管理應用程序及容器的體驗。

深入了解Rio

要了解Rio如何實現上述功能，我們來深入了解一些概念以及工作原理。

安裝Rio

前期準備

• Kubernetes版本在1.15以上的Kubernetes集群

• 為集群配置的kubeconfig（即上下文是你希望將Rio安裝到的集群）

• 在$PATH中安裝的Rio CLI工具，可參閱以下鏈接，了解如何安裝CLI：
  https://github.com/rancher/rio/blob/master/README.md

安裝

使用安裝好的Rio CLI工具，調用rio install。你可能需要考慮以下情況：

ip-address：節點的IP地址的逗號分隔列表。你可以在以下情況使用：

• 你不使用（或不能使用）layer-4的負載均衡器

• 你的節點IP不是你希望流量到達的IP地址（例如，你使用有公共IP的EC2實例）

服 務

在Rio中，service是一個基本的執行單位。從Git倉庫或容器鏡像實例化之後，一個service由單個容器以及服務網格的關聯sidecar組成（默認啟用）。例如，運行使用Golang構建的一個簡單的“hello world”應用程序。

rio run https://github.com/ebauman/rio-demo

或者運行容器鏡像版本：

rio run ebauman/demo-rio:v1

還有其他選項也可以傳遞給rio run，如需要公開的任意端口（-p 80:8080/http），或者自動擴縮的配置（--scale 1-10）。你可以通過這一命令rio help run，查看所有可傳遞的選項。

想要查看你正在運行的服務，請執行rio ps：

$ rio ps
NAME            IMAGE                               ENDPOINT
demo-service    default-demo-service-4dqdw:61825    https://demo-service...

每次你運行一個新的服務，Rio將會為這一服務生成一個全局性的端點：

$ rio endpoints
NAME           ENDPOINTS
demo-service   https://demo-service-default.op0kj0.on-rio.io:30282

請注意，此端點不包括版本——它指向由一個common name標識的服務，並且流量根據服務的權重進行路由。

自動DNS&TLS

默認情況下，所有Rio集群都將為自己創建一個on-rio.io主機名，並以隨機字符串開頭（如lkjsdf.on-rio.io）。該域名成為通配符域名，它的記錄解析到集群的網關。如果使用NodePort服務，則該網關可以是layer-4負載均衡器，或者是節點本身。

除了創建這個通配符域名，Rio還會使用Let’s Encrypt為這個域名生成一個通配符證書。這會允許自動加密任何HTTP工作負載，而無需用戶進行配置。要啟動此功能，請傳遞-p參數，將http指定為協議，例如：

rio run -p 80:8080/http ...

自動擴縮容

Rio可以根據每秒所查詢到的指標自動擴縮服務。為了啟用這一特性，傳遞--scale 1-10作為參數到rio run，例如：

rio run -p 80:8080/http -n demo-service --scale 1-10 ebauman/rio-demo:v1

執行這個命令將會構建ebauman/rio-demo並且部署它。如果我們使用一個工具來添加負載到端點，我們就能夠觀察到自動擴縮容。為了證明這一點，我們需要使用HTTP端點（而不是HTTPS），因為我們使用的工具不支持TLS：

$ rio inspect demo-service
<snipped>
endpoints:
- https://demo-service-v0-default.op0kj0.on-rio.io:30282
- http://demo-service-v0-default.op0kj0.on-rio.io:31976
<snipped>

rio inspect除了端點之外還會显示其他信息，但我們目前所需要的是端點信息。使用HTTP端點以及HTTP基準測試工具rakyll / hey，我們可以添加綜合負載：

hey -n 10000 http://demo-service-v0-default.op0kj0.on-rio.io:31976

這將會發送10000個請求到HTTP端點，Rio將會提高QPS並適當擴大規模，執行另一個rio ps將會展示已經擴大的規模：

$ rio ps
NAME            ...     SCALE       WEIGHT
demo-service    ...     2/5 (40%)   100%

分階段發布、金絲雀部署以及權重

注意

對於每個服務，都會創建一個全局端點，該端點將根據基礎服務的權重路由流量。

Rio可以先交付新的服務版本，然後再推廣到生產環境。分階段發布一個新的版本十分簡單：

rio stage --image ebauman/rio-demo:v2 demo-service v2

這一命令使用版本v2，分階段發布demo-service的新版本，並且使用容器鏡像ebauman/rio-demo:v2。我們通過執行rio ps這一命令，可以看到新階段的發布：

$ rio ps
NAME                IMAGE                   ENDPOINT                    WEIGHT
demo-service@v2     ebauman/rio-demo:v2     https://demo-service-v2...  0%
demo-service        ebauman/rio-demo:v1     https://demo-service-v0...  100%

請注意，新服務的端點具有v2的新增功能，因此即使權重設置為0%，訪問此端點仍將帶你進入服務的v2。這可以讓你能夠在向其發送流量之前驗證服務的運行情況。

說到發送流量：

$ rio weight demo-service@v2=5%
$ rio ps
NAME                IMAGE                   ENDPOINT                    WEIGHT
demo-service@v2     ebauman/rio-demo:v2     https://demo-service-v2...  5%
demo-service        ebauman/rio-demo:v1     https://demo-service-v0...  95%

使用rio weight命令，我們現在將發送我們5%的流量（從全局的服務端點）到新版本。當我們覺得demo-service的v2性能感到滿意之後，我們可以將其提升到100%：

$ rio promote --duration 60s demo-service@v2
demo-service@v2 promoted

超過60秒之後，我們的demo-service@v2服務將會逐漸提升到接收100%的流量。在這一過程中任意端點上，我們可以執行rio ps，並且查看進程：

$ rio ps
NAME                IMAGE                   ENDPOINT                    WEIGHT
demo-service@v2     ebauman/rio-demo:v2     https://demo-service-v2...  34%
demo-service        ebauman/rio-demo:v1     https://demo-service-v0...  66%

路由（Routing）

Rio可以根據主機名、路徑、方法、標頭和cookie的任意組合將流量路由到端點。Rio還支持鏡像流量、注入故障，配置retry邏輯和超時。

創建一個路由器

為了開始制定路由決策，我們必須首先創建一個路由器。路由器代表一個主機名和一組規則，這些規則確定發送到主機名的流量如何在Rio集群內進行路由。你想要要定義路由器，需要執行rio router add。例如，要創建一個在默認測試時接收流量並將其發送到demo-service的路由器，請使用以下命令：

rio route add testing to demo-service

這將創建以下路由器：

$ rio routers
NAME             URL                            OPTS    ACTION      TARGET
router/testing   https://testing-default.0pjk...        to          demo-service,port=80

發送到https://testing-default…的流量將通過端口80轉發到demo-service。

請注意，此處創建的路由為testing-default. 。Rio將始終使用命名空間資源，因此在這種情況下，主機名測試已在默認命名空間中進行了命名。要在其他命名空間中創建路由器，請將 -n <namespace>傳遞給rio命令：

rio -n <namespace> route add ...

基於路徑的路由

為了定義一個基於路徑的路由，當調用rio route add時，指定一個主機名加上一個路徑。這可以是新路由器，也可以是現有路由器。

$ rio route add testing/old to demo-service@v1

以上命令可以創建一個基於路徑的路由，它會在https://testing-default. /old接收流量，並且轉發流量到 demo-service@v1服務。

標頭和基於方法的路由

Rio支持基於HTTP標頭和HTTP verbs的值做出的路由策略。如果你想要創建基於特定標頭路由的規則，請在rio route add命令中指定標頭：

$ rio route add --header X-Header=SomeValue testing to demo-service

以上命令將創建一個路由規則，它可以使用一個X-Header的HTTP標頭和SomeValue的值將流量轉發到demo-service。類似地，你可以為HTTP方法定義規則：

$ rio route add --method POST testing to demo-service

故障注入

Rio路由有一項有趣的功能是能夠將故障注入響應中。通過定義故障路由規則，你可以設置具有指定延遲和HTTP代碼的失敗流量百分比：

$ rio route add --fault-httpcode 502 --fault-delay-milli-seconds 1000 --fault-percentage 75 testing to demo-service

其他路由選項

Rio支持按照權重分配流量、為失敗的請求重試邏輯、重定向到其他服務、定義超時以及添加重寫規則。要查看這些選項，請參閱以下鏈接：

https://github.com/rancher/rio

自動構建

將git倉庫傳遞給rio run將指示Rio在提交到受監控的branch（默認值：master）之後構建代碼。對於Github倉庫，你可以通過Github webhooks啟動此功能。對於任何其他git repo，或者你不想使用webhooks，Rio都會提供一項“gitwatcher”服務，該服務會定期檢查您的倉庫中是否有更改。

Rio還可以根據受監控的branch的拉取請求構建代碼。如果你想要進行配置，請將--build-pr傳遞到rio run。還有其他配置這一功能的選項，包括傳遞Dockerfile的名稱、自定義構建的鏡像名稱以及將鏡像推送到指定的鏡像倉庫。

堆棧和Riofile

Rio使用稱為Riofile的docker-compose-style manifest定義資源

configs:
  conf:
    index.html: |-
      <!DOCTYPE html>
      <html>
      <body>

      <h1>Hello World</h1>

      </body>
      </html>
services:
  nginx:
    image: nginx
    ports:
    - 80/http
    configs:
    - conf/index.html:/usr/share/nginx/html/index.html

Riofile定義了一個簡單的nginx Hello World網頁所有必要的組件。通過rio up部署它，會創建一個Stack（堆棧），它是Riofile定義的資源的集合。

Riofile具有許多功能，例如觀察Git庫中的更改以及使用Golang模板進行模板化。

其他Rio組件

Rio還有許多功能，例如configs、secrets以及基於角色訪問控制（RBAC）。詳情可參閱：

https://rio.io/

Rio可視化

Rio Dashboard

Rio的beta版本包括了一個全新的儀錶盤，使得Rio組件可視化。要訪問此儀錶盤，請執行命令：rio dashboard。在有GUI和默認瀏覽器的操作系統上，Rio將自動打開瀏覽器並加載儀錶盤。

你可以使用儀錶盤來創建和編輯堆棧、服務、路由等。此外，可以直接查看和編輯用於各種組件技術（Linkerd、gloo等）的對象，儘管不建議這樣做。儀錶盤目前處於開發的早期階段，因此某些功能的可視化（如自動縮放和服務網格）尚不可用。

Linkerd

作為Rio的默認服務網格，Linked附帶了一個儀錶盤作為產品的一部分。該儀錶盤可以通過執行rio linkerd來使用，它將代理本地本地主機流量到linkerd儀錶盤（不會在外部公開）。與Rio儀錶盤類似，有GUI和默認瀏覽器的操作系統上，Rio將自動打開瀏覽器並加載儀錶盤：

Linkerd儀錶盤显示了Rio集群的網格配置、流量和網格組件。Linkerd提供了Rio路由的某些功能組件，因此這些配置可能會显示在此儀錶盤上。還有一些工具可用於測試和調試網格配置和流量。

結 論

Rio為用戶提供許多功能，是一款強大的應用程序部署引擎。這些組件可以在部署應用程序時為開發人員提供強大的功能，使流程穩定而安全，同時輕鬆又有趣。在Rancher產品生態中，Rio提供了企業部署和管理應用程序和容器的強大功能。

如果你想了解Rio的更多信息，歡迎訪問Rio主頁或Github主頁：

https://rio.io

https://github.com/rancher/rio

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

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

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

0.前言

m3u8是一種很常見的網頁視頻播放器的視頻源，比如說中國大學MOOC中課程就是使用了該種視頻格式。

隨便打開一門課程，就可以發現在網絡請求中存在一個m3u8的文件，在preview中預覽，它並不像我們想象中是亂碼的視頻流。

裏面是一個列表，有一堆ts結尾的文件名，每個下面還跟了一個EXTINF的字段，好像是時間，在我們播放視頻時，網絡請求中會不斷出現請求ts的內容。

隨便打開一個ts文件，它的內容卻是如圖視頻流一般亂碼的。

說到這裏，你可能有猜測了，m3u8並不是視頻流的文件，而有可能是組織ts文件的規範，EXTINF代表播放每多少秒去請求下一片ts流。

這種邊看邊加載的方法無疑可以減少我們的網絡負荷。

要用爬蟲爬取這類視頻的方法也很簡單，我們只需要獲得m3u8文件，就可以得到視頻的ts地址了，將所有ts請求下來之後進行合併，就可以得到視頻文件了。

不過要提的一點是，很多視頻網站會對他們的ts進行加密，我們下載下來合併之後可能視頻能看，但是播放器放着放着就卡住了，然後之後黑屏畫面。

1.編碼部分

我們先根據m3u8來判斷一下創建咋樣一個代表M3U8視頻對象的類。

我們首先需要定義一個list，來存放這個m3u8視頻下所有的ts文件，也就是後面說到的TS類。

這裏提一點，m3u8裏面的ts的路徑一般對路徑，會和m3u8在同一文件夾，我們代碼中也是這麼認為了，但是難免有些網站會單獨存放m3u8和ts文件，如果遇到這種情況，修改一下代碼即可。

有了ts的名稱，我們還需要URL的前綴，也就是圖中紫色劃線部分，也就是basepath。

此外，我們還需要一個TS對象。

這個對象中存儲TS文件名稱以及時間EXTINF。

定義完實體類，就需要編寫下載視頻的過程了。

首先需要請求到m3u8的文件，此處使用Java的HttpURLConnection來請求獲取，其它語言類似，只需要請求到文件即可。

請求到了m3u8的文本內容，我們還需要解析它 ，從中得到ts的名稱。

得到了M3U8視頻對象之後，我們就可以遍歷請求它的list中TS對象的名稱屬性來下載ts文件了。

這麼多ts文件如果我們在單線程中遍歷請求，會很耗費時間，Java給我們提供了Stream，其中parallel可以讓我們併發去遍歷集合，效率會提升不少。

依舊是使用HttpURLConnection來做請求，不過最好本次設置超時時間。

這樣就可以請求到所有ts文件了。

最後要做的就是合併這些ts文件成為一個MP4文件。

對於未加密的正常ts文件，我們只需要按照編號順序直接拼接即可。

這樣就算是完成了M3U8視頻抓取了。

2.打包使用

下載地址：

在命令行中java -jar m3u8-down.jar [m3u8地址]，會显示報錯信息。

也可以直接m3u8-down.jar [m3u8地址]，不會显示保存信息，會在後台執行。

最終會在同目錄下生成一個output.mp4的文件，temp文件可以刪除。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

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

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

Java多線程系列文章是Java多線程的詳解介紹，對多線程還不熟悉的同學可以先去看一下我的這篇博客，這篇博客從宏觀層面介紹了多線程的整體概況，接下來的幾篇文章是對多線程的深入剖析。

 

多線程的常用方法

1、currentThread()方法：

介紹：currentThread()方法可返回該代碼正在被哪個線程調用的信息。

示例：

例1：

public class Test01 {

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
	}
	
}

結果：
main

　　

結果說明，main方法被名為main的線程調用

 

例2：

class Mythread extends Thread{
	
	public Mythread() {
		System.out.println("構造方法的打印："+Thread.currentThread().getName());
	}
	
	@Override
	public void run() {
		System.out.println("run方法的打印："+Thread.currentThread().getName());
	}
}

public class Test01 {

	public static void main(String[] args) {
		Mythread t=new Mythread();
		t.start();//①
	}
	
}

結果：
構造方法的打印：main
run方法的打印：Thread-0

　　

從結果可知：Mythread的構造方法是被main線程調用的，而run方法是被名稱為Thread-0的線程調用的，run方法是線程自動調用的

現在我們將①處的代碼改為t.run()，現在的輸出結果如下：

構造方法的打印：main
run方法的打印：main

　　

從結果中我們可以看到兩次的結果显示都是main線程調用了方法，因為當你使用t.start()方法的時候是線程自動調用的run()方法，所以輸出的是Thread-0，當你直接調用run()方法時，和調用普通方法沒有什麼區別，所以是main線程調用run()

 

2、isAlive()方法：

介紹：isAlive()方法的功能是判斷當前的線程是否處於活動狀態

示例：

例1：

class Mythread extends Thread{
	
	@Override
	public void run() {
		System.out.println("run =="+this.isAlive());
	}
	
}

public class Test01 {

	public static void main(String[] args) {
		Mythread thread=new Mythread();
		System.out.println("begin =="+thread.isAlive());//①
		thread.start();//②
		System.out.println("end =="+thread.isAlive());//③
	}
	
}

結果：
begin ==false
end ==true
run ==true

　　

方法isAlive()的作用是測試線程是否處於活動狀態。那麼什麼情況下是活動狀態呢？活動狀態就是線程已經啟動且尚未停止。線程處於正在運行或準備開始運行的狀態，就認為線程是存活的

①處代碼的結果為false，因為此時線程還未啟動；

②處代碼調用了run()方法輸出結果為run ==true，此時線程處於活動狀態；

③處代碼的結果為true，有的同學看到這個輸出可能會不理解，不是說線程處於活動狀態isAlive()方法的結果才是true，現在程序都已經運行結束了為什麼還是true？這裏的輸出結果是不確定的，我們再來看下面一段代碼

我們將例1中的代碼稍做修改，代碼如下：

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		System.out.println("begin =="+thread.isAlive());//①
		thread.start();//②
		Thread.sleep(1000);//這裏加了一行代碼，讓當前線程沉睡1秒
		System.out.println("end =="+thread.isAlive());//③
	}
	
}

結果：
begin ==false
run ==true
end ==false

　　

現在我們看到③處的代碼結果為end ==false，因為thread對象已經在1秒內執行完畢，而上面代碼輸出結果為true是因為thread線程未執行完畢。

 

3、sleep()方法：

介紹：

方法sleep()的作用是在指定的毫秒數內讓當前“正在執行的線程”休眠（暫停執行），這個“正在執行的線程”是指this.currentThread()返回的線程。

示例：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		try {
			System.out.println("run threadName="+this.currentThread().getName()+" begin");
			Thread.sleep(2000);
			System.out.println("run threadName="+this.currentThread().getName()+" end");
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		System.out.println("begin ="+System.currentTimeMillis());
		thread.run();//①
		System.out.println("end ="+System.currentTimeMillis());
	}
	
}

結果：
begin =1574660731663
run threadName=main begin
run threadName=main end
end =1574660733665

　　

從結果中可以看出main線程暫停了2秒（因為這裏調用的是thread.run()）

下面我們將①處的代碼改成thread.start()，再來看下運行結果：

begin =1574661491412
end =1574661491412
run threadName=Thread-0 begin
run threadName=Thread-0 end

　　

由於main線程與thread線程是異步執行的，所以首先打印的信息為begin和end，而thread線程是隨後運行的，在最後兩行打印run begin和run end的信息。

 

4、getId()方法：

介紹：getId()方法的作用是取得線程的唯一標識

示例：

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Thread thread=Thread.currentThread();
		System.out.println(thread.getName()+" "+thread.getId());
	}
	
}

結果：main 1

　　

從運行結果可以看出，當前執行代碼的線程名稱是main，線程id值為1

 

5、停止線程：

介紹：停止線程是在多線程開發時很重要的技術點，掌握此技術可以對線程的停止進行有效的處理。停止線程在Java語言中並不像break語句那樣乾脆，需要一些技巧性的處理。

在java中有三種方法可以停止線程

1. 使用退出標誌，讓線程正常退出，也就是當run方法執行完之後終止
2. 使用stop方法強制終止線程，但是不推薦使用，因為stop和suspend及resume一樣，是java廢棄的方法
3. 使用interrupt方法中斷線程（推薦使用）

示例：

例1：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		for(int i=0;i<5000;i++) {
			System.out.println("i="+(i+1));
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
		Thread.sleep(2000);
		thread.interrupt();
	}
	
}

　　

運行結果：

 

從運行結果我們可以看出最後i=500000，調用interrupt方法沒有停止線程，那麼該如何停止線程呢？

在介紹如何停止線程時，我們先來介紹一下如何判斷線程是否處於停止狀態

Thread類中提供了兩種方法用來判斷線程是否停止：

1、this.interrupted()：測試當前線程是否已經中斷，執行后具有將狀態標誌清除為false的功能

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
}

　　

2、this.isInterrupted()：測試線程Thread對象是否已經中斷，但是不清除狀態標誌

public boolean isInterrupted() {
        return isInterrupted(false);
}

　　

讀者可以仔細觀看一下這兩個方法的聲明有什麼不同？

 

例2：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		for(int i=0;i<5000;i++) {
			System.out.println("i="+(i+1));
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
		Thread.sleep(1000);
		thread.interrupt();
		System.out.println("是否停止1？="+thread.interrupted());
		System.out.println("是否停止2？="+thread.interrupted());
		System.out.println("end!");
	}
	
}

　　

結果：

 

 

 輸出結果显示調用了thread.interrupt()方法后線程並未停止，這也就證明了interrupted()方法的解釋：測試當前線程是否已經中斷。這個當前線程是main，它從未斷過，所以打印的結果是兩個false。

如果想讓main線程結束該怎麼做？

將main方法改成如下：

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Thread.currentThread().interrupt();
		System.out.println("是否停止1？="+Thread.interrupted());
		System.out.println("是否停止2？="+Thread.interrupted());
		System.out.println("end!");
	}
	
}

結果：
是否停止1？=true
是否停止2？=false
end!

　　

從輸出結果我們可以看出，方法interrupted()的確判斷出當前線程是否是停止狀態。但為什麼第2個值是false？

查看一下官方文檔的介紹：

測試當前線程是否已經中斷。線程的中斷狀態由該方法清除。換句話說，如果連續兩次調用該方法，則第二次調用將返回false（在第一次調用已清除了其中斷狀態之後，且第二次調用檢驗完中斷狀態前，當前線程再次中斷的情況除外）。

 文檔中說明的非常清楚，interrupted()方法具有清除狀態的功能，所以第二次調用interrupted方法返回的值時false。

下面我們來看一下isInterrupted()方法，將main方法改成如下代碼：

public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
		thread.interrupt();
		Thread.sleep(1000);
		System.out.println("是否停止1？="+thread.isInterrupted());
		System.out.println("是否停止2？="+thread.isInterrupted());
		System.out.println("end");
}
結果：

是否停止1？=true
是否停止2？=true
end

　　

從結果可以看出，方法isInterrrupted()並未清除狀態，所以結果為兩個true。

 

例3：在沉睡中停止

當線程調用sleep()方法后再調用interrupt()方法後會有什麼結果：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		try {
			System.out.println("run begin");
			Thread.sleep(200000);
			System.out.println("run end");
		} catch (InterruptedException e) {
			System.out.println("在沉睡中被停止，進入catch!"+this.isInterrupted());
			e.printStackTrace();
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		try {
			Mythread thread=new Mythread();
			thread.start();
			Thread.sleep(200);
			thread.interrupt();
		}catch(Exception e) {
			System.out.println("main catch");
			e.printStackTrace();
		}
		System.out.println("end!");
	}
	
}

　　

 

 

6、暫停線程：

暫停線程意味着此線程還可以恢復運行。在java多線程中，可以使用suspend()方法暫停線程，使用resume()方法恢複線程的執行

例1：

class Mythread extends Thread{
	
	private long i=0;
	public long getI() {
		return i;
	}
	
    public void setI(long i) {
		this.i = i;
	}
	
	@Override
	public void run() {
		while(true) {
			i++;
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		
		Mythread thread=new Mythread();
		thread.start();
		Thread.sleep(5000);
		//A段
		thread.suspend();
		System.out.println("A= "+System.currentTimeMillis()+" i="+thread.getI());
		Thread.sleep(5000);
		System.out.println("A= "+System.currentTimeMillis()+" i="+thread.getI());
		
		//B段
		thread.resume();
		Thread.sleep(5000);
		
		//C段
		thread.suspend();
		System.out.println("B= "+System.currentTimeMillis()+" i="+thread.getI());
		Thread.sleep(5000);
		System.out.println("B= "+System.currentTimeMillis()+" i="+thread.getI());
		
	}
	
}

　　

結果：

 

從控制台打印的時間上來看，線程的確被暫停了，而且還可以恢復成運行狀態。

 

7、yield方法：

介紹：yield()方法的作用是放棄當前的CPU資源，將它讓給其他的任務去佔用CPU執行時間。但放棄的時間不確定，有可能剛剛放棄，馬上又獲得CPU時間片

示例：

class Mythread extends Thread{
	
	@Override
	public void run() {
		long beginTime=System.currentTimeMillis();
		int count=0;
		for(int i=0;i<500000;i++) {
　　　　　　　　　　　　　　 //Thread.yield();①
			count=count+(i+1);
		}
		long endTime=System.currentTimeMillis();
		System.out.println("用時："+(endTime-beginTime)+"毫秒！");
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
	}
	
}

結果：用時：2毫秒！

　　

現在將①處的代碼取消註釋，我們再來看一下運行結果：

用時：213毫秒！

　　

將CPU讓給其他資源導致速度變慢

 

8、線程優先級：

介紹：

在操作系統中，線程可以劃分優先級，優先級較高的線程得到的CPU資源較多，也就是CPU優先執行優先級較高的線程對象中的任務。

設置線程優先級有助於幫“線程規劃器”確定在下一次選擇哪一個線程來優先執行。

設置線程的優先級使用setPriority()方法，此方法在JDK的源代碼如下：

public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
}

　　

在Java中，線程的優先級為1-10這10個等級，如果小於1或大於10，則JDK拋出異常throw new IllegalArgumentException()。

通常高優先級的線程總是先執行完，但是並不是一定的，高優先級和低優先級的線程會交替進行，高優先級執行的次數多一些

 

線程優先級的繼承特性：

在Java中，線程的優先級具有繼承性，比如A線程啟動B線程，則B線程的優先級與A是一樣的。

class Mythread2 extends Thread{
	@Override
	public void run() {
		System.out.println("Mythread2 run priority="+this.getPriority());
	}
}


class Mythread1 extends Thread{
	
	@Override
	public void run() {
		System.out.println("Mythread run priority="+this.getPriority());
		Mythread2 thread2=new Mythread2();
		thread2.start();
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		
		System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
    	        //Thread.currentThread().setPriority(6);①
		System.out.println("main thread end priority="+Thread.currentThread().getPriority());
		Mythread1 thread1=new Mythread1();
		thread1.start();
	}
	
}

結果:
main thread begin priority=5
main thread end priority=5
Mythread run priority=5
Mythread2 run priority=5

　　

可以看到上面幾個線程的優先級都為5

現在將①處的代碼註釋掉后的結果是：

main thread begin priority=5
main thread end priority=6
Mythread run priority=6
Mythread2 run priority=6

　　

優先級被更改后再繼續繼承

 

9、守護線程：

在java中有兩種線程，一種是用戶線程，另一種是守護線程。

守護線程是一種特殊的線程，它的特性有“陪伴”的含義，當進程中不存在非守護線程了，則守護線程自動銷毀。典型的守護線程就是垃圾回收線程，當進程中沒有非守護線程了，則垃圾回收線程也就沒有存在的必要了，自動銷毀。用個比較通俗的比喻來解釋一下：“守護線程”：任何一個守護線程都是整個JVM中所有非守護線程的“保姆”，只要當前JVM實例中存在任何一個非守護線程沒有結束，守護線程就在工作，只有當最後一個非守護線程結束時，守護線程才隨着JVM一同結束工作。Daemon的作用是為其他線程的運行提供便利服務，守護線程最典型的應用就是GC（垃圾回收器），它就是一個很稱職的守護者。

 

class Mythread extends Thread{
	
	private int i=0;
	
	
	@Override
	public void run() {
		
		try {
			while(true) {
				i++;
				System.out.println("i="+(i));
				Thread.sleep(1000);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		
		try {
			Mythread thread=new Mythread();
			thread.setDaemon(true);
			thread.start();
			Thread.sleep(5000);
			System.out.println("我離開Thread對象就不再打印了，也就是停止了");
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
}

　　

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

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

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

本文整理了我自己在Java開發中常用的jar包以及常用的API記錄。

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

common-lang3

簡介

一個現在最為常用的jar包，封裝了許多常用的工具包

依賴：

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.4</version>
</dependency>

主要常見的類如下：

• 數組工具類 ArrayUtils
• 日期工具類 DateUtils DateFormatUtils
• 字符串工具類 StringUtils
• 数字工具類 NumberUtils
• 布爾工具類 BooleanUtils
• 反射相關工具類 FieldUtils、MethodUtils、MemberUtils、TypeUtils、ConstructorUtils
• 對象工具類 ObjectUtils
• 序列化工具類 SerializationUtils

API介紹

這裏我只介紹經常使用的幾個工具類及方法，ArrayUtils，StringUtils，NumberUtils，DateUtils，其他的請查看官方API文檔吧

1.ArrayUtils

方法名	說明
add
remove
clone	複製數組
addAll
removeAll	第二個參數傳入需要刪除的下標（可以指定多個下標）
toObject	把數值（int[],double[]）轉為包裝類(Int[],Double[])
indexOf	在數組按順序查找，找到第一個滿足對應的數值的下標
lastIndexOf	在數組按順序查找，找到最後一個滿足對應的數值的下標
contains	數組是否包含某個值
isEmpty	判斷數組是否為空
isNotEmpty	判斷數組是否不為空
reverse	數組反轉
subarray	指定區間截取數組，區間為半開區間，不包含末尾
toArray	接收一個多個對象，把這幾個對象轉為對應類型的數組
toMap	將一個二維數組轉為Map

2.NumberUtils

方法名	說明
min	比較三個數，返回最小值 或比較指定的幾個數，返回最小值
max	比較三個數，返回最大值 或比較指定的幾個數，返回最大值
createInt	從傳入的String中創建對應類型的數值，createDouble,createFloat…
toInt	將指定字符串轉為Int類型，可以選擇指定默認數值，如果字符串為null則返回默認數值，除此之外，還有toDouble,toLong…等轉為不同類型的方法
compare	比較兩個同類型數值的大小
isDigits	判斷字符串是否只包含数字
isParsable	判斷字符串是否可轉換為Long,Int等類型
isNumber	判斷字符串是否為數值（0x,0X開頭等進制數值）

3.DateUtils

方法名	說明
parseDate	將Date對象轉為字符串
isSameDay	判斷兩個Dated對象是否為同一天
isSameDay	判斷兩個Dated對象是否為同一天
addHour	將指定的Date對象加上指定小時，除此之外，還有addMonth,addDay..等

DateFormatUtils正如其名，是用來把時間轉為字符串，這裏就不再多說

4.StringUtils

方法名	說明
join	將指定的數組連接成字符串，並添加指定的分割字符
containOnly	字符串是否只包含某個字符串
substringBefore	截取指定字符串前面的內容
substringAfter	截取指定字符串後面的內容（不包括指定字符串）
substringBetween	截取字符串某區間內容，如substringBetween(“abcde”,”a”,”e”)=”bcd”
difference	比較兩個字符串，返回兩個字符串不同的內容，具體可以看API文檔給出的示例
isBlank	判斷字符串是否為空白，null,””,” “這三個結果都是為true
isEmpty	判斷字符串是否為空(只要不為null，或傳入的String對象的長度不為0即為true)
countMatches	判斷指定的字符串在某個字符串中出現的次數
deleteWhitespace	刪除字符串中的空格
defaultIfBlank	如果字符串為空白，則返回一個指定的默認值(null或某個String)
defaultIfEmpty	如果字符串為空，則返回一個指定的默認值(null或某個String)
capitalize	將指定字符串首字母大寫
abbreviate	將指定字符串的後面三位轉為…
swapCase	將字符串中的字母大小寫反轉,如aBc變為AbC
lowerCase	將字符串的字母全部轉為小寫
upperCase	將字符串的字母全部轉為大寫
left	取字符串左邊幾個字符，如left(“hello”,3)=”hel”，right與此相反
leftPad	字符串的長度不夠，則使用指定字符填充指定字符串，如leftPad(“hel”,5,”z”)=”zzhel”,rightPad方法與此相反
prependIfMissing	指定字符串不以某段字符串開頭，則自動添加開頭，如prependIfMissing(“hello”,”li”)=”lihello”
prependIfMissing	指定字符串不以某段字符串開頭(忽略大小寫)，則自動添加開頭
getCommonPrefix	獲得多個字符串相同的開頭內容，接收參數為多個字符串
removeEnd	刪除字符串中結尾（滿足是以某段內容結尾），如removeEnd(“hello”,”llo”)=”he”
removeEndIgnoreCase	與上面一樣，忽略大小寫
removeStart	與上面的相反
remove	刪除字符串中的指定內容，如remove(“hello”,”l”)=”heo”
removeIgnoreCase	刪除字符串中的指定內容，如remove(“hello”,”l”)=”heo”
strip	清除字符串開頭和末尾指定的字符(第二個參數為null,用來清除字符串開頭和末尾的空格)，如strip(” abcxy”,”xy”)=” abc”,strip(” abcxy”,”yx”)=” abc”
stripStart	清除字符串開頭指定字符
stripEnd	清除字符串末尾指定的字符

common-io

簡介

常用的IO流工具包

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

API

我們主要關心的就是Utils後綴的那幾個類即可，可以看到，common-io庫提供了FileUtils,FileSystemUtils,FileNameUtils,FileFilterUtils,IOUtils

FileUtils

• 寫出文件
• 讀取文件
• 創建一個有父級文件夾的文件夾
• 複製文件和文件夾
• 刪除文件和文件夾
• URL轉文件
• 通過過濾器和擴展名來篩選文件和文件夾
• 比較文件內容
• 文件最後修改時間
• 文件校驗

FileSystemUtils

關於文件系統的相關操作，如查看C盤的大小，剩餘大小等操作

IOUtils

字面意思，是封裝了IO流的各種操作的工具類

Log4j

簡介

Log4J 是 Apache 的一個開源項目，通過在項目中使用 Log4J，我們可以控制日誌信息輸出到控制台、文件、GUI 組件、甚至是數據庫中。

我們可以控制每一條日誌的輸出格式，通過定義日誌的輸出級別，可以更靈活的控制日誌的輸出過程，方便項目的調試。

依賴：

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

結構

Log4J 主要由 Loggers (日誌記錄器)、Appenders（輸出端）和 Layout（日誌格式化器）組成。

其中Loggers 控制日誌的輸出級別與日誌是否輸出；
Appenders 指定日誌的輸出方式（輸出到控制台、文件等）；
Layout 控制日誌信息的輸出格式。

日誌級別：

級別	說明
OFF	最高日誌級別，關閉左右日誌
FATAL	將會導致應用程序退出的錯誤
ERROR	發生錯誤事件，但仍不影響系統的繼續運行
WARN	警告，即潛在的錯誤情形
INFO	一般和在粗粒度級別上，強調應用程序的運行全程
DEBUG	一般用於細粒度級別上，對調試應用程序非常有幫助
ALL	最低等級，打開所有日誌記錄

我們主要使用這四個：Error>Warn>Info>Debug

使用

我們可以使用兩種方式來運行Log4j，一種是java代碼方式，另外一種則是配置文件方式

例子（Java方式）

public class Log4JTest {
    public static void main(String[] args) {   
        //獲取Logger對象的實例（傳入當前類）         
        Logger logger = Logger.getLogger(Log4JTest.class);
        //使用默認的配置信息，不需要寫log4j.properties
        BasicConfigurator.configure();
        //設置日誌輸出級別為WARN，這將覆蓋配置文件中設置的級別，只有日誌級別低於WARN的日誌才輸出
        logger.setLevel(Level.WARN);
        logger.debug("這是debug");
        logger.info("這是info");
        logger.warn("這是warn");
        logger.error("這是error");
        logger.fatal("這是fatal");
    }
}

例子（配置文件方式）

上面的例子，我們想要實現打印Log，但是每次都要寫一遍，浪費時間和精力，所以，Log4j提供了另外一種方式來配置好我們的信息

創建一個名為log4j.properties的文件，此文件需要放在項目的根目錄（約定），如果是maven項目，直接放在resources文件夾中即可

log4j.properties

#控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

#log jdbc
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=WARN
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

#log mybatis設置
#log4j.logger.org.apache.ibatis=DEBUG
log4j.logger.org.apache.ibatis.jdbc=error
log4j.logger.org.apache.ibatis.io=info
log4j.logger.org.apache.ibatis.datasource=info

#springMVC日誌
log4j.logger.org.springframework.web=WARN

# 文件輸出配置
log4j.appender.A = org.apache.log4j.DailyRollingFileAppender
log4j.appender.A.File = D:/log.txt #指定日誌的輸出路徑
log4j.appender.A.Append = true
log4j.appender.A.Threshold = DEBUG
log4j.appender.A.layout = org.apache.log4j.PatternLayout #使用自定義日誌格式化器
log4j.appender.A.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n #指定日誌的輸出格式
log4j.appender.A.encoding=UTF-8 #指定日誌的文件編碼

#指定日誌的輸出級別與輸出端
log4j.rootLogger=DEBUG,Console,A

#指定某個包名日誌級別（不能超過上面定義的級別，否則日誌不會輸出）
log4j.logger.com.wan=DEBUG

之後使用的話就比較簡單了

//Logger的初始化（這個推薦定義為全局變量，方便使用）
Logger logger = Logger.getLogger(Log4JTest.class);
//輸出Log
logger.info("這是info");

參考鏈接：

lombok

簡介

平常我們創建實體類的時候，需要get/set方法，極其麻煩，雖然IDEA等IDE都是有提供了快捷生成，不過，最好的解決方法還是省略不寫

而lombok就是這樣的一個框架，實現省略get/set方法，當然，lombok的功能不只有此，還有equal，toString方法也可以由此框架自動生成

lombok的原理是使用註解，之後就會在編譯過程中，給Class文件自動加上get/set等方法

不過IDEA似乎無法識別，代碼檢查還是會報錯，所以，使用IDEA的時候還得安裝一個插件，在plugin搜索lombok，之後安裝重啟即可，如圖

之後為Java項目添加依賴

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
    <scope>provided</scope>
</dependency>

使用示例

1.實體類省略get/set
估計Kotlin中的data關鍵字就是參照着lombok實現的

//這裏我們只需要為類添加Data註解，就會自動生成對應屬性的get/set方法，toString，equal等方法
@Data
public class User {
    private String username;
    private String password;
}

2.需要無參構造以及get/set方法

@Getter
@Setter
@NoArgsConstructor
public class User {
    private String username;
    private String password;
}

3.鏈式調用set方法

@Data
@Accessors(chain = true)
public class User {
    private String username;
    private String password;
}

//使用
User user = new User();
user.setUsername("helo").setPassword("123");

4.參數不為空

//如果調用此方法，就會抱一個空指針錯誤
public String print(@NotNull String str){
    ...
}

5.只需要toString

@ToString(callSuper=true, includeFieldNames=true)
public class User {
    private String username;
    private String password;
    //省略的get/set方法
}

6.builder模式創建實體類對象

@Data
@Builder
public class User {
    private String username;
    private String password;
}
//使用
User user1 = User.builder().username("user1").password("123").build();

7.工具類

@UtilityClass
public class MyUtils{
    //會將此方法自動轉為靜態方法
    public void print(String str){
        ...
    }
}
//使用
MyUtils.print("hello");

8.自動關閉流

public static void main(String[] args) throws Exception {
    //使用Cleanup會自動調用close方法
    @Cleanup InputStream in = new FileInputStream(args[0]);
    @Cleanup OutputStream out = new FileOutputStream(args[1]);
    byte[] b = new byte[1024];
    while (true) {
        int r = in.read(b);
        if (r == -1) break;
        out.write(b, 0, r);
    }
}

9.省略Logger時的初始化

@Log4j
@Log
public class User{
    //會自動添加此語句
    //Logger logger = Logger.getLogger(User.class);
    ...
}

參考：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

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

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整