一 OpenShift特性

1.1 OpenShift概述

Red Hat OpenShijft Container Platform (OpenShift)是一個容器應用程序平台，它為開發人員和IT組織提供了一個雲應用程序平台，用於在安全的、可伸縮的資源上部署新應用程序，而配置和管理開銷最小。

OpenShift構建於Red Hat Enterprise Linux、Docker和Kubernetes之上，為當今的企業級應用程序提供了一個安全且可伸縮的多租戶操作系統，同時還提供了集成的應用程序運行時和庫。

OpenShift帶來了健壯、靈活和可伸縮的特性。容器平台到客戶數據中心，使組織能夠實現滿足安全性、隱私性、遵從性和治理需求的平台。不願意管理自己的OpenShift集群的客戶可以使用Red Hat提供的公共雲平台OpenShift Online。

1.2 OpenShift特性

OpenShift容器平台和OpenShift Online都是基於OpenShift Origin開源軟件項目的，該項目本身使用了許多其他開源項目，如Docker和Kubernetes。

應用程序作為容器運行，容器是單個操作系統內的隔離分區。容器提供了許多與虛擬機相同的好處，比如安全性、存儲和網絡隔離，同時需要的硬件資源要少得多，啟動和終止也更快。OpenShift使用容器有助於提高平台本身及其承載的應用程序的效率、靈活性和可移植性。

OpenShift的主要特性如下:

• 自助服務平台：OpenShift允許開發人員使用Source-to-Image(S21)從模板或自己的源代碼管理存儲庫創建應用程序。系統管理員可以為用戶和項目定義資源配額和限制，以控制系統資源的使用。
• 多語言支持：OpenShift支持Java、Node.js、PHP、Perl以及直接來自Red Hat的Ruby。同時也包括來自合作夥伴和更大的Docker社區的許多其他代碼。MySQL、PostgreSQL和MongoDB數據庫。Red Hat還支持在OpenShift上本地運行的中間件產品，如Apache httpd、Apache Tomcat、JBoss EAP、ActiveMQ和Fuse。
• 自動化：OpenShift提供應用程序生命周期管理功能，當上游源或容器映像發生更改時，可以自動重新構建和重新部署容器。根據調度和策略擴展或故障轉移應用程序。
• 用戶界面：OpenShift提供用於部署和監視應用程序的web UI，以及用於遠程管理應用程序和資源的CLi。它支持Eclipse IDE和JBoss Developer Studio插件，以便開發人員可以繼續使用熟悉的工具，並支持REST APl與第三方或內部工具集成。
• 協作：OpenShift允許在組織內或與更大的社區共享項目。
• 可伸縮性和高可用性：OpenShift提供了容器多租戶和一個分佈式應用程序平台，其中包括彈性，以處理隨需增加的流量。它提供了高可用性，以便應用程序能夠在物理機器宕機等事件中存活下來。OpenShift提供了對容器健康狀況的自動發現和自動重新部署。
• 容器可移植性：在OpenShift中，應用程序和服務使用標準容器映像進行打包，組合應用程序使用Kubernetes進行管理。這些映像可以部署到基於這些基礎技術的其他平台上。
• 開源：沒有廠商鎖定。
• 安全性：OpenShift使用SELinux提供多層安全性、基於角色的訪問控制以及與外部身份驗證系統(如LDAP和OAuth)集成的能力。
• 動態存儲管理：OpenShift使用Kubernetes持久卷和持久卷聲明的方式為容器數據提供靜態和動態存儲管理
• 基於雲(或不基於雲)：可以在裸機服務器、活來自多個供應商的hypervisor和大多數IaaS雲提供商上部署OpenShift容器平台。
• 企業級：Red Hat支持OpenShift、選定的容器映像和應用程序運行時。可信的第三方容器映像、運行時和應用程序由Red Hat認證。可以在OpenShift提供的高可用性的強化安全環境中運行內部或第三方應用程序。
• 日誌聚合和metrics：可以在中心節點收集、聚合和分析部署在OpenShift上的應用程序的日誌信息。OpenShift能夠實時收集關於應用程序的度量和運行時信息，並幫助不斷優化性能。
• 其他特性：OpenShift支持微服務體繫結構，OpenShift的本地特性足以支持DevOps流程，很容易與標準和定製的持續集成/持續部署工具集成。

二 OpenShift架構

2.1 OpenShift架構概述

OpenShift容器平台是一組構建在Red Hat Enterprise Linux、Docker和Kubernetes之上的模塊化組件和服務。OpenShift增加了遠程管理、多租戶、增強的安全性、應用程序生命周期管理和面向開發人員的自服務接口。

OpenShift的架構：

• RHEL：基本操作系統是Red Hat Enterprise Linux；
• Docker：提供基本的容器管理API和容器image文件格式；
• Kubernetes：管理運行容器的主機集群(物理或虛擬主機)。它處理描述由多個資源組成的多容器應用程序的資源，以及它們如何互連；
• Etcd：一個分佈式鍵值存儲，Kubernetes使用它來存儲OpenShift集群中容器和其他資源的配置和狀態信息。

OpenShift在Docker + Kubernetes基礎設施之上添加了提供容器應用程序平台所需的更富豐的功能：

OpenShift-Kubernetes extensions：其它資源類型存儲在Etcd中，由Kubernetes管理。這些額外的資源類型形成OpenShift內部狀態和配置，以及由標準 Kubernetes管理的應用程序資源；

Containerized services：完成許多基礎設施功能，如網絡和授權。其中一些一直運行，另一些則按需啟動。OpenShift使用Docker和Kubernetes來實現大多數內部功能。即大多數OpenShift內部服務作為由Kubernetes管理的容器；

Runtimes and xPaaS：供開發人員使用的 base image，每個image都預配置了特定的runtime或db。xPaaS提供了一組用於JBoss中間件產品（如JBoss EAP和ActiveMQ）的 base image；

DevOps tools and user experience：OpenShift提供了Web UI和CLI管理工具，從而實現配置和監視應用程序、OpenShift服務和資源。Web和CLI工具都是由相同的REST api構建的，可供IDE和CI平台等外部工具使用。OpenShift 還可以訪問外部SCM存儲庫和容器registry，並將它們的構件引入OpenShift Cloud。

OpenShift不會向開發人員和系統管理員屏蔽Docker和Kubernetes的核心基礎設施。相反，它將它們用於內部服務，並允許將Docker和Kubernetes資源導入OpenShift集群，同時原始Docker和資源可以從OpenShift集群導出，並導入到其他基於docker的基礎設施中。

OpenShift添加到Docker + Kubernetes的主要價值是自動化開發工作流，因此應用程序的構建和部署在OpenShift集群中按照標準流程進行。開發者不需要知道底層Docker的細節。OpenShift接受應用程序，打包它，並將其作為容器啟動。

2.2 Master和nodes

OpenShift集群是一組節點服務器，它們運行容器，並由一組主服務器集中管理。服務器可以同時充當master和node，但是為了增加穩定性，這些角色通常是分開的。

OpenShift工作原理和交互視圖：




master節點運行OpenShift核心服務，如身份驗證，並未管理員提供API入口。

nodes節點運行包含應用程序的容器，容器又被分組成pod。

OpenShift master運行Kubernetes master服務和Etcd守護進程；

node運行Kubernetes kubelet和kube-proxy守護進程。

雖然在描述中通常沒有聲明，但實際上master本身也是node。

scheduler和management/replication是Kubernetes主服務，而Data Store是Etcd守護進程。

Kubernetes的調度單元是pod，它是一組共享虛擬網絡設備、內部IP地址、TCP/UDP端口和持久存儲的容器。pod可以是任何東西，從完整的企業應用程序(包括作為不同容器的每一層)到單個容器中的單個微服務。例如，一個pod，一個容器在Apache下運行PHP，另一個容器運行MySQL。

Kubernetes管理replicas來縮放pods。副本是一組共享相同定義的pod。

三 管理OpenShift

3.1 OpenShift項目及應用

除了Kubernetes的資源(如pods和services)之外，OpenShift還管理projects和users。一個projects對Kubernetes資源進行分組，以便用戶可以使用訪問權限。還可以為projects分配配額，從而限制了已定義的pod、volumes、services和其他資源。

OpenShift中沒有application的概念，OpenShift client提供了一個new-app命令。此命令在projects中創建資源，但它們都不是應用程序資源。這個命令是為標準開發人員工作流配置帶有公共資源的proiect的快捷方式。

OpenShift使用lables(標籤)對集群中的資源進行分類。默認情況下，OpenShift使用app標籤將相關資源分組到應用程序中。

3.2 使用Source-to-image構建映像

OpenShift允許開發人員使用標準源代碼管理倉庫(SCM)和集成開發環境(ide)來發布應用。

OpenShift中的source -to-lmage (S2I)流程從SCM倉庫中提取代碼，自動判斷所需的runtime，基於runtime啟動一個pod，在pod中編譯應用。

當編譯成功時，將在runtime image中添加層並形成新的image，推送進入OpenShift internal registry倉庫，接着基於這個image將創建新的pod，運行應用程序。

S2I可被視為已經內置到OpenShift中的完整的CI/CD管道。

CI/CD有不同的形式，根據具體場景表現不同。例如，可以使用外部CI工具(如Jenkins)啟動構建並運行測試，然後將新構建的映像標記為成功或失敗，將其推送到QA或生產。

3.2 管理OpenShift資源

OpenShift資源定義,如image、container、pod、service、builder、template等，都存儲在Etcd中，可以由OpenShift CLI, web控制台或REST API進行管理。

OpenShift的資源科通過JSON或YAML文件查看，並且在類似Git或版本控制的SCM中共享。OpenShift甚至可以直接從外部SCM檢索這些資源定義。

大多數OpenShift操作不需要實時響應，OpenShift命令和APIs通常創建或修改存儲在Etcd中的資源描述。Etcd然後通知OpenShift控制器，OpenShift控制器會就更改警告這些資源。

這些控制器採取行動，以便使得資源的最終態反應達到更改效果。例如，如果創建了一個新的pod資源，Kubernetes將在node上調度並啟動該pod，使用pod資源確定要使用哪個映像、要公開哪個端口，等等。或者一個模板被更改，從而指定應該有更多的pod來處理負載，OpenShift會安排額外的pod(副本)來滿足更新后的模板定義。

注意：雖然Docker和Kubernetes是OpenShift的底層，但是必須主要使用OpenShift CLi和OpenShift APls來管理應用程序和基礎設施。OpenShift增加了額外的安全和自動化功能，當直接使用Docker或Kubernetes命令和APls時，這些功能必須手動配置，或者根本不可用。因此強烈建議不要使用docker或Kubernetes的命令直接管理應用。

四 OpenShift網絡

4.1 OpenShift網絡概述

Docker網絡相對簡單，Docker創建一個虛擬內核橋接器（docker0網卡），並將每個容器網絡接口連接到它。

Docker本身沒有提供允許一個主機上的pod連接到另一個主機上的pod的方法。Docker也沒有提供嚮應用程序分配公共固定IP地址的方法，以便外部用戶可以訪問它。

但Kubernetes提供service和route資源來管理pods之間的網絡，以及從外部到pods的路由流量。service在不同pods之間提供負載均衡用於接收網絡請求，同時為service的所有客戶機(通常是其他pods)提供一個內部IP地址。

container和pods不需要知道其他pods在哪裡，它們只連接到service。route為service提供一個固定的惟一DNS名稱，使其對OpenShift集群之外的客戶端可見。

Kubernetes service和route資源需要外部（功能）插件支持。service需要軟件定義的網絡(SDN)，它將在不同主機上的pod之間提供通信，route需要轉發或重定向來自外部客戶端的包到服務內部IP。

OpenShift提供了一個基於Open vSwitch的SDN，路由由分佈式HAProxy farm提供。

五 OpenShift持久性存儲

5.1 永久存儲

pod可以在一個節點上停止，並隨時在另一個節點上重新啟動。同時pod的默認存儲是臨時存儲，通過對於類似數據庫需要永久保存數據的應用不適合。

Kubernetes為管理容器的外部持久存儲提供了一個框架。Kubernetes提供了PersistentVolume資源，它可以在本地或網絡中定義存儲。pod資源可以使用PersistentVolumeClaim資源來訪問對應的持久存儲卷。

Kubernetes還指定了一個PersistentVolume資源是否可以在pod之間共享，或者每個pod是否需要具有獨佔訪問權的自己PersistentVolume。當pod移動到另一個節點時，它將保持與相同的PersistentVolumeClaim和PersistentVolumne資源的關聯。這意味着pod的持久存儲數據跟隨它，而不管它將在哪個節點上運行。

OpenShift向Kubernetes提供了多種VolumeProvider，如NFS、iSCSI、FC、Gluster或OpenStack Cinder。

OpenShift還通過StorageClass資源為應用程序提供動態存儲。使用動態存儲，可以選擇不同類型的後端存儲。後面存儲根據應用程序的需要劃分為不同的“tiers”。例如，可以定義一個名為“fast”的存儲類和另一個名為“slow”的存儲類，前者使用更高速的後端存儲，後者提供普通的存儲。當請求存儲時，最終用戶可以指定一個Persistentvolumeclaim，並使用一個註釋指定他們所需的StorageClass。

六 OpenShift高可用

6.1 OpenShift高可用概述

OpenShift平台集群的高可用性(HA)有兩個不同的方面：

OpenShift基礎設施本身的HA(即主機)；

以及在OpenShift集群中運行的應用程序的HA。

默認情況下，OpenShift為master提供了完全支持的本機HA機制。

對於應用程序或“pods”，如果pod因任何原因丟失，Kubernetes將調度另一個副本，將其連接到服務層和持久存儲。如果整個節點丟失，Kubernetes會為它所有的pod安排替換節點，最終所有的應用程序都會重新可用。pod中的應用程序負責它們自己的狀態，因此它們需要自己維護應用程序狀態(如HTTP會話複製或數據庫複製)。

七 Image Streams

7.1 Image Streams

要在OpenShift中創建一個新的應用程序，除了應用程序源代碼之外，還需要一個base image(S2I builder image)。如果源代碼或image任何一個更新，就會生成一個新的image，並且基於此新image創建新的pod，同時替換舊的pod。

即當應用程序代碼發生更改時，容器映像需要更新，但如果構建器映像發生更改，則部署的pod也需要更新。

Image Streams包括由tag標識的大量的image。應用程序是針對Image Streams構建的。Image Streams可用於在創建新image時自動執行操作。構建和部署可以監視Image Streams，以便在添加新image時接收通知，並分別執行構建或部署。

OpenShift默認情況下提供了幾個Image Streams，包括許多流行的runtime和frameworks。

Image Streams tag是指向Image Streams中的image的別名。通常縮寫為istag。它包含一個image歷史記錄，表示為tag曾經指向的所有images的堆棧。

每當使用特定的istag標記一個新的或現有的image時，它都會被放在歷史堆棧的第一個位置(標記為latest)。之前tag再次指向舊的image。同時允許簡單的回滾，使標籤再次指向舊的image。 本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

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

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

※聚甘新

基礎認識

本項目使用的是face++平台，人臉識別+手勢識別雙確認显示。

python編程，代碼簡介，方便擴展。

該項目適用於Windows系統和Linux系統，但必須安裝相應的模塊，其中包括

l  Python3  python 庫，邏輯編寫

l  Pillow   窗口開發實現

l  opencv-python python的opencv接口

l  Opencv庫   用於人臉檢測

本次測試是在win 10電腦上

視頻演示：

https://www.bilibili.com/video/BV1Wk4y1z7H7

安裝python3

這個網上到處都是資料，找一找就知道啦

官網：

https://www.python.org/

 安裝pillow

該庫用於python做界面開發，詳細參考：https://www.cnblogs.com/dongxiaodong/p/9971974.html

這個庫一般電腦都自帶有了，可以先不安裝，直接運行代碼。

如果出現以下錯誤，則必須手動安裝

ModuleNotFoundError: No module named ‘PIL’

安裝命令：

pip install pillow

安裝opencv-python

Opencv可以實現人臉檢測、人臉對比識別等功能，但在次只是用它來實現了人臉檢測並做人臉框圖，並沒有更多功能的實現，想要獲取更多功能的學習參考，請訪問：https://www.cnblogs.com/dongxiaodong/p/10134904.html

pip install opencv-python

如果出現紅色字體，表示安裝出錯了，必須從新運行安裝命令

 Face++

Face++在項目中用於人臉識別和手勢識別

系統流程主要為如下：

測試

(一)  獲取人臉標識

工程目錄：

l  運行項目，攝像頭將開啟，實時展示所拍攝的畫面

l  按下空格鍵即可獲取人臉標識，輸出人臉標識和存儲到data文件目錄下

l  此時按下ESC鍵則退出程序

l  同一個人的人臉標識很有可能是不一樣的，因為它更多的是基於本次照片計算

(二)  創建人臉庫&人臉標識添加到人臉庫

l  創建人臉標識庫，標識名自定義，但同一用戶內不可有相同的人臉標識庫

l  在函數填寫自己賬戶下唯一的人臉庫標識名

l  將人臉標識添加到人臉庫中

l  在函數中填寫人臉庫標識和我們第一步獲取的人臉標識，將人臉標識添加到人臉庫中

l  人臉庫可以添加多個不同的人臉標識

(三)  人臉庫搜索結果比對

l  修改為我們剛剛所創建的人臉庫，進行接下來的人臉識別查找

l  運行工程后將開啟攝像頭進行照片實時捕獲識別，並在屏幕中显示識別結果

l  識別包括人臉識別和手勢識別

l  只有在人臉識別正確的情況下才會開啟手勢識別

人臉識別失敗

人臉識別成功，無手勢

人臉識別成功，手勢為合攏

人臉識別成功，手勢為打開

視頻演示：

https://www.bilibili.com/video/BV1Wk4y1z7H7

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

【其他文章推薦】

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

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

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

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

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

※聚甘新

這篇文章我決定一改以往的風格，以幽默風趣的故事博文來介紹如何整合 SpringBoot、Mybatis、Redis。

很久很久以前，森林里有一隻可愛的小青蛙，他邁着沉重的步伐走向了找工作的道路，結果發現許多的招聘要求都要會 Redis。

小青蛙就想啥是 Redis 呢，為什麼要用 Redis 呢？難道是因為 Mysql 的幣格不夠高嗎，小青蛙點開了收藏已久的網站：十萬個為什麼

發現原來隨着使用網站的用戶越來越多，表中的數據也越來越多，查詢速度越來越慢。

MySql 的性能遇到了瓶頸，所以許多網站都用 Redis 作緩存。

然而能作緩存的不僅只有 Redis，還有 Memcache，那為什麼要用 Redis 呢？

1、性能方面：它們都是將數據存放在內存中，所以性能基本相似。

2、數據類型方面：Redis 支持五種數據數據類型：字符串、散列、列表、集合、有序集合，而 Memcache 僅僅支持簡單的 key-value。

3、數據持久化方面：Redis 可以通過 RDB快照、AOF日誌 等方式進行數據持久化，但是 Memcache 不可以。

4、數據備份方面：Redis  支持 master-slave 主從模式的數據備份。

在了解到許多 Redis 的好處后，小青蛙已經迫不及待的想了解它了。

為了更好的使用 Redis，了解 Redis 的五種數據類型適應場景是很有必要的。

1、String 類型：一個 key 對應一個 value，而 value 不僅僅是 String，也可以是数字、甚至是一個序列化對象。

2、Hash 類型：一個 key 對應 多個 field，一個 field 對應 yige value，實際上該類型最適合存儲序列化對象。

　　　　　　     key 相當於數據庫表名字，field  相當於主鍵，value 也就是序列化對象。

3、List 類型：簡單的字符串列表，按照插入順序排序，該結構類似於數據結構中的雙向鏈表，可以從頭部插也可以從尾部插。

4、Set 類型：它是字符串集合，只不過它是無序的且不存在重複的字符串，但是它可以實現 交集、並集、差集。

5、ZSet 類型：它也是字符串集合，它和 Set 的區別是該集合的元素存在 score 屬性，按照 score 屬性的高低排序。可以應用在排行榜上。

值得注意的是，不要習慣性的認為 Redis 字符串只能存字符串，實際上，它可以存儲任何序列化后的對象，當然也可以讀出來。

小青蛙知道了 Redis 的五種數據類型應用場景后，迫不及待的想要實踐它了。

為了知道如何讓它作為緩存，以及如何操作數據，小青蛙打開了珍藏已久的視頻網站來學習：青蛙愛學習

在該視頻網站上，小青蛙沉迷其中無法自拔，額，呸呸。緩過神來，發現了一個很好的視頻。小青蛙幽默的說：快進我的收藏夾吃灰去吧。

小青蛙向來都不是一個收藏從未停止，學習從未開始的青蛙。它模仿着視頻建了一個 SpringBoot 項目。

此時，小青蛙想為什麼要勾選 Lombok 呢，因為它可以簡化類，並且提供了 log 等功能。

之後小青蛙為了連上 Mysql 和 Redis 就開始配置 application.properties 文件：

# 數據源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=lemon@mango

# Redis 配置
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.shutdown-timeout=100

配置好該文件后，需要 redisTemplate 模板 Bean，因為自動配置的 redisTemplate Bean 沒有提供序列化操作：(因為是入門版的，所以這樣最好理解)

package com.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
                template.setConnectionFactory(factory);
                GenericJackson2JsonRedisSerializer genericJsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
                template.setKeySerializer(new StringRedisSerializer());
                template.setValueSerializer(genericJsonRedisSerializer);
                template.setHashKeySerializer(genericJsonRedisSerializer);
                template.setHashValueSerializer(genericJsonRedisSerializer);
                template.afterPropertiesSet();
                return template;
    }
}

至此就整合完成了，小青蛙心想這就完事了？！！！，不信？那就來演示一下：(先建一個簡單的類測試一下)

package com.test.serviceImpl;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
public class JustForTest {
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    public void test(String username) {
        
        if(redisTemplate.hasKey(username)) {
            log.info((String)redisTemplate.opsForValue().get(username));
            log.info("get value from redis");
        }else {
            String password = "password";
            log.info(password);
            log.info("get value from mysql");
            log.info("set value to redis");
            redisTemplate.opsForValue().set(username, password);
        }
        
    }

}

package com.test;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.beans.factory.annotation.Autowired;
import com.test.serviceImpl.JustForTest;

@SpringBootTest
class TestApplicationTests {
    
    @Autowired
    private JustForTest justFortest;

    @Test
    void contextLoads() {
        justFortest.test("username");
    }
}

哦嚯，報錯了，原來是 pom.xml 中少了 commons.pool 依賴，咱給它加上：

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

再來一次：

再再來一次：

可以看到確實存入 Redis 了，小青蛙便去 Redis 數據庫中看看有沒有:

事實證明確實整合完畢了，小青蛙仍然表示不解，說好的是SpringBoot、Mybatis、Redis的整合呢，怎麼只看到 Redis 的？

小青蛙剛這麼想，然後視頻里就說了，心急吃不了熱豆腐，需要慢慢來。緊接着，小青蛙就看到了完整的項目結構：

為了讓青蛙們只關注有關整合的部分，視頻里僅僅只給出 serviceImpl 中的代碼:

package com.demo.serviceImpl;

import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.beans.factory.annotation.Autowired;
import com.demo.pojo.SimpleUser;
import com.demo.dao.SimpleUserDao;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
@SuppressWarnings({"rawtypes","unchecked"})
public class SimpleUserServiceImpl implements UserDetailsService {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private SimpleUserDao userDao;
    @Override 
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // TODO Auto-generated method stub
        if(redisTemplate.opsForHash().hasKey("user",username)) {
            SimpleUser user = (SimpleUser)redisTemplate.opsForHash().get("user",username);
            return new User(user.getUsername(),user.getPassword(),user.getAuthorities());
        }else {
            SimpleUser user = userDao.findUserByUsername(username);
            if(user != null) {
                redisTemplate.opsForHash().put("user", "username", user);
                return new User(user.getUsername(),user.getPassword(),user.getAuthorities());
            }else {
                throw new UsernameNotFoundException("Username or Password is not correct");
            }
        }
    }
    
    public int addSimpleUser(SimpleUser user) {
        user.setPassword(new BCryptPasswordEncoder().encode(user.getPassword()));
        return userDao.addSimpleUser(user);
    }
}

和上面測試的簡單小例子相似，僅僅是把 String 換成了對象。小青蛙對 Mysql 的表結構和Redis中存入的數據比較感心趣：

由於對 String 類型帶有 ” 符號，所以需要對其進行轉義。

小青蛙是一個有分享精神的蛙，每次它覺得有價值的東西，它都會分享給它的朋友們，項目地址為：GitHub

小青娃逐漸的弄懂了怎麼去進行整合，但是它還是不太明白為什麼這樣就能整合，也就是 know how but don’t konw why！

小青蛙知道：萬事開頭難，但它不知道的是，後面也很難…從此，小青蛙踏上了探尋源碼的道路！呱呱呱……

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

【其他文章推薦】

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

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

※超省錢租車方案

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

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

※聚甘新

1.前言

項目中都會使用常量類文件, 這些值如果需要變動需要重新提交代碼,或者基於@Value註解實現動態刷新, 如果常量太多也是很麻煩; 那麼 能不能有更加簡便的實現方式呢?

本文講述的方式是, 一個JAVA類對應NACOS中的一個配置文件,優先使用nacos中的配置,不配置則使用程序中的默認值;

2.正文

nacos的配置如下圖所示,為了滿足大多數情況,配置了 namespace命名空間和group;

 新建個測試工程 cloud-sm.

bootstrap.yml 中添加nacos相關配置;

為了支持多配置文件需要注意ext-config節點,group對應nacos的添加的配置文件的group; data-id 對應nacos上配置的data-id

配置如下:

server:
  port: 9010
  servlet:
    context-path: /sm
spring:
  application:
    name: cloud-sm
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.100.101:8848 #Nacos服務註冊中心地址
        namespace: 1
      config:
        server-addr: 192.168.100.101:8848 #Nacos作為配置中心地址
        namespace: 1
        ext-config:
          - group: TEST_GROUP
            data-id: cloud-sm.yaml
            refresh: true
          - group: TEST_GROUP
            data-id: cloud-sm-constant.properties
            refresh: true

接下來是本文重點:

1)新建註解ConfigModule,用於在配置類上;一個value屬性;

2)新建個監聽類,用於獲取最新配置,並更新常量值

實現流程:

1)項目初始化時獲取所有nacos的配置

2)遍歷這些配置文件,從nacos上獲取配置

3)遍歷nacos配置文件,獲取MODULE_NAME的值

4)尋找配置文件對應的常量類,從spring容器中尋找 常量類 有註解ConfigModule 且值是 MODULE_NAME對應的

5)使用JAVA反射更改常量類的值

6)增加監聽,用於動態刷新

import org.springframework.stereotype.Component;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Component
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface ConfigModule {
    /**
     *  對應配置文件裏面key為( MODULE_NAME ) 的值
     * @return
     */
    String value();
}

import com.alibaba.cloud.nacos.NacosConfigProperties;
import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.client.utils.LogUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Field;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * nacos 自定義監聽
 *
 * @author zch
 */
@Component
public class NacosConfigListener {
    private Logger LOGGER = LogUtils.logger(NacosConfigListener.class);
    @Autowired
    private NacosConfigProperties configs;
    @Value("${spring.cloud.nacos.config.server-addr:}")
    private String serverAddr;
    @Value("${spring.cloud.nacos.config.namespace:}")
    private String namespace;
    @Autowired
    private ApplicationContext applicationContext;
    /**
     * 目前只考慮properties 文件
     */
    private String fileType = "properties";
    /**
     * 需要在配置文件中增加一條 MODULE_NAME 的配置,用於找到對應的 常量類
     */
    private String MODULE_NAME = "MODULE_NAME";

    /**
     * NACOS監聽方法
     *
     * @throws NacosException
     */
    public void listener() throws NacosException {
        if (StringUtils.isBlank(serverAddr)) {
            LOGGER.info("未找到 spring.cloud.nacos.config.server-addr");
            return;
        }
        Properties properties = new Properties();
        properties.put(PropertyKeyConst.SERVER_ADDR, serverAddr.split(":")[0]);
        if (StringUtils.isNotBlank(namespace)) {
            properties.put(PropertyKeyConst.NAMESPACE, namespace);
        }

        ConfigService configService = NacosFactory.createConfigService(properties);
        // 處理每個配置文件
        for (NacosConfigProperties.Config config : configs.getExtConfig()) {
            String dataId = config.getDataId();
            String group = config.getGroup();
            //目前只考慮properties 文件
            if (!dataId.endsWith(fileType)) continue;

            changeValue(configService.getConfig(dataId, group, 5000));

            configService.addListener(dataId, group, new Listener() {
                @Override
                public void receiveConfigInfo(String configInfo) {
                    changeValue(configInfo);
                }

                @Override
                public Executor getExecutor() {
                    return null;
                }
            });
        }
    }

    /**
     * 改變 常量類的 值
     *
     * @param configInfo
     */
    private void changeValue(String configInfo) {
        if(StringUtils.isBlank(configInfo)) return;
        Properties proper = new Properties();
        try {
            proper.load(new StringReader(configInfo)); //把字符串轉為reader
        } catch (IOException e) {
            e.printStackTrace();
        }
        String moduleName = "";
        Enumeration enumeration = proper.propertyNames();
        //尋找MODULE_NAME的值
        while (enumeration.hasMoreElements()) {
            String strKey = (String) enumeration.nextElement();
            if (MODULE_NAME.equals(strKey)) {
                moduleName = proper.getProperty(strKey);
                break;
            }
        }
        if (StringUtils.isBlank(moduleName)) return;
        Class curClazz = null;
        // 尋找配置文件對應的常量類
        // 從spring容器中 尋找類的註解有ConfigModule 且值是 MODULE_NAME對應的
        for (String beanName : applicationContext.getBeanDefinitionNames()) {
            Class clazz = applicationContext.getBean(beanName).getClass();
            ConfigModule configModule = (ConfigModule) clazz.getAnnotation(ConfigModule.class);
            if (configModule != null && moduleName.equals(configModule.value())) {
                curClazz = clazz;
                break;
            }
        }
        if (curClazz == null) return;
        // 使用JAVA反射機制 更改常量
        enumeration = proper.propertyNames();
        while (enumeration.hasMoreElements()) {
            String key = (String) enumeration.nextElement();
            String value = proper.getProperty(key);
            if (MODULE_NAME.equals(key)) continue;
            try {
                Field field = curClazz.getDeclaredField(key);
                //忽略屬性的訪問權限
                field.setAccessible(true);
                Class<?> curFieldType = field.getType();
                //其他類型自行拓展
                if (curFieldType.equals(String.class)) {
                    field.set(null, value);
                } else if (curFieldType.equals(List.class)) { // 集合List元素
                    field.set(null, JSONUtils.parse(value));
                } else if (curFieldType.equals(Map.class)) { //Map
                    field.set(null, JSONUtils.parse(value));
                }
            } catch (NoSuchFieldException | IllegalAccessException e) {
                LOGGER.info("設置屬性失敗:{} {} = {} ", curClazz.toString(), key, value);
            }
        }
    }

    @PostConstruct
    public void init() throws NacosException {
        listener();
    }
}

 3.測試

1)新建常量類Constant,增加註解@ConfigModule(“sm”),盡量測試全面, 添加常量類型有 String, List,Map

@ConfigModule("sm")
public class Constant {

    public static volatile String TEST = new String("test");

    public static volatile List<String> TEST_LIST = new ArrayList<>();
    static {
        TEST_LIST.add("默認值");
    }
    public static volatile Map<String,Object> TEST_MAP = new HashMap<>();
    static {
        TEST_MAP.put("KEY","初始化默認值");
    }
    public static volatile List<Integer> TEST_LIST_INT = new ArrayList<>();
    static {
        TEST_LIST_INT.add(1);
    }
}

2)新建個Controller用於測試這些值

@RestController
public class TestController {

    @GetMapping("/t1")
    public Map<String, Object> test1() {
        Map<String, Object> result = new HashMap<>();

        result.put("string" , Constant.TEST);
        result.put("list" , Constant.TEST_LIST);
        result.put("map" , Constant.TEST_MAP);
        result.put("list_int" , Constant.TEST_LIST_INT);
        result.put("code" , 1);
        return result;
    }
}

3)當前nacos的配置文件cloud-sm-constant.properties為空

 4)訪問測試路徑localhost:9010/sm/t1,返回為默認值

{
    "code": 1,
    "string": "test",
    "list_int": [
        1
    ],
    "list": [
        "默認值"
    ],
    "map": {
        "KEY": "初始化默認值"
    }
}

5)然後更改nacos的配置文件cloud-sm-constant.properties;

 6)再次訪問測試路徑localhost:9010/sm/t1,返回為nacos中的值

{
    "code": 1,
    "string": "12351",
    "list_int": [
        1,
        23,
        4
    ],
    "list": [
        "123",
        "sss"
    ],
    "map": {
        "A": 12,
        "B": 432
    }
}

4.結語

這種實現方式優點如下:

1)動態刷新配置,不需要重啟即可改變程序中的靜態常量值

2)使用簡單,只需在常量類上添加一個註解

3)避免在程序中大量使用@Value,@RefreshScope註解

 不足:

此代碼是個人業餘時間的想法,未經過生產驗證,實現的數據類型暫時只寫幾個,其餘的需要自行拓展

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

【其他文章推薦】

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

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

※回頭車貨運收費標準

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

※超省錢租車方案

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

※聚甘新

平台是一套完整的服務。也是一套內部自洽的系統。核心在於分離，業務與通用服務隔離，業務與通用功能隔離。

目標：

• 對需求方： 快速響應。可以敏捷地進行需求迭代。

• 對第三方業務方： 以產品的方式提供服務。所見即所得。所有功能對業務方透明。

• 對測試方： 簡易明了的測試方式。利於自動化測試，灰度測試。

• 對運維方： 持續集成，自動化編排，自動化部署。

• 數據方： 提供多維度，詳盡的服務數據。可以給數據方提供簡便的數據分析。

• 內部開發： 敏捷開發。迅速集成。

實現：

• 如何實現需求的快速響應？
  明確的方向，清晰的邊界。確認通用語言，核心領域。敏捷開發，快速迭代。AB 測試。

• 如何為第三方提供產品式的服務？

  所見即所得。詳盡的文檔。第三方調試平台，第三方管理平台。

• mock 服務，自動化測試，swagger 文檔。

• Devops，CI，DI 等持續集成，服務監控。

• 業務數據與分析數據異構存儲。提供易於分析的數據服務。

• 組內服務負責制度，人類最佳的合作人數是 2-3 人。所以兩人維護一個項目，一人主導，一人輔助，兩人交叉合作是一個很好的團隊合作模式。如圖形成一個網狀模式(紅色線代表主導，黑色線輔助)。這樣每一個項目都將有兩個熟悉的人。

原則

1. 單一職責。
2. 業務關注業務，功能關注功能。
3. 確認邊界，確認核心領域。
4. 所見即所得。

實施

如何推進業務開發快速響應？

1. 抽離變化與不變。形成基礎服務

   如下面一套用戶體系，將服務抽離，將變與不變隔離。

   用戶 api： 主要提供用戶相關的接口，變化大，更偏向於業務；

   用戶中心： 主要管理用戶核心領域，變動不大，需穩定高可用的服務；

   鑒權授權中心： 變動不大，主要管理用戶憑證核心領域；

1. 抽離通用功能。

   那些非業務的通用功能應隔離於業務之外：組件化，工具化，服務化。

   如來源監控，接口限流，日誌分析，應用監控，服務依賴，配置管理，系統部署等（業務人員不必關心這些功能相關的事情，只需要關注於具體的業務領域）。關注點分離。

   如上面所涉及的，從Spring Cloud的各大組件可以看出，最終的方案都將走上相近的道路。

1. 領域上下文劃分。劃分微服務項目。業務隔離，數據去中心化。服務組件化。

   Spring cloud 技術棧：

   • 服務治理： 註冊中心，服務調用，衍生的容錯（熔斷器）
   • api 網關： 來源監控，接口限流(Spring Cloud gateway、zuul)
   • **配置中心： ** 配置管理(Apollo)
   • 自動化部署： Jenkins、docker、k8s
   • 日誌與監控： prometheus、influxdb、skywalking、elk
   • 數據可視化： druid、kylin、superset

1. 細節管控

   接口版本管理， gitflow 管理，項目迭代 release 版本管理，標準化，敏捷開發。

歡迎關注我的公眾號。

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

【其他文章推薦】

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

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

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

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

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

※聚甘新

1. Redis簡介

Redis（Remote Dictionary Server )，即遠程字典服務，是一個開源的使用ANSI C語言編寫、支持網絡、可基於內存亦可持久化的日誌型、Key-Value 數據庫，並提供多種語言的API。Redis 是一個高性能的key-value數據庫。 redis的出現，在部分場合可以對關係數據庫起到很好的補充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客戶端，使用很方便。

Redis支持主從同步。數據可以從主服務器向任意數量的從服務器上同步，從服務器可以是關聯其他從服務器的主服務器。這使得Redis可執行單層樹複製。存盤可以有意無意的對數據進行寫操作。由於完全實現了發布/訂閱機制，使得從數據庫在任何地方同步樹時，可訂閱一個頻道並接收主服務器完整的消息發布記錄。同步對讀取操作的可擴展性和數據冗餘很有幫助。

redis的key都是字符串String類型，它的value是多樣化的，如下圖：

2. Redis的五種數據類型

2.1 字符串對象(String)

字符串對象的模型：

redis底層提供了三種不同的數據結構實現字符串對象，根據不同的數據自動選擇合適的數據結構。這裏的字符串對象並不是指的純粹的字符串，数字也是可以的。

• int：當數據是long類型的整数字符串時，底層使用long類型的整數實現。這個值會直接存儲在字符串對象的ptr屬性中，同時OBJECT ENCODING為int。

• raw：當數據為長度大於44字節的字符串時，底層使用簡單動態字符串實現，說到這裏就不得不提下redis的簡單隨機字符串（Simple Dynamic String，SDS），SDS有三個屬性，free，len和buf。free存的是還剩多少空間，len存的是目前字符串長度，不包含結尾的空字符。buf是一個list，存放真實字符串數據，包含free和空字符。針對SDS本文不做詳細介紹，歡迎點擊SDS了解。

• embstr：當數據為長度小於44字節的字符串時，底層使用embstr編碼的簡單動態字符串實現。相比於raw，embstr內存分配只需要一次就可完成，分配的是一塊連續的內存空間。

2.2 列表對象(List)

列表對象的模型：

redis中的列表對象經常被用作消息隊列使用，底層採用ziplist和linkedlist實現。大家使用的時候當作鏈表使用就可以了。

• ziplist

  列表對象使用ziplist編碼需要滿足兩個要求，一是所有字符串長度都小於設定值值64字節（可以在配置文件中修改list-max-ziplist-value字段改變）。二是所存元素數量小於設定值512個（可以在配置文件中修改list-max-ziplist-entries字段改變）。ziplist類似與python中的list，佔用一段連續的內存地址，由此減小指針內存佔用。

  zlbytes:占內存總數

  zltail:到尾部的偏移量

  zllen:內部節點數

  node:節點

  zlend:尾部標識

  previous_entry_length:前一節點的長度

  encoding:數據類型

  content:真實數據

  遍歷的時候會根據zlbytes和zltail直接找到尾部節點nodeN，然後根據每個節點的previous_entry_length反向遍歷。增加和刪除節點會導致其他節點連鎖更新，因為每個節點都存儲了前一節點的長度。

• linkedlist

  linkedlist有三個屬性，head，tail和len。head指向鏈表的頭部，tail指向鏈表的尾部，len為鏈表的長度。

2.3 哈希類型對象(Hash)

哈希類型對象的模型：

redis的value類型hash類型，其實就是map類型，就是在值的位置放一個map類型的數據。大家想詳細了解一下，可以參考一下這篇文章：https://www.jianshu.com/p/658365f0abfc 。

2.4 集合對象(Set)

集合對象類型的模型：

Set類型的value保證每個值都不重複。

redis中的集合對象底層有兩種實現方式，分別有整數集合和hashtable。當所有元素都是整數且元素數小於512（可在配置文件中set-max-intset-entries字段配置）時採用整數集合實現，其餘情況都採用hashtable實現。hashtable請移駕上文鏈接查閱，接下來介紹整數集合intset。intset有三個屬性，encoding：記錄数字的類型，有int16，int32和int64等，length：記錄集合的長度，content：存儲具體數據。具體結構如下圖：

2.5 有序集合對象

有序集合對象(zset)和集合對象(set)沒有很大區別，僅僅是多了一個分數(score)用來排序。

redis中的有序集合底層採用ziplist和skiplist跳錶實現，當所有字符串長度都小於設定值值64字節（可以在配置文件中修改list-max-ziplist-value字段改變），並且所存元素數量小於設定值512個（可以在配置文件中修改list-max-ziplist-entries字段改變）使用ziplist實現，其他情況均使用skiplist實現，跳躍表的實現原理這裏偷個懶，給大家推薦一篇寫的非常好的博客，點擊查看跳躍表原理。

3. Redis的安裝

可以去官網或者中文網下載Redis。redis的windows版本現在已經不更新了，所以我們安裝redis的6.0.3版本，這個版本支持的東西很多，在此次教程中，我們只對redis的五種數據類型做解釋和學習。

官網：https://redis.io/

中文網：https://www.redis.net.cn/

本教程安裝的redis版本為6.0.3版本，redis使用C語言編寫的，CentOS7的gcc自帶版本為4.8.5，而redis6.0+需要的gcc版本為5.3及以上，所以需要升級gcc版本。

下載Linux版本的tar.gz包，解壓以後進入解壓產生的包：

cd redis-6.0.3

發現沒有bin目錄，這裏需要通過make進行安裝。

# 先檢查gcc的環境 
gcc -v 
# 查看gcc版本 
yum -y install centos-release-scl 
# 升級到9.1版本 
yum -y install devtoolset-9-gcc devtoolset-9-gcc- c++ devtoolset-9-binutils 

scl enable devtoolset-9 bash 
#以上為臨時啟用，如果要長期使用gcc 9.1的話： 
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile 
# 進入redis解壓文件 
make 
# 6.0的坑，gcc版本 9.0 以上
# 等待完畢

執行完make操作之後，就可以在redis目錄看到src目錄了。進入src目錄后就可以看到redis-server和redis-cli。

這裏建議將Redis的配置文件複製，保留一份原生的配置文件。

redis的配置大家可以在網上搜一下常用的配置，在這裏給大家推薦一個常用的配置，比較詳細：

https://blog.csdn.net/ymrfzr/article/details/51362125

到這裏redis就可以啟動並且正常訪問了。

注意：一定要將redis的IP地址綁定註釋掉，允許所有的IP地址訪問，不然我們從Windows訪問就訪問不了。

註釋掉下面的這一行：

同時關閉Redis的服務保護模式，將protected-mode設置為no。如下：

4. Spring Boot 整合 Redis

• 4.1 搭建工程，引入依賴

  搭建工程的操作我這裏就不在寫出來了。直接上pom.xml：

  <!--springboot父工程-->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.2.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>
  
  <dependencies>
      <!--springboot-web組件-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
          <version>2.2.2.RELEASE</version>
      </dependency>
      <!--redis整合springboot組件-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
          <version>2.3.0.RELEASE</version>
      </dependency>
      <!--lombok組件-->
      <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.18.10</version>
      </dependency>
  </dependencies>
  

• 4.2 redis的配置

  項目的配置文件，application.yml：

  butterflytri:
    host: 127.0.0.1
  server:
    port: 8080 # 應用端口
    servlet:
      context-path: /butterflytri # 應用映射
  spring:
    application:
      name: redis # 應用名稱
    redis:
      host: ${butterflytri.host} # redis地址
      port: 6379 # redis端口，默認是6379
      timeout: 10000 # 連接超時時間（ms）
      database: 0 # redis默認情況下有16個分片，這裏配置具體使用的分片，默認是0
      jedis: # 使用連接redis的工具-jedis
        pool:
          max-active: 8 # 連接池最大連接數（使用負值表示沒有限制） 默認 8
          max-wait: -1 # 連接池最大阻塞等待時間（使用負值表示沒有限制） 默認 -1
          max-idle: 8 # 連接池中的最大空閑連接 默認 8
          min-idle: 0 # 連接池中的最小空閑連接 默認 0
  

  另外還有額外的配置類RedisConfig.java：

  package com.butterflytri.config;
  
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.data.redis.connection.RedisConnectionFactory;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  import org.springframework.data.redis.serializer.RedisSerializer;
  import org.springframework.data.redis.serializer.StringRedisSerializer;
  
  /**
   * @author: WJF
   * @date: 2020/5/24
   * @description: RedisConfig
   */
  
  @Configuration
  public class RedisConfig {
  
      /**
       * redis鍵值對的值的序列化方式：通用方式
       * @return RedisSerializer
       */
      private RedisSerializer redisValueSerializer() {
          return new GenericJackson2JsonRedisSerializer();
      }
  
      /**
       * redis鍵值對的健的序列化方式：所有的健都是字符串
       * @return RedisSerializer
       */
      private RedisSerializer redisKeySerializer() {
          return new StringRedisSerializer();
      }
  
      @Bean("redisTemplate")
      public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
          RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
          redisTemplate.setConnectionFactory(redisConnectionFactory);
          redisTemplate.setKeySerializer(redisKeySerializer());
          redisTemplate.setValueSerializer(redisValueSerializer());
          return redisTemplate;
      }
  
  }
  

• 4.3 redisTemplate的使用

  對value類型的值的CRUD：

  ValueServiceImpl.java：

  package com.butterflytri.service.impl;
  
  import com.butterflytri.service.ValueService;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Service;
  
  import javax.annotation.Resource;
  
  /**
   * @author: WJF
   * @date: 2020/5/27
   * @description: ValueServiceImpl
   */
  @Service
  public class ValueServiceImpl implements ValueService {
  
      @Resource
      private RedisTemplate<String, Object> redisTemplate;
  
      @Override
      public void addValue(String key, Object value) {
          redisTemplate.opsForValue().set(key,value);
      }
  
      @Override
      public Object get(String key) {
          return redisTemplate.opsForValue().get(key);
      }
  
      @Override
      public Object update(String key, Object newValue) {
          return redisTemplate.opsForValue().getAndSet(key,newValue);
      }
  
      @Override
      public void delete(String key) {
          redisTemplate.delete(key);
      }
  }	
  

  對List類型的值的CRUD：

  這裏我加了枚舉類型用來控制增加的位置，因為List類型對應的是鏈表。

  ListServiceImpl.java：

  package com.butterflytri.service.impl;
  
  import com.butterflytri.enums.OpsType;
  import com.butterflytri.service.ListService;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Service;
  
  import javax.annotation.Resource;
  import java.util.List;
  
  /**
   * @author: WJF
   * @date: 2020/5/28
   * @description: ListServiceImpl
   */
  @Service
  public class ListServiceImpl implements ListService {
  
      @Resource
      private RedisTemplate<String, Object> redisTemplate;
  
      @Override
      public void addList(String key, List<Object> list, OpsType type) {
          switch (type) {
              case RIGHT:
                  redisTemplate.opsForList().rightPushAll(key, list);
                  break;
              case LEFT:
                  redisTemplate.opsForList().leftPushAll(key, list);
                  break;
              default:
                  throw new RuntimeException("type不能為null");
          }
      }
  
      @Override
      public void add(String redisKey, Object value, OpsType type) {
          switch (type) {
              case RIGHT:
                  redisTemplate.opsForList().rightPush(redisKey, value);
                  break;
              case LEFT:
                  redisTemplate.opsForList().leftPush(redisKey, value);
                  break;
              default:
                  throw new RuntimeException("type不能為null");
          }
      }
  
      @Override
      public List<Object> get(String key) {
          return redisTemplate.opsForList().range(key, 0, -1);
      }
  
      @Override
      public Object update(String key, Object value, Integer index) {
          Object obj = redisTemplate.opsForList().index(key, index);
          redisTemplate.opsForList().set(key,index,value);
          return obj;
      }
  
      @Override
      public void delete(String key) {
          redisTemplate.delete(key);
      }
  
      @Override
      public void deleteValue(String redisKey, OpsType type) {
          switch (type) {
              case RIGHT:
                  redisTemplate.opsForList().rightPop(redisKey);
                  break;
              case LEFT:
                  redisTemplate.opsForList().leftPop(redisKey);
                  break;
              default:
                  throw new RuntimeException("type不能為null");
          }
      }
  }
  

  對Hash類型的值的CRUD:

  hash類型是我們使用最常用的類型。

  HashServiceImpl.java:

  package com.butterflytri.service.impl;
  
  import com.butterflytri.service.HashService;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Service;
  
  import javax.annotation.Resource;
  import java.util.Map;
  
  /**
   * @author: WJF
   * @date: 2020/5/28
   * @description: HashServiceImpl
   */
  @Service
  public class HashServiceImpl implements HashService {
  
      @Resource
      private RedisTemplate<String, Object> redisTemplate;
  
      @Override
      public void addHashAll(String key, Map<String, Object> value) {
          redisTemplate.opsForHash().putAll(key, value);
      }
  
      @Override
      public void addHash(String redisKey, String key, Object value) {
          redisTemplate.opsForHash().put(redisKey, key, value);
      }
  
      @Override
      public Object get(String redisKey, String key) {
          return redisTemplate.opsForHash().get(redisKey, key);
      }
  
      @Override
      public Object update(String redisKey, String key, Object value) {
          Object obj = this.get(redisKey, key);
          this.delete(redisKey,key);
          redisTemplate.opsForHash().put(redisKey, key, value);
          return obj;
      }
  
      @Override
      public void delete(String redisKey, String key) {
          redisTemplate.opsForHash().delete(redisKey, key);
      }
  
      @Override
      public void deleteAll(String redisKey) {
          redisTemplate.delete(redisKey);
      }
  }
  

  對Set的值的CRUD：

  package com.butterflytri.service.impl;
  
  import com.butterflytri.service.SetService;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Service;
  
  import javax.annotation.Resource;
  import java.util.Set;
  
  /**
   * @author: WJF
   * @date: 2020/5/28
   * @description: SetServiceImpl
   */
  @Service
  public class SetServiceImpl implements SetService {
  
      @Resource
      private RedisTemplate<String, Object> redisTemplate;
  
  
      @Override
      public void addAll(String key, Set<Object> set) {
          redisTemplate.opsForSet().add(key,set);
      }
  
      @Override
      public void add(String key, Object value) {
          redisTemplate.opsForSet().add(key,value);
      }
  
      @Override
      public Set<Object> findAll(String key) {
          return redisTemplate.opsForSet().members(key);
      }
  
      @Override
      public void deleteValue(String key, Object value) {
          redisTemplate.opsForSet().remove(key,value);
      }
  
      @Override
      public void delete(String key) {
          redisTemplate.delete(key);
      }
  }
  

  對ZSet類型的值的CRUD：

  package com.butterflytri.service.impl;
  
  import com.butterflytri.service.SortedSetService;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Service;
  
  import javax.annotation.Resource;
  import java.util.LinkedHashSet;
  
  /**
   * @author: WJF
   * @date: 2020/5/28
   * @description: SortedSetServiceImpl
   */
  @Service
  public class SortedSetServiceImpl implements SortedSetService {
  
      @Resource
      private RedisTemplate<String, Object> redisTemplate;
  
      @Override
      public void add(String key, String value, Double score) {
          redisTemplate.opsForZSet().add(key, value, score);
      }
  
      @Override
      public LinkedHashSet<Object> findAll(String key) {
          return (LinkedHashSet<Object>) redisTemplate.opsForZSet().range(key,0,-1);
      }
  
      @Override
      public Long count(String key, Double scoreFrom, Double scoreTo) {
          return redisTemplate.opsForZSet().count(key,scoreFrom,scoreTo);
      }
  
      @Override
      public LinkedHashSet<Object> findByScore(String key, Double scoreFrom, Double scoreTo) {
          return (LinkedHashSet<Object>) redisTemplate.opsForZSet().rangeByScore(key,scoreFrom,scoreTo);
      }
  
      @Override
      public Long rank(String key, Object value) {
          return redisTemplate.opsForZSet().rank(key,value);
      }
  
      @Override
      public void remove(String key, String value) {
          redisTemplate.opsForZSet().remove(key,value);
      }
  
      @Override
      public void delete(String key) {
          redisTemplate.delete(key);
      }
  
  }
  

  redis的Java客戶端有很多，在這裏我們使用的是jedis，還有一個很好的Java語言的客戶端叫lettuce，大家可以去了解一下，Spring從不重複造輪子，只會簡化輪子的使用，redisTemplate就是一個超級簡單的使用實現。到這裏redis整合Spring Boot 就結束了。

5. 項目地址

本項目傳送門：

• GitHub —> spring-data-redis
• Gitee —> spring-data-redis

此教程會一直更新下去，覺得博主寫的可以的話，關注一下，也可以更方便下次來學習。

• 作者：Butterfly-Tri
• 出處：Butterfly-Tri個人博客
• 版權所有，歡迎保留原文鏈接進行轉載

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

【其他文章推薦】

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

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

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

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

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

※聚甘新

前言

我們當然希望能夠更快的完成我們的工作，這樣我們才能有更多的時間做其他的事情，比如說測試、學習、放鬆。

背景

軟件一般也就這麼幾個方面的工作要做，增、刪、改、查。如果歸結到頁面上來說，那麼無非也就這麼幾個頁面Form頁面（增）、列表頁面（查、刪）、編輯頁面（改）。很大程度上，你的項目就是由不同的實體的這麼幾個頁面組裝起來的。既然他們都是這麼幾個頁面，那麼，我們是不是可以考慮針對這幾個頁面進行抽象呢？然後使用數據描述這幾個頁面的行為。

效果

經典倒敘，先上效果圖

列表頁面

創建頁面

目前就簡單實現了列表頁面和創建頁面。編輯頁面，跟創建頁面太像了。暫時還沒有實現相關內容，不過，這個不是很重要了。

實現過程

需求分析

其實，每個頁面都是存在固定的路數的。

比如說：

列表頁面裡邊主要存在這麼幾個參數：列表名、列表頭上的按鈕、列表的表頭、列表內容、列表每一行中的操作、分頁控件。

表單頁面列表主要存在這麼幾個參數：表單名、表單內容項。

主要的參數出現的位置都是固定的。但是什麼地方出現什麼內容則是可以變化的，一般情況下，我們都是通過代碼，一遍一遍的重寫這些頁面，然後來達到不同的應用之間的變化的目的。其實我們是可以通過數據來描述他們的。比如說向下面這樣。

列表頁面的定義

Form表單頁面的定義

原始數據的定義

然後將這些定義好的屬性通過後端渲染到頁面上。

就可以達到，前邊展示的這種效果了。

數據存儲

因為數據類型是自定義的，所以數據存儲的字段也是可以自己隨便預設的。然後系統就可以直接支持這一數據類型。在這個Demo裡邊，我是簡單粗暴的使用了文件存儲Json文件的方式來進行保存的數據。

其實應該鏈接數據庫的。不過我在Demo項目裡邊留下了相關的接口，只要再實現一個數據庫版本的實例就可以無縫對接了。

其實

當然了這隻是他的最初級的形態，因為現在寫的配置文件都是通過手寫來實現，將來可以做一個編輯器。並且可以實時看到調整過的效果。

其實這個做法，是來源於PaaS項目中的一個很小很小的功能塊。真正的PaaS項目這一整套東西都是在線上直接編輯看效果的。

最後

系列

這個項目將來會融入到我寫的PaaS Demo中作為前端展示部分。 系列的目錄在 https://juejin.im/post/5eca2a186fb9a047e96b2884 這個部分會一點點完善。

開源

雖然東西不大，但是還是希望能給你一點點啟發。 項目地址 https://gitee.com/anxin1225/Dov.GenericWeb

簡單的體驗

部署到雲端了，可以簡單體驗一下。

http://gw.ash50p.com/Generic/Meeting.Record/List

轉載莫忘原文地址：https://juejin.im/post/5eeb85b8e51d45740850f755

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

【其他文章推薦】

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

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

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

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

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

※聚甘新