面試官：淦！0202年你還不知道面向對象？

發佈日期: 2020-11-30 作者: admin

2020年6月13日多雲轉暴雨️

I’m sad,tired,negative,powerless,miss,lonely fine 🙂

那你回去等通知吧

面試官：我看你簡歷上說，你的主要編程語言是Java，偶爾也用Python，那麼你可以說一下這兩個的相同點在什麼地方嗎？

山禾：它們都是高級程序設計語言，都是面向對象的語言。

面試官：那你講講你是怎麼理解面向對象的吧。

山禾：emmm。。封裝，繼承，多態是面向對象的三大特徵。

面試官：還有其他要補充的嗎？

山禾：沒了

面試官：那你回去等通知吧。

是什麼

痛定思痛，挫折只會讓我變得更強，奧利給！下面開始進入正文，首先我們需要知道面向對象是什麼？

面向對象，顧名思義，是面向對象，也就是說單身狗是不配使用面向對象的編程語言的（當然只是開個玩笑，逃）。

對象，就是把現實世界中的實物映射抽象到虛擬世界中，把實物的屬性和行為，通過代碼的方式表達出來。然後通過設計對象的數據結構（屬性），然後使用算法進行行為的模擬（方法），就完成了從現實到虛擬的一個映射。

實體	對象	類
屬性	數據結構	變量
行為	算法	方法

與面向對象經常拿來對比的就是面向過程編程，那麼他們之間的區別在什麼地方呢？

面向過程和面向對象

面向過程編程，打個比方，我們買過的一般的玩具（變形金剛），我們必須要按照它說明書上的步驟，一步一步的去組裝，才能得到最後的玩具，如果我們想要一個新的玩具，就要去商場買一個新的，然後按照說明書的順序一步一步的組裝。

而面向對象編程，就可以理解為積木，沒有一個固定的拼裝方式，我們可以發揮自己的想象力，去自由的拼裝和組裝，同樣的模塊在不同的地方可以起到不同的作用（多態），一塊兒積木就是一個最小的單位，我們不用去關心積木是怎麼造的（封裝）。也可以用多個對象組裝起來去拼裝成一個新的對象（繼承）。大大的方便了我們的設計，不再拘泥於過程，極大程度上的放飛了生產力和效率。

為什麼

我們剛剛已經了解了面向對象是什麼，下面我們來說一下，為什麼要用面向對象編程

首先從理解角度上來說，它符合我們對現實世界的認知習慣，更容易去理解、實現和設計我們的需求。
其次從軟件設計的角度上來說，行為的實現對於外部是完全封閉的，只需要提供對應的接口就可以獲得相應的結果，降低了代碼與代碼之間的耦合度。符合我們高內聚，低耦合的設計理念。優雅，客觀，層次分明，像積木一樣，可以方便的實現插拔和維護，對象組合而成的模塊化和服務化，更是大大擴展了系統的伸縮性，便於維護、擴展和復用。這也是為什麼越來越多的編程語言選擇向這個方向去靠攏（ TypeScript說的就是你

怎麼用

剛剛我一直忍住，沒有去提面向對象的三大特性：封裝、繼承和多態，我相信我們有一些經驗的開發人員來說，這三個詞語是再熟悉不過了。下面，我通過代碼的方式，來看看這三個特性在代碼中的模擬應用。

封裝

@Data
public class Uzi {

    // 选手類型
    private String type;
    // 选手最擅長英雄
    private String bestHero;
    // 选手狀態
    private Status status;
    
    public void play() {
        status.say();
    }
}

public class Status {
   public void say(){}
}

上面是一段非常簡單的代碼，我定義了一個很簡單的類，裏面的name，type，bestHero對於我們來說都是一個包裝在盒子里的東西。比如：

    Uzi uzi = new Uzi();
    uzi.setType("ADC");
    uzi.setBestHero("孫尚香");

我們看到的Uzi可能就是一個主玩孫尚香的職業ADC选手（狗頭保命，我啥都不知道），他怎麼玩的，我們不需要知道，我們只需要知道他這樣的一名选手就可以了。這就是封裝的魅力：

隱藏了實現的細節，提供對外的訪問方式。
外部如果想要訪問，必須經過這個方法。

繼承

看完了封裝，下面我們來看繼承，我們分別用三個狀態去繼承Status類：

public class ShunFeng extends Status {
    
    @Override
    public void say(){
        System.out.println("順風狂小狗");
    }
}
public class NiFeng extends Status {
    
    @Override
    public void say(){
        System.out.println("逆風簡自豪");
    }
}

public class JueJing extends Status {
    
    @Override
    public void say(){
        System.out.println("絕境Uzi");
    }
}

關鍵字extends表示正在構造的新類派生於一個已經存在類。這個已經存在的類被稱為父類（超類，基類）；新創建的類被稱為子類。在通過擴展父類定義子類的時候，僅僅需要指齣子類和父類的不同之處。因此在設計類的時候，應該將通用的方法放在父類中，而將具有特殊用途的方法放在子類中。

我們只是在父類Status中定義了say方法，然後三種不同的類去繼承這個類，然後實現方法，這樣就體現出了面向對象在設計上的可擴展性，但是需要注意的是，繼承會破壞封裝，我們需要謹慎使用，盡量使用一些設計模式去避免繼承，合理使用，才能體現出它的優勢～

說完了繼承，接下來就要去說多態了。

多態

在說多態之前，我們先來看一下代碼：

public class Test {
    public static void main(String[] args) {
        //uzi1
        Uzi uzi1 = new Uzi();
        ShunFeng shunFeng = new ShunFeng();
        uzi1.setStatus(shunFeng);
        //uzi2
        Uzi uzi2 = new Uzi();
        NiFeng niFeng = new NiFeng();
        uzi2.setStatus(niFeng);
        //uzi3
        Uzi uzi3 = new Uzi();
        JueJing jueJing = new JueJing();
        uzi3.setStatus(jueJing);
        
        //uzis
        Uzi[] uzis = {uzi1,uzi2,uzi3};
        // 多態
        for (Uzi uzi : uzis) {
            uzi.play();
        }
    }
}

運行程序的結果：（TMD，淚目，青結）

所謂的多態就是一個對象變量（比如上文中的status變量）可以指示多種實際類型的現象（比如status既可以引用Status對象，也可以引用它的子類ShunFeng對象）被稱為多態。在運行時候能夠自動地選擇調用哪個方法的現象被稱為動態綁定，上面打印出的語句，就說明了這一點。

後續

原來我們天天掛在口邊的面向對象，其實某種程度上來說，更像是一種哲學，一種計算機科學發展的自然規則。

如果你有學到，請給我點贊+關注，這是對一個堅持原創作者的最大支持！我是山禾，千篇一律的皮囊，萬里挑一的靈魂，一個不太一樣的寫手。

世事洞明皆學問，人情練達即文章。

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

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

C# 9.0 新特性之模式匹配簡化

發佈日期: 2020-11-30 作者: admin

閱讀本文大概需要 2 分鐘。

記得在 MS Build 2020 大會上，C# 語言開發項目經理 Mads Torgersen 宣稱 C# 9.0 將會隨着 .NET 5 在今年 11 月份正式發布。目前 .NET 5 已經到了 Preview 5 階段了，C# 9.0 也已經初具規模。忍不住激動的心情，暫停更新《C#.NET 拾遺補漏》系列幾天，先要和大家分享一下我了解到的 C# 9.0 的新特性。由於新特性比較多，所以會分成幾篇來講。這是第一篇，專講模式匹配這個特性的簡化。

模式匹配（Pattern Matching）是在 C# 7.0 引入的，是對 switch 語句的增強，可以支持實現複雜的條件匹配。下面我先用一個示例來展示一下模式匹配的一般的用法。

假如現在我們要計算各種車輛在某高速的通行費，比如有下面四種車輛，分別定義為以下四個類，各個類中定義了和通行費計算相關的屬性：

public class Car
{
    public int Passengers { get; set; }
}

public class DeliveryTruck
{
    public int GrossWeightClass { get; set; }
}

public class Taxi
{
    public int Fares { get; set; }
}

public class Bus
{
    public int Capacity { get; set; }
    public int Riders { get; set; }
}

下面用用模式匹配的方式來實現一個計算通行費的方法：

public decimal CalculateToll(object vehicle) =>
    vehicle switch
{
    Car { Passengers: 0}        => 2.00m + 0.50m,
    Car { Passengers: 1}        => 2.0m,
    Car { Passengers: 2}        => 2.0m - 0.50m,
    Car c                       => 2.00m - 1.0m,

    Taxi t => t.Fares switch
    {
        0 => 3.50m + 1.00m,
        1 => 3.50m,
        2 => 3.50m - 0.50m,
        _ => 3.50m - 1.00m
    },

    Bus b when ((double)b.Riders / (double)b.Capacity) < 0.50 => 5.00m + 2.00m,
    Bus b when ((double)b.Riders / (double)b.Capacity) > 0.90 => 5.00m - 1.00m,
    Bus b => 5.00m,

    DeliveryTruck t when (t.GrossWeightClass > 5000) => 10.00m + 5.00m,
    DeliveryTruck t when (t.GrossWeightClass < 3000) => 10.00m - 2.00m,
    DeliveryTruck _ => 10.00m,

    { } => throw new ArgumentException(message: "Not a known vehicle type", paramName: nameof(vehicle)),
    null => throw new ArgumentNullException(nameof(vehicle))
};

代碼來源於文末參考鏈接

如果上面代碼閱讀起來感覺吃力，你可以先閱讀文末參考鏈接中的第一個鏈接，關於模式匹配的詳細介紹。

實現這個業務邏輯，若在 C# 7.0 之前，需要用一堆的 if/else 來實現。有了模式匹配后，變得方便了很多，而且使用上很靈活，代碼結構也更優美。

對我來說，模式匹配是個極好的特性！但這還不夠，C# 9.0 對模式匹配的寫法做了進一步的簡化！

以上面代碼為例，模式匹配可以分為三種：簡單模式、關係模式和邏輯模式。下面分別說說 C# 9.0 對三種模式的簡化。

簡單模式

以上面 CalculateToll 方法示例代碼為例，簡單模式是這種：

vehicle switch
{
    ...
    Car c => 2.00m - 1.0m
}

我們其實可以發現，上面的變量 c 聲明了卻沒用被使用，現在 C# 9.0 中可以把它省略了：

vehicle switch
{
    ...
    Car => 2.00m - 1.0m
}

關係模式

以上面 CalculateToll 方法示例代碼為例，關係模式是通過比較（大小）關係來匹配的，對應的代碼片段如下：

DeliveryTruck t when (t.GrossWeightClass > 5000) => 10.00m + 5.00m,
DeliveryTruck t when (t.GrossWeightClass < 3000) => 10.00m - 2.00m,
DeliveryTruck _ => 10.00m,

現在 C# 9.0 可以簡寫成：

DeliveryTruck t when t.GrossWeightClass switch
{
    > 5000 => 10.00m + 5.00m,
    < 3000 => 10.00m - 2.00m,
    _ => 10.00m,
}

邏輯模式

在 C# 9.0 中，你可以通過邏輯操作符 and、or 和 not 對模式進行組合，下面是一些示例：

DeliveryTruck t when t.GrossWeightClass switch
{
    < 3000 => 10.00m - 2.00m,
    >= 3000 and <= 5000 => 10.00m,
    > 5000 => 10.00m + 5.00m,
}

not null => throw new ArgumentException($"Not a known vehicle type: {vehicle}", nameof(vehicle)),
null => throw new ArgumentNullException(nameof(vehicle))

另外，not 關鍵字還可以用來替代 if 條件判斷中的邏輯非(!)，比如：

// 原來的寫法
if (!(e is Customer)) { ... }

// 新的寫法（易讀性更好）
if (e is not Customer) { ... }

C# 9.0 還有很多其它好用的新特性，下一篇文章繼續與你分享。文章寫短一點不是因為我偷懶哈，而是為了促使大家一次性看完，方便大家在零碎時間閱讀，避免因文章太長而成為“收藏不看”系列。

敬請關注我明天下一篇關於 C# 9.0 新特性的介紹，明天不見不散。

參考：

https://bit.ly/2MNc0DJ

https://bit.ly/2UzEIwu

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

【其他文章推薦】

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

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

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

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

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

※超省錢租車方案

小師妹學JVM之:JVM的架構和執行過程

發佈日期: 2020-11-30 作者: admin

簡介
JVM是一種標準
java程序的執行順序
JVM的架構
- 類加載系統
- 運行時數據區域
- 執行引擎
總結

簡介

JVM也叫Java Virtual Machine，它是java程序運行的基礎，負責將java bytecode轉換成為適合在各個不同操作系統中運行的機器代碼並運行。今天我們和小師妹一起走進java的核心JVM，領略java在設計上的哲學。

JVM是一種標準

小師妹:F師兄,經常聽到有人說hotspot VM,這個跟JVM是什麼關係？

其實吧，JVM只是一種標準，就像是一種協議，只要是實現和滿足這種協議的都可以稱為JVM。當然，java現在是Oracle公司的，所以這些所謂的JVM標準也是由Oracle來頒布的，如果你去查看Oracle的文檔，就會發現有一個專門的Java SE Specifications欄目，這個欄目中列出了JVM的實現標準，最新的標準就是The Java Virtual Machine Specification, Java SE 14 Edition。

更多精彩內容且看：

區塊鏈從入門到放棄系列教程-涵蓋密碼學,超級賬本,以太坊,Libra,比特幣等持續更新
Spring Boot 2.X系列教程:七天從無到有掌握Spring Boot-持續更新
Spring 5.X系列教程:滿足你對Spring5的一切想象-持續更新
java程序員從小工到專家成神之路（2020版）-持續更新中,附詳細文章教程

更多內容請訪問www.flydean.com

既然JVM是一個標準，就可能有很多種實現。各大公司在滿足JVM標準的基礎上，開發了很多個不同的版本。

下面是我在維基百科中截取到的目前各個JVM的比較：

小師妹：F師兄，大家齊心協力做一個JVM不是更好嗎？為什麼分來分去的，還要重複造輪子？

有聽過Oracle和Google之間的API十年訴訟案嗎？API都不能順便用，更何況是JVM。各大廠商為了各自的利益，最終搞出了這麼多個JVM的版本。

在這些JVM中，最常用的就是HotSpot JVM了，畢竟它是Oracle的親兒子，或者可以說HotSpot JVM就是JVM的標準。

接下來就是Eclipse OpenJ9,這個是由IBM主導的JVM，一般只能跟IBM的產品一起使用的，因為有許可證限制。

java程序的執行順序

為了說明JVM的作用，我們先來回顧一下java程序的執行順序。

編寫java代碼文件比如Example.java
使用java編譯器javac將源文件編譯成為Example.class文件
JVM加載生成的字節碼文件，將其轉換成為機器可以識別的native machine code執行

JVM的架構

小師妹：F師兄，Java語言那麼多特性，最後都要在JVM中運行，JVM的架構是不是特別複雜？好怕我聽不懂。

其實吧，JVM可以分為三大部分，五大空間和三大引擎，要講起來也不是特別複雜，先看下面的總體的JVM架構圖。

從上面的圖中，我們可以看到JVM中有三大部分，分別是類加載系統，運行時數據區域和Execution Engine。

類加載系統

類加載系統分為三個階段，分別是加載，鏈接和初始化。

加載大家都很清楚了，java中有個專門的ClassLoader來負責這個事情。除了加載Class之外，ClassLoader還可以用來加載resources。

在JDK9之前，系統默認有三個類加載器，分別是：

Bootstrap ClassLoader

這個類加載器主要是加載 /jre/lib下面的rt.jar，並且這個類加載器是用C/C++來編寫的，並且它是後面Extension ClassLoader的父ClassLoader。
這個類應該在java代碼中找不到的（correct me if I am wrong!）。

Extension ClassLoader

這個類加載器主要加載JDK的擴展類 /jre/lib/ext，它的實現類是 sun.misc.Launcher$ExtClassLoader ：

static class ExtClassLoader extends URLClassLoader {
        private static volatile Launcher.ExtClassLoader instance;

        public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
            if (instance == null) {
                Class var0 = Launcher.ExtClassLoader.class;
                synchronized(Launcher.ExtClassLoader.class) {
                    if (instance == null) {
                        instance = createExtClassLoader();
                    }
                }
            }

            return instance;
        }

我們看下它的實現，實際上它創建了一個單例模式，使用的是雙重檢查加鎖，小師妹可以考慮一下怎麼使用延遲初始化佔位類的方式來重新這個類。

System ClassLoader

這個加載器是加載定義在ClassLoader中的類。它的實現類是sun.misc.Launcher$AppClassLoader，這個類的實現很長，這裏就不完整列出來了：

static class AppClassLoader extends URLClassLoader

在JDK9之後，因為引入了JPMS模塊的概念，所以類加載器變得不一樣了，在JDK9之後還是有三個內置的類加載器，分別是BootClassLoader，PlatformClassLoader和AppClassLoader：

    private static class BootClassLoader extends BuiltinClassLoader {
        BootClassLoader(URLClassPath bcp) {
            super(null, null, bcp);
        }

        @Override
        protected Class<?> loadClassOrNull(String cn, boolean resolve) {
            return JLA.findBootstrapClassOrNull(this, cn);
        }
    };

private static class PlatformClassLoader extends BuiltinClassLoader

private static class AppClassLoader extends BuiltinClassLoader

Linking階段主要做了三件事情：

Verification – 主要驗證字節碼文件的結構的正確性，如果不正確則會報LinkageError。
Preparation – 負責創建static fields，並且初始化他們的值。
Resolution – 把類型的常量池中引用的類，接口，字段和方法替換為直接引用的過程。

Initialization階段主要是調用class的父類和自身的初始化方法，來設置變量的初始值。

運行時數據區域

類加載好了，也初始化了，接下來就可以準備運行了。

運行的時候要為數據分配運行空間，這就是運行時數據區域的作用。

運行時數據區域又可以分為5個部分：

Method Area

方法區是非Heap的內存空間，主要用來存放class結構，static fields, method, method’s data 和 static fields等。方法區是在JVM啟動的時候創建的，並且在所有的線程中共享。

Run-Time Constant Pool運行時常量池是放在方法區中的，他是class文件中constant_pool的運行時表現。

注意在JDK8之前，HotSpot JVM中對方法區的實現叫做持久代Perm Gen。不過在JDK8之後，Perm Gen已經被取消了，現在叫做Metaspace。Metaspace並不在java虛擬機中，它使用的是本地內存。Metaspace可以通過-XX:MaxMetaspaceSize來控制。

Heap Area

Heap Area主要存儲類對象和數組。垃圾回收器（GC）主要就是用來回收Heap Area中的對象的。

Stack Area

因為是棧的結構，所以這個區域總是LIFO(Last in first out)。我們考慮一個方法的執行，當方法執行的時候，就會在Stack Area中創建一個block，這個block中持有對本地對象和其他對象的引用。一旦方法執行完畢，則這個block就會出棧，供其他方法訪問。

PC Registers

PC Registers主要用來對程序的執行狀態進行跟蹤，比如保存當前的執行地址，和下一步的地址等。

Native Methods

最後一個就是本地方法區了，因為JVM的底層很多都是由C/C++來實現的，這些方法的實現就構成了本地方法區。

執行引擎

執行引擎主要負責將java的字節碼翻譯成機器碼然後執行。

先看一個java字節碼的內在結構,大家可以隨便找一個編譯好的類，使用javap來進行解析：

javap -v BufferUsage

這裏不過多介紹輸出結果的含義，我們會在後面的文章中進行詳解。

這我們可以看到方法中都有一個Code片段，這些Code被稱為OpCode，是JVM可以理解的操作命令。

執行引擎中裏面又有三個部分：

Interpreter

翻譯器用來讀取上面介紹的OpCode，並將其翻譯成為機器語言。因為翻譯器需要一個命令一個命令的翻譯字節碼，所以速度會比較慢。這就是很久很久以前Java被詬病的地方。

JIT (Just-In-Time) compiler

為了解決Interpreter翻譯慢的問題，JDK引入了JIT，對於那些經常使用的代碼，JIT會將這些字節碼翻譯成為機器代碼，並直接復用這些機器代碼，從而提高了執行效率。

Garbage Collector

GC用來回收Heap Area，他是一個Daemon thread。

總結

本文介紹了JVM的總體架構信息。各個部分的細節信息會在後面的系列文章中陸續講解。歡迎大家關注小師妹系列。

本文作者：flydean程序那些事

本文鏈接：http://www.flydean.com/jvm-all-in-one/

本文來源：flydean的博客

歡迎關注我的公眾號:程序那些事，更多精彩等着您！

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

【其他文章推薦】

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

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

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

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

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

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

全網最完整的Redis入門指導

發佈日期: 2020-11-30 作者: admin

前言

本文提供全網最完整的Redis入門指導教程，下面我們從下載Redis安裝包開始，一步一步的學習使用。

下載Redis

官網提供的Redis安裝包是服務於Linux的，而我們需要在Window下使用Redis，所以，我們去下面這個網址中下載。

Redis的下載地址：https://github.com/microsoftarchive/redis/releases。

如下圖所示，Redis的windows版是由microsoftarchive提供，是微軟的一個工作小組，所以我們可以選擇完全信任，下面我們選擇最新版的Redis版本下載（可以看到，儘管是最新版本，但最後一次提交已經是2016年了）

下載完成后解壓到文件夾，得到文件如下：

重要文件講解：

redis-server.exe：Redis服務端宿主程序，運行後會啟動一個控制台窗體，該窗體是宿主程序，如關閉窗體，則Redis服務關閉。

redis-check-dump.exe：本地數據庫檢查程序。

redis-check-aof.exe：更新日誌檢查程序。

redis-benchmark.exe：性能測試，用以模擬同時由N個客戶端發送M個 SETs/GETs 查詢。

redis-cli.exe： Redis客戶端程序，服務端開啟后，可以通過該客戶端進行命令測試。（運行后，會啟動一個控制台窗體，可在控制台內輸入命令）

Windows Service Documentation.docx：Redis服務端使用文檔。

redis.windows-service.conf：Redis啟動服務默認加載的配置文件（下文會介紹如何將Redis服務已Windows服務模式啟動），雙擊redis-server.exe啟動時並不加載該文件，雙擊exe啟動時會提示未指定配置文件，使用默認配置，這個默認配置應該是exe內部編寫的。

redis.windows.conf ：Redis配置文件，其內容和redis.windows-service.conf是一模一樣的，相當於一個備份，如果希望Redis讀取的配置文件是redis.windows.conf ，則需要對Redis進行命令操作，重新設置配置文件。

了解Redis文件信息后，我們運行redis-server.exe，然後我們編寫一個C#的控制台項目訪問Redis。

Redis訪問

C#想訪問Redis需要使用開源類庫，那麼應該使用哪個類庫呢？

打開Redis的中文官網http://www.redis.cn/，在客戶端菜單下可以發現C#可用的Redis客戶端很多，如下圖：

這裏我們使用ServiceStack.Redis來訪問Redis。

創建項目

首先我們創建一個項目RedisConsole，然後在Nuget下搜索ServiceStack.Redis，如下圖：

然後創建一個RedisManager類來管理Redis，代碼如下：

using ServiceStack.Redis;
using ServiceStack.Text;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace RedisConsole
{
    /// <summary>
    /// RedisManager類主要是創建鏈接池管理對象的
    /// </summary>
    public class RedisManager
    {
        /// <summary>
        /// 綁定本機Redis
        /// </summary>
        private static string ConnStr = "localhost:6379";//password@ip:port  123@localhost:6379
        private static PooledRedisClientManager _prcm;

        
        /// <summary>
        /// 靜態構造方法，初始化鏈接池管理對象
        /// </summary>
        static RedisManager()
        {
            _prcm = CreateManager(new string[] { ConnStr }, new string[] { ConnStr });
        }
        /// <summary>
        /// 創建鏈接池管理對象
        /// </summary> 
        private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
        {
            //WriteServerList：可寫的Redis鏈接地址。
            //ReadServerList：可讀的Redis鏈接地址。
            //MaxWritePoolSize：最大寫鏈接數。
            //MaxReadPoolSize：最大讀鏈接數。
            //AutoStart：自動重啟。
            //LocalCacheTime：本地緩存到期時間，單位:秒。
            //RecordeLog：是否記錄日誌,該設置僅用於排查redis運行時出現的問題,如redis工作正常,請關閉該項。
            //RedisConfigInfo類是記錄redis連接信息，此信息和配置文件中的RedisConfig相呼應
            // 支持讀寫分離，均衡負載 
            return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
            { 
                MaxWritePoolSize = 5, // “寫”鏈接池鏈接數 
                MaxReadPoolSize = 5, // “讀”鏈接池鏈接數 
                AutoStart = true,
            },
            0,//初始化數據庫 默認有16個數據 這裏設置初始化為第0個
            50,//連接池數量
            5//連接池超時秒數
            )
            { 
                ConnectTimeout = 6000,//連接超時時間，毫秒
                SocketSendTimeout = 6000,//數據發送超時時間，毫秒
                SocketReceiveTimeout = 6000,// 數據接收超時時間，毫秒
                IdleTimeOutSecs = 60,//連接最大的空閑時間 默認是240
                PoolTimeout = 6000 //連接池取鏈接的超時時間，毫秒
            };
        }

        /// <summary>
        /// 客戶端緩存操作對象
        /// </summary>
        public static IRedisClient GetClient()
        {
            if (_prcm == null)
            {
                _prcm = CreateManager(new string[] { RedisPath }, new string[] { RedisPath });
            }
            return _prcm.GetClient();
        }
    }
 }

然後在Main函數里使用RedisManager來進行寫入和讀取，代碼如下：

static void Main(string[] args)
        { 
            var redisClient = RedisManager.GetClient(); 
            redisClient.Set<string>("Name", "Kiba518");
            redisClient.Set<int>("Age", 10000);  
            Console.WriteLine($"MyName:{redisClient.Get<string>("Name")}====MyAge:{redisClient.Get<int>("Age")}");
            redisClient.Dispose();  //釋放內存
            Console.ReadLine();
        }

運行結果如下圖所示：

可以看到，我們成功的完成了Redis的插入和讀取。

但我們不滿足於此，我們需要一個圖形管理界面更直觀的查看Redis數據庫。

下載RedisStudio。

下載地址:https://github.com/cinience/RedisStudio/releases

運行RedisStudio，連接本地Redis，如下圖：

連接成功后，點擊Data菜單，查看數據。

可以看到，我們添加的數據被寫進了第0個數據庫（Redis默認會創建16個數據庫，數據庫編號以0開頭）。

Redis的Windows服務

使用Cmd的命令窗口作為Redis的宿主進程確實有一些問題，比如關閉了就不能用了，比如不能開機自啟。為了讓Redis服務可以更好的運行，我們需要把Redis的宿主改成Windows是服務。

這件事不需要我們自行開發，redis-server.exe中已經提供了這些功能，它的Main函數會處理一些他接受的參數。

現在我們使用命令行啟動redis-server.exe。

注：使用Redis命令時，需要在先將目錄跳轉到Redis所在文件夾，如【cd/d D:\Redis-x64-3.2.100】

redis-server.exe --service-install redis.windows.conf --loglevel verbose

參數介紹：

service-install：啟動Redis服務安裝，必須是第一個參數。

redis.windows.conf：指定配置文件。

loglevel verbose：日誌級別。

CMD運行結果如下圖所示：

查看服務。

如上圖所示，服務已經成功的安裝到系統中了，右鍵就可以啟動服務了。

當然我們也可以通過命令行啟動和關閉服務，命令如下：

啟動服務命令：redis-server.exe –service-start

關閉服務命令：redis-server.exe –service-stop

CMD運行關閉服務結果如下圖：

配置密碼

我們都知道數據庫是需要密碼的，這樣才能保證安全性，不然任何一個知道你服務器IP的人只要按個端口試一遍就可以連接你的數據庫了。

Redis的數據庫密碼需要在配置文件中設置，默認是沒有密碼的。

因為上文我們配置Windows服務時，指定了redis.windows.conf文件為配置文件，所以我們現在需要在redis.windows.conf文件中配置密碼。

打開redis.windows.conf文件，搜索【# requirepass foobared】定位到配置密碼的行（配置文件中#為註釋符），然後在該行下方輸入requirepass 123456，其中123456就是數據庫的密碼了，如下圖所示：

現在我們測試一下，運行我們剛才的項目，結果如下圖所示：

可以看到，系統提示了驗證錯誤的異常。

這是因為我們上文配置的連接字符串是【localhost:6379】這裏面只有IP和端口，現在因為有了密碼所以這個字符串不在合法了。

現在我們將密碼加入進字符串，修改代碼如下：

private static string ConnStr = "123456@localhost:6379";

項目成功運行，訪問Redis數據庫成功，如下圖：

—————————————————————————————————-

代碼已經傳到Github上了，歡迎大家下載。

Github地址：https://github.com/kiba518/RedisConsole

—————————————————————————————————-

注：此文章為原創，任何形式的轉載都請聯繫作者獲得授權並註明出處！
若您覺得這篇文章還不錯，請點擊下方的【推薦】，非常感謝！

https://www.cnblogs.com/kiba/p/13085327.html

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

【其他文章推薦】

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

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

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

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

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

你必須知道的雲計算知識（下）

發佈日期: 2020-11-30 作者: admin

最近訂閱學習了《深入淺出雲計算》專欄，一口氣學完之後，做了一些總結筆記形成此文，特分享與你，希望對你有所幫助！本文為下半部分，主要總結了PaaS篇的核心要點。

一、PaaS篇

1、正確評估和理解PaaS

　　PaaS的核心概念是Platform-as-a-Service，即雲計算提供的平台類服務。它是抽象和可復用的單元，讓用戶將更多精力放在業務邏輯上。

　　PaaS的核心優勢在於生產力/效率，尤其體現在搭建和運維層面。

　　怎樣學習和研究PaaS呢？可以參照以下幾個維度：

　　（1）第一維度：服務是否帶有內生的運行環境；

　　（2）第二維度：PaaS服務存在的位置和範圍及給予你的控制粒度；

　　（3）第三維度：服務是否是“有狀態的”；

　　（4）第四維度：支持PaaS的虛擬機是否對外暴露；

　　怎樣衡量和評估PaaS呢？由於PaaS的核心在於封裝，既帶來了效率優勢也帶來了靈活性上的犧牲，因此我們需要檢查PaaS服務的限制，它們有：功能屏蔽、版本選擇、性能極限、更新頻率、版本陷阱；

　　此外，當雲上官方的PaaS不滿足需求時也可以考慮第三方PaaS。

2、對象存儲服務

　　對象存儲的主要功能：它是雲上創建的一種“網盤”，可以存儲任意結構化的和非結構化的二進制文件，用戶可以隨時上傳下載、修改刪除。對象存儲服務保證了數據的可靠性、可用性和擴展性。

　　對象存儲和雲硬盤的區別：

　　（1）訪問的接口和形式不同 => 雲硬盤作為虛擬機的塊存儲設備而存在，對象存儲本質是一個網絡化的服務；

　　（2）對象存儲內本身不存在一個真正的文件系統，它是一個鍵值形式的存儲服務；

　　（3）對象存儲的巨大容量，能夠輕鬆容納PB級的大容量數據；

　　對象存儲的高級特性：

　　（1）存儲分層 => 設置訪問頻率從高頻到低頻等不同的存儲級別；

　　（2）生命周期管理 => 允許設置一定的過期規則，自動執行一些清理操作；

　　（3）對象的版本管理 => 啟用此特性會自動記錄版本號以便進行回滾和恢復；

　　總的來說，對象存儲的應用場景就是一切需要保存數據的地方！

3、應用託管服務

正確理解應用託管服務

　　應用託管服務本質是為應用提供一個隔離的獨立運行環境，讓用戶只專註於業務邏輯而無須關注運維。

　　目前主流雲廠商的該項服務的產品有：AWS ElasticBeanstalk、阿里雲Web應用託管服務（Web+）、Azure應用服務（Azure App Service）。

應用託管的增值服務

　　（1）監控：針對Web應用的特點而進行的HTTP層面的監控，基於這些監控指標可以指定相應的報警規則；

　　（2）擴展：既包含了底層機器配置的垂直擴展，也包含了機器數量層面的水平擴展；

　　（3）集成：與其他PaaS服務的集成很方便，與雲上DevOps組件和流程的無縫對接；

4、雲上數據庫服務

理解數據庫服務

　　數據庫PaaS服務是將數據庫服務搬到雲上，讓用戶更方便輕鬆地使用、管理和維護數據庫。

　　數據庫PaaS服務和傳統關係型數據庫的共同點：外部交互層面，保持了和原版數據庫幾乎一致的編程接口和使用體驗。

　　和傳統關係型數據庫的差異點：搭建、運維和管理層面實現了相當程度的智能化和自動化，極大提升用戶友好度，降低使用門檻。

　　雲上數據庫最具代表的高級特性：

　　（1）支持讀寫分離 => 只需在後台略加操作配置即可完成；

　　（2）支持自動調優 => 自帶有性能分析和改進模塊幫助發現性能熱點；

新一代雲原生數據庫

　　目前主流雲原生數據庫產品有：AWS Aurora、阿里雲 PolarDB、Azure Cosmos DB；

　　目前雲原生數據庫的特點：

　　（1）更強的可擴展性 => 存儲規模和算力；

　　（2）更高的可用性和可靠性 => 默認多副本高可用；

　　（3）支持多種數據模型 => 兼容關係型與NoSQL；

　　（4）低成本啟動 => 自然地跟隨業務增長，經濟適用；

數據庫服務為何能不斷佔領市場

　　除了上面提到的易用性和豐富功能性外，雲廠商能夠端到端地掌控影響一個數據庫的設計和性能的所有因素，為它配備了最新最好的軟硬件組合。

　　藉助雲計算平台，雲數據庫擁有非常好的流量入口，Gartner甚至大膽預測到2023年全球3/4的數據庫都會跑在雲上！

使用雲數據庫的建議

　　如果是老的應用遷移/與自建數據庫保持高度兼容性的場合 => 使用經典RDS服務

　　如果應用場景中數據量大、性能要求高/沒有歷史負擔 => 直接考慮雲原生數據庫服務

5、雲上大數據服務

理解雲上大數據服務

　　大數據是技術手段，而雲是一種資源和能力的載體！如果雲是一艘航母，是一個大型綜合作戰品台，那大數據就好比戰鬥機，在航母上就是艦載機。

雲上大數據的特點

　　（1）簡單易用，方便管理：大大降低了學習和應用大數據技術的門檻

　　（2）盡可能的保證了兼容性：和熟知的大數據技術別無他樣

　　（3）解耦了大數據架構中的計算和存儲：存儲端一般優先選擇對象存儲，計算端集群可以動態地創建和銷毀

　　（4）提供了很多增值服務：如性能監控、Jupyter Notebook等；

主流雲廠商的大數據服務

　　（1）大數據計算：AWS EMR、阿里雲 MaxCompute / E-MapReduce、Azure HDInsight

　　（2）大數據存儲：AWS S3（EMRFS）、阿里雲 OSS / JindoFS、Azure Blob Storage / Data Lake Storage Gen2

基於阿里雲MaxCompute的日誌大數據分析案例

6、雲上容器服務

容器和雲的關係

　　一方面，容器和雲是相輔相成的：雲承載着容器的運行，容器生態也驅動着雲的發展。

　　另一方面，容器與雲廠商力推的一些雲服務存在競爭和替代關係：其實部分PaaS服務也可以使用IaaS服務來實現，又如Google积極創立和發展CNCF推動容器應用標準化。

雲上Kubernetes服務的特點

　　（1）雲端的多租戶特性，可以免除在Master節點方面的開銷；

　　（2）雲廠商做了很多工作，使得K8s可以和IaaS/PaaS組件有很好的的集成；

　　（3）易部署多集群，保證不同的集群有更好的隔離性；

騰訊雲TKE產品架構

雲上容器鏡像服務

　　雲廠商都提供了自己的容器鏡像服務，如AWS ECR、Azure ACR等。

騰訊雲容器鏡像服務助力實現容器持續部署

全託管容器實例服務

　　“全託管”思想在容器服務商的體現有以下幾個點：

　　（1）不用關心底層基礎設施；

　　（2）AWS Fargate、阿里雲彈性容器實例等；

　　（3）適合有容器鏡像且想要儘快在雲上跑起來的場景；

Azure Container Instance容器實例服務創建容器實例

7、無服務器計算服務

理解無服務器計算

　　無服務器：“無服務器”是雲計算中資源抽象的極致體現，用戶感覺不到服務器的存在，可以專註於業務邏輯而不再關心基礎設施；

　　無服務器計算服務：完全屏蔽計算資源，引導不再關心底層環境，主流的無服務器計算服務有AWS Lambda、阿里雲函數計算以及 Azure Functions。

無服務器計算的計費機制

　　兩個指標：調用次數和調用時長。

　　適合場景：偶爾觸發、短時間運行的工作。

無服務器計算是多面手

　　（1）事件模型是無服務器的核心編程模型和運行邏輯；

　　（2）雲上Serverless服務一般都配套提供了多種多樣的觸發器；

　　（3）多樣的外部交互方式也讓無服務器計算能夠對外訪問，並向下游輸出；

　　（4）以工作流的方式進行雲函數等事件處理單元的組合和編排；

無服務器計算服務的限制

　　無服務器計算服務的主要限制還是在於它是一個受限的環境，比如：冷啟動的延時、內存的限制、雲函數的運行時長、併發數上限等等。

8、雲上AI服務

開箱即用的API服務

　　這類服務將非結構化數據處理分析的通用需求場景，進行了封裝和開放。非結構化數據包括：圖像、視頻、語音、文本等等。

　　我們可以通過雲端標準的API和SDK來進行調用，一般按調用次數進行收費。

　　現在各領域的AI服務有：

　　（1）計算機視覺：人臉識別、物體檢測、OCR、安全掃描等；

　　（2）自然語言處理：機器翻譯、文本分析等；

　　（3）語音類智能服務：語音識別、語音合成等；

　　（4）視頻類智能服務：視頻分析、用戶內容審查等；

百度雲圖片識別服務識別到花瓶和水杯

構建自己的AI模型

　　實際應用中，很多企業都需要按照特定的需求來構建自己的定製模型，是普遍而常見的場景。

　　因此，雲廠商開始提供幫助用戶構建AI模型的基礎設施服務：

　　（1）主流的產品有：AWS SageMaker、Azure Machine Learning 以及阿里雲機器學習平台PAI；

　　（2）適合的對象由：數據科學家、算法工程師；

　　此外，雲上機器學習服務可以幫助進行貫穿生命周期的模型構建和管理：

　　（1）數據準備：集成了數據標註相關的功能簡化操作難度；

　　（2）模型訓練：內置常見機器學習和深度學習算法以及也兼容開源的機器學習和深度學習框架；

　　（3）模型發布和部署：簡化了模型部署和推理調用操作難度；

百度雲EasyDL定製化圖像識別模型訓練報告

二、結束語

1、再看雲計算

　　（1）雲計算是一個載體和平台，承載着從IaaS到PaaS林林總總的能力；

　　（2）每項能力中既包含了資源，也體現了技術，並且以產品和服務的形態開放；

　　（3）雲的承載性是雲得以包羅萬象，並且與時俱進的根本原因；

2、雲原生的本質

　　（1）雲原生的本質是用於構建現代雲端應用的一系列架構理念，以及幫助這些理念落地的技術支撐和最佳實踐；

　　（2）雲原生的核心理念包括無狀態、分佈式、服務化、彈性擴展等等；

　　（3）雲原生的狹義的定義：特指容器化、容器編排和微服務架構，此外雲廠商在宣傳K8s服務和產品時所說的“雲原生”；

　　（4）雲原生的廣義視角：只要是適合在雲上運行，具備和符合雲上架構特點的應用，都可以說是屬於“雲原生”範疇；

3、面向未來的建議

　　（1）跟隨雲的發展腳步來不斷提升自己：比如考取雲廠商的認證（比如阿里雲ACP認證）、參加雲計算大會、積极參与雲生態等；

　　（2）用雲來構建和開展你的業務：讓雲在手中發揮最大的作用和價值，抓住機會上雲用效率贏取競爭優勢；

三、腦圖分享

點此查看完整腦圖

參考資料

何愷鐸，極客時間《深入淺出雲計算》專欄（推薦訂閱學習）

作者：周旭龍

出處：https://edisonchou.cnblogs.com

本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文鏈接。

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

【其他文章推薦】

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

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

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

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

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

基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（六）

發佈日期: 2020-11-30 作者: admin

系列文章

基於 abp vNext 和 .NET Core 開發博客項目 – 使用 abp cli 搭建項目
基於 abp vNext 和 .NET Core 開發博客項目 – 給項目瘦身，讓它跑起來
基於 abp vNext 和 .NET Core 開發博客項目 – 完善與美化，Swagger登場
基於 abp vNext 和 .NET Core 開發博客項目 – 數據訪問和代碼優先
基於 abp vNext 和 .NET Core 開發博客項目 – 自定義倉儲之增刪改查
基於 abp vNext 和 .NET Core 開發博客項目 – 統一規範API，包裝返回模型
基於 abp vNext 和 .NET Core 開發博客項目 – 再說Swagger，分組、描述、小綠鎖
基於 abp vNext 和 .NET Core 開發博客項目 – 接入GitHub，用JWT保護你的API
基於 abp vNext 和 .NET Core 開發博客項目 – 異常處理和日誌記錄
基於 abp vNext 和 .NET Core 開發博客項目 – 使用Redis緩存數據
基於 abp vNext 和 .NET Core 開發博客項目 – 集成Hangfire實現定時任務處理
基於 abp vNext 和 .NET Core 開發博客項目 – 用AutoMapper搞定對象映射
基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（一）
基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（二）
基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（三）
基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（一）
基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（二）
基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（三）
基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（四）
基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（五）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（一）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（二）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（三）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（四）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（五）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（六）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（七）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（八）
基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（九）
基於 abp vNext 和 .NET Core 開發博客項目 – 終結篇之發布項目

上一篇完成了博客文章詳情頁面的數據展示和基於JWT方式的簡單身份驗證，本篇繼續推進，完成後台分類管理的所有增刪改查等功能。

分類管理

在 Admin 文件夾下新建Razor組件，Categories.razor，設置路由，@page "/admin/categories"。將具體的展示內容放在組件AdminLayout中。

@page "/admin/categories"

<AdminLayout>
      <Loading />
</AdminLayout>

在這裏我會將所有分類展示出來，新增、更新、刪除都會放在一個頁面上去完成。

先將列表查出來，添加API的返回參數，private ServiceResult<IEnumerable<QueryCategoryForAdminDto>> categories;，然後再初始化中去獲取數據。

//QueryCategoryForAdminDto.cs
namespace Meowv.Blog.BlazorApp.Response.Blog
{
    public class QueryCategoryForAdminDto : QueryCategoryDto
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int Id { get; set; }
    }
}

/// <summary>
/// API返回的分類列表數據
/// </summary>
private ServiceResult<IEnumerable<QueryCategoryForAdminDto>> categories;

/// <summary>
/// 初始化
/// </summary>
/// <returns></returns>
protected override async Task OnInitializedAsync()
{
    var token = await Common.GetStorageAsync("token");
    Http.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}");

    categories = await FetchData();
}

/// <summary>
/// 獲取數據
/// </summary>
/// <returns></returns>
private async Task<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>> FetchData()
{
    return await Http.GetFromJsonAsync<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>>("/blog/admin/categories");
}

初始化的時候，需要將我們存在localStorage中的token讀取出來，因為我們後台的API都需要添加 Authorization Header 請求頭才能成功返回數據。

在Blazor添加請求頭也是比較方便的，直接Http.DefaultRequestHeaders.Add(...)即可，要注意的是 token值前面需要加 Bearer ，跟了一個空格不可以省略。

獲取數據單獨提成了一個方法FetchData()，因為會頻繁用到，現在在頁面上將數據綁定進行展示。

@if (categories == null)
{
    <Loading />
}
else
{
    <div class="post-wrap categories">
        <h2 class="post-title">-&nbsp;Categories&nbsp;-</h2>
        @if (categories.Success && categories.Result.Any())
        {
            <div class="categories-card">
                @foreach (var item in categories.Result)
                {
                    <div class="card-item">
                        <div class="categories">
                            <NavLink title="刪除" @onclick="@(async () => await DeleteAsync(item.Id))"></NavLink>
                            <NavLink title="編輯" @onclick="@(() => ShowBox(item))"></NavLink>
                            <NavLink target="_blank" href="@($"/category/{item.DisplayName}")">
                                <h3>@item.CategoryName</h3>
                                <small>(@item.Count)</small>
                            </NavLink>
                        </div>
                    </div>
                }
                <div class="card-item">
                    <div class="categories">
                        <NavLink><h3 @onclick="@(() => ShowBox())">~~~ 新增分類 ~~~</h3></NavLink>
                    </div>
                </div>
            </div>
        }
        else
        {
            <ErrorTip />
        }
    </div>
}

同樣的當categories還沒成功獲取到數據的時候，我們直接在展示 <Loading />組件。然後就是循環列表數據在foreach中進行綁定數據。

在每條數據最前面，加了刪除和編輯兩個按鈕，刪除的時候調用DeleteAsync方法，將當前分類的Id傳給他即可。新增和編輯的時候調用ShowBox方法，他接受一個參數，當前循環到的分類對象item，即QueryCategoryForAdminDto。

同時這裏考慮到復用性，我寫了一個彈窗組件，Box.Razor，放在Shared文件夾下面，可以先看一下標題為彈窗組件的內容再回來繼續往下看。

刪除分類

接下來看看刪除方法。

/// <summary>
/// 刪除分類
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
private async Task DeleteAsync(int id)
{
    // 彈窗確認
    bool confirmed = await Common.InvokeAsync<bool>("confirm", "\n真的要幹掉這個該死的分類嗎");

    if (confirmed)
    {
        var response = await Http.DeleteAsync($"/blog/category?id={id}");

        var result = await response.Content.ReadFromJsonAsync<ServiceResult>();

        if (result.Success)
        {
            categories = await FetchData();
        }
    }
}

刪除之前搞個原生的confirm進行提示，避免手殘誤刪。因為API那邊使用的是HttpDelete，所有我們調用API時候要用Http.DeleteAsync，返回的是HttpResponseMessage對象，需要我們手動處理接收返回數據，將其轉換為ServiceResult對象，如果判斷刪除成功后重新調用FetchData()刷新分類數據。

新增/更新分類

新增和更新數據選擇使用彈窗的方式來進行(彈窗組件在下方)，首先是需要一個參數判斷彈窗是否打開，因為是將新增和更新放在一起，所以如何判斷是新增還是更新呢？這裏使用Id來進行判斷，當編輯的時候肯定會有Id參數。新增的時候是沒有參數傳遞的。

當我們打開彈窗后裏面需要展示兩個input框，用來供輸入要保存的數據，同樣是添加兩個變量。

添加所需的這幾個參數。

/// <summary>
/// 默認隱藏Box
/// </summary>
private bool Open { get; set; } = false;

/// <summary>
/// 新增或者更新時候的分類字段值
/// </summary>
private string categoryName, displayName;

/// <summary>
/// 更新分類的Id值
/// </summary>
private int id;

現在可以將Box組件添加到頁面上。

<div class="post-wrap categories">
	...
</div>

<Box OnClickCallback="@SubmitAsync" Open="@Open">
    <div class="box-item">
        <b>DisplayName：</b><input type="text" @bind="@displayName" @bind:event="oninput" />
    </div>
    <div class="box-item">
        <b>CategoryName：</b><input type="text" @bind="@categoryName" @bind:event="oninput" />
    </div>
</Box>

確定按鈕回調事件執行SubmitAsync()方法，打開狀態參數為上面添加的Open，按鈕文字ButtonText為默認值不填。

添加了兩個input，將兩個分類字段分別綁定上去，使用@bind和@bind:event。前者等價於設置其value值，後者等價於一個change事件當值改變後會重新賦給綁定的字段參數。

現在可以來看看點擊了新增或者編輯按鈕的方法ShowBox(...)，接收一個參數QueryCategoryForAdminDto讓其默認值為null。

/// <summary>
/// 显示box，綁定字段
/// </summary>
/// <param name="dto"></param>
private void ShowBox(QueryCategoryForAdminDto dto = null)
{
    Open = true;
    id = 0;

    // 新增
    if (dto == null)
    {
        displayName = null;
        categoryName = null;
    }
    else // 更新
    {
        id = dto.Id;
        displayName = dto.DisplayName;
        categoryName = dto.CategoryName;
    }
}

執行ShowBox()方法，將彈窗打開，設置Open = true;和初始化id的值id = 0;。

通過參數是否null進行判斷是新增還是更新，這樣打開彈窗就搞定了，剩下的就交給彈窗來處理了。

因為新增和更新API需要還對應的輸入參數EditCategoryInput，去添加它不要忘了。

那麼現在就只差按鈕回調事件SubmitAsync()了，主要是給輸入參數進行賦值調用API，執行新增或者更新即可。

/// <summary>
/// 確認按鈕點擊事件
/// </summary>
/// <returns></returns>
private async Task SubmitAsync()
{
    var input = new EditCategoryInput()
    {
        DisplayName = displayName.Trim(),
        CategoryName = categoryName.Trim()
    };

    if (string.IsNullOrEmpty(input.DisplayName) || string.IsNullOrEmpty(input.CategoryName))
    {
        return;
    }

    var responseMessage = new HttpResponseMessage();

    if (id > 0)
        responseMessage = await Http.PutAsJsonAsync($"/blog/category?id={id}", input);
    else
        responseMessage = await Http.PostAsJsonAsync("/blog/category", input);

    var result = await responseMessage.Content.ReadFromJsonAsync<ServiceResult>();
    if (result.Success)
    {
        categories = await FetchData();
        Open = false;
    }
}

當參數為空時，直接return什麼都不執行。通過當前Id判斷是新增還是更新操作，調用不同的方法PutAsJsonAsync和PostAsJsonAsync去請求API，同樣返回到是HttpResponseMessage對象，最後如果操作成功，重新請求一個數據，刷新分類列表，將彈窗關閉掉。

分類管理頁面的全部代碼如下：

點擊查看代碼

@page "/admin/categories"

<AdminLayout>
    @if (categories == null)
    {
        <Loading />
    }
    else
    {
        <div class="post-wrap categories">
            <h2 class="post-title">-&nbsp;Categories&nbsp;-</h2>
            @if (categories.Success && categories.Result.Any())
            {
                <div class="categories-card">
                    @foreach (var item in categories.Result)
                    {
                        <div class="card-item">
                            <div class="categories">
                                <NavLink title="刪除" @onclick="@(async () => await DeleteAsync(item.Id))"></NavLink>
                                <NavLink title="編輯" @onclick="@(() => ShowBox(item))"></NavLink>
                                <NavLink target="_blank" href="@($"/category/{item.DisplayName}")">
                                    <h3>@item.CategoryName</h3>
                                    <small>(@item.Count)</small>
                                </NavLink>
                            </div>
                        </div>
                    }
                    <div class="card-item">
                        <div class="categories">
                            <NavLink><h3 @onclick="@(() => ShowBox())">~~~ 新增分類 ~~~</h3></NavLink>
                        </div>
                    </div>
                </div>
            }
            else
            {
                <ErrorTip />
            }
        </div>

        <Box OnClickCallback="@SubmitAsync" Open="@Open">
            <div class="box-item">
                <b>DisplayName：</b><input type="text" @bind="@displayName" @bind:event="oninput" />
            </div>
            <div class="box-item">
                <b>CategoryName：</b><input type="text" @bind="@categoryName" @bind:event="oninput" />
            </div>
        </Box>
    }
</AdminLayout>

@code {
    /// <summary>
    /// 默認隱藏Box
    /// </summary>
    private bool Open { get; set; } = false;

    /// <summary>
    /// 新增或者更新時候的分類字段值
    /// </summary>
    private string categoryName, displayName;

    /// <summary>
    /// 更新分類的Id值
    /// </summary>
    private int id;

    /// <summary>
    /// API返回的分類列表數據
    /// </summary>
    private ServiceResult<IEnumerable<QueryCategoryForAdminDto>> categories;

    /// <summary>
    /// 初始化
    /// </summary>
    /// <returns></returns>
    protected override async Task OnInitializedAsync()
    {
        var token = await Common.GetStorageAsync("token");
        Http.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}");

        categories = await FetchData();
    }

    /// <summary>
    /// 獲取數據
    /// </summary>
    /// <returns></returns>
    private async Task<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>> FetchData()
    {
        return await Http.GetFromJsonAsync<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>>("/blog/admin/categories");
    }

    /// <summary>
    /// 刪除分類
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    private async Task DeleteAsync(int id)
    {
        Open = false;

        // 彈窗確認
        bool confirmed = await Common.InvokeAsync<bool>("confirm", "\n真的要幹掉這個該死的分類嗎");

        if (confirmed)
        {
            var response = await Http.DeleteAsync($"/blog/category?id={id}");

            var result = await response.Content.ReadFromJsonAsync<ServiceResult>();

            if (result.Success)
            {
                categories = await FetchData();
            }
        }
    }

    /// <summary>
    /// 显示box，綁定字段
    /// </summary>
    /// <param name="dto"></param>
    private void ShowBox(QueryCategoryForAdminDto dto = null)
    {
        Open = true;
        id = 0;

        // 新增
        if (dto == null)
        {
            displayName = null;
            categoryName = null;
        }
        else // 更新
        {
            id = dto.Id;
            displayName = dto.DisplayName;
            categoryName = dto.CategoryName;
        }
    }

    /// <summary>
    /// 確認按鈕點擊事件
    /// </summary>
    /// <returns></returns>
    private async Task SubmitAsync()
    {
        var input = new EditCategoryInput()
        {
            DisplayName = displayName.Trim(),
            CategoryName = categoryName.Trim()
        };

        if (string.IsNullOrEmpty(input.DisplayName) || string.IsNullOrEmpty(input.CategoryName))
        {
            return;
        }

        var responseMessage = new HttpResponseMessage();

        if (id > 0)
            responseMessage = await Http.PutAsJsonAsync($"/blog/category?id={id}", input);
        else
            responseMessage = await Http.PostAsJsonAsync("/blog/category", input);

        var result = await responseMessage.Content.ReadFromJsonAsync<ServiceResult>();
        if (result.Success)
        {
            categories = await FetchData();
            Open = false;
        }
    }
}

彈窗組件

考慮到新增和更新數據的時候需要彈窗，這裏就簡單演示一下寫一個小組件。

在 Shared 文件夾下新建一個Box.razor。

在開始之前分析一下彈窗組件所需的元素，彈窗肯定有一個確認和取消按鈕，右上角需要有一個關閉按鈕，關閉按鈕和取消按鈕一個意思。他還需要一個打開或者關閉的狀態，判斷是否打開彈窗，還有就是彈窗內需要自定義展示內容。

確定按鈕的文字可以自定義，所以差不多就需要3個參數，組件內容RenderFragment ChildContent，是否打開彈窗bool Open默認隱藏，按鈕文字string ButtonText默認值給”確定”。然後最重要的是確定按鈕需要一個回調事件，EventCallback<MouseEventArgs> OnClickCallback 用於執行不同的事件。

/// <summary>
/// 組件內容
/// </summary>
[Parameter]
public RenderFragment ChildContent { get; set; }

/// <summary>
/// 是否隱藏
/// </summary>
[Parameter]
public bool Open { get; set; } = true;

/// <summary>
/// 按鈕文字
/// </summary>
[Parameter]
public string ButtonText { get; set; } = "確定";

/// <summary>
/// 確認按鈕點擊事件回調
/// </summary>
[Parameter]
public EventCallback<MouseEventArgs> OnClickCallback { get; set; }

/// <summary>
/// 關閉Box
/// </summary>
private void Close() => Open = false;

右上角關閉和取消按鈕直接在內部進行處理，執行Close()方法，將參數Open值設置為false即可。

對應的html如下。

@if (Open)
{
    <div class="shadow"></div>
    <div class="box">
        <div class="close" @onclick="Close"></div>
        <div class="box-content">
            @ChildContent
            <div class="box-item box-item-btn">
                <button class="box-btn" @onclick="OnClickCallback">@ButtonText</button>
                <button class="box-btn btn-primary" @onclick="Close">取消</button>
            </div>
        </div>
    </div>
}

關於樣式

下面是彈窗組件所需的樣式代碼，大家需要的自取，也可以直接去GitHub實時獲取最新的樣式文件。

.box {
    width: 600px;
    height: 300px;
    border-radius: 5px;
    background-color: #fff;
    position: fixed;
    top: 50%;
    left: 50%;
    margin-top: -150px;
    margin-left: -300px;
    z-index: 997;
}
.close {
    position: absolute;
    right: 3px;
    top: 2px;
    cursor: pointer;
}
.shadow {
    width: 100%;
    height: 100%;
    position: fixed;
    left: 0;
    top: 0;
    z-index: 996;
    background-color: #000;
    opacity: 0.3;
}
.box-content {
    width: 90%;
    margin: 20px auto;
}
.box-item {
    margin-top: 10px;
    height: 30px;
}
.box-item b {
    width: 130px;
    display: inline-block;
}
.box-item input[type=text] {
    padding-left: 5px;
    width: 300px;
    height: 30px;
}
.box-item label {
    width: 100px;
    white-space: nowrap;
}
.box-item input[type=radio] {
    width: auto;
    height: auto;
    visibility: initial;
    display: initial;
    margin-right: 2px;
}
.box-item button {
    height: 30px;
    width: 100px;
}
.box-item-btn {
    position: absolute;
    right: 20px;
    bottom: 20px;
}
.box-btn {
    display: inline-block;
    height: 30px;
    line-height: 30px;
    padding: 0 18px;
    background-color: #5A9600;
    color: #fff;
    white-space: nowrap;
    text-align: center;
    font-size: 14px;
    border: none;
    border-radius: 2px;
    cursor: pointer;
}
button:focus {
    outline: 0;
}
.box-btn:hover {
    opacity: .8;
    filter: alpha(opacity=80);
    color: #fff;
}
.btn-primary {
    border: 1px solid #C9C9C9;
    background-color: #fff;
    color: #555;
}
.btn-primary:hover {
    border-color: #5A9600;
    color: #333;
}
.post-box {
    width: 98%;
    margin: 27px auto 0;
}
.post-box-item {
    width: 100%;
    height: 30px;
    margin-bottom: 5px;
}
.post-box-item input {
    width: 49.5%;
    height: 30px;
    padding-left: 5px;
    border: 1px solid #ddd;
}
.post-box-item input:nth-child(1) {
    float: left;
    margin-right: 1px;
}
.post-box-item input:nth-child(2) {
    float: right;
    margin-left: 1px;
}
.post-box .box-item b {
    width: auto;
}
.post-box .box-item input[type=text] {
    width: 90%;
}

好了，分類模塊的功能都完成了，標籤和友情鏈接的管理界面還會遠嗎？這兩個模塊的做法和分類是一樣的，有興趣的可以自己動手完成，今天到這吧，未完待續…

開源地址：https://github.com/Meowv/Blog/tree/blog_tutorial

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

【其他文章推薦】

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

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

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

※超省錢租車方案

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

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

上周熱點回顧（6.8-6.14）

發佈日期: 2020-11-30 作者: admin

熱點隨筆：

· 真慘！連各大編程語言都擺起地攤了！ (軒轅之風)
· .NET開發者省份分佈排名 (張善友)
· C#9.0 終於來了，您還學的動嗎？帶上VS一起解讀吧！（應該是全網第一篇） (一線碼農)
· WinUI 3 試玩報告 (dino.c)
· [C#.NET 拾遺補漏]04：你必須知道的反射 (LiamWang)
· 120行代碼打造.netcore生產力工具-小而美的後台異步組件 (福祿網絡技術團隊)
· .Net Core實戰之基於角色的訪問控制的設計 (陳珙)
· 面試了 6 輪 Google 中國之後，還是掛了 (程序猿石頭)
· 手動造輪子——基於.NetCore的RPC框架DotNetCoreRpc (yi念之間)
· .Net Core微服務入門全紀錄（一）——項目搭建 (xhznl)
· 搭上末班車去了京東，終於可以做東哥兄弟… (龍躍十二)
· 8000字長文讓你徹底了解 Java 8 的 Lambda、函數式接口、Stream 用法和原理 (風的姿態)

熱點新聞：

· 中國最慘創業者：3年前我被投資人趕出公司，3年後讓我賠3800萬！
· 馬化騰每天刷Leetcode？代碼你打算寫到幾歲？
· Linux之父親手拒補丁、怒懟亞馬遜程序員網友：我的快樂又回來了
· 一場屬於少數人的復蘇
· 打破Oracle垄斷！支付寶OceanBase獨立：年內將發布重大版本升級
· 京東真正上岸了
· 關閉微信朋友圈個性化廣告有多難？13 個步驟點擊 16 次，只能關半年
· 27歲程序員轉職賞金獵人：一個漏洞10萬美元，比工資香多了
· .NET 5.0 Preview 5 發布
· 好評率84%，微軟工作室翻身大作《盜賊之海》登陸Steam！
· 阿里雲年度戰略首次公開！中台做厚，硬件擴張，還要再招5000人
· 分析了上千張照片發現：R語言程序員最快樂，Java開發者最年輕

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

【其他文章推薦】

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

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

※超省錢租車方案

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

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

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

重學 Java 設計模式：實戰享元模式「基於Redis秒殺，提供活動與庫存信息查詢場景」

發佈日期: 2020-11-30 作者: admin

作者：小傅哥
博客：https://bugstack.cn

沉澱、分享、成長，讓自己和他人都能有所收穫！

一、前言

程序員‍‍的上下文是什麼？

很多時候一大部分編程開發的人員都只是關注於功能的實現，只要自己把這部分需求寫完就可以了，有點像被動的交作業。這樣的問題一方面是由於很多新人還不了解程序員的職業發展，還有一部分是對於編程開發只是工作並非興趣。但在程序員的發展來看，如果不能很好的處理上文(產品)，下文(測試)，在這樣不能很好的了解業務和產品發展，也不能編寫出很有體繫結構的代碼，日久天長，1到3年、3到5年，就很難跨越一個個技術成長的分水嶺。

擁有接受和學習新知識的能力

你是否有感受過小時候在什麼都還不會的時候接受知識的能力很強，但隨着我們開始長大后，慢慢學習能力、處事方式、性格品行，往往會固定。一方面是形成了各自的性格特徵，一方面是圈子已經固定。但也正因為這樣的故步，而很少願意聽取別人的意見，就像即使看到了一整片內容，在視覺盲區下也會過掉到80%，就在眼前也看不見，也因此導致了能力不再有較大的提升。

編程能力怎樣會成長的最快

工作內容往往有些像在工廠擰螺絲，大部分內容是重複的，也可以想象過去的一年你有過多少創新和學習了新的技能。那麼這時候一般為了多學些內容會買一些技術書籍，但！技術類書籍和其他書籍不同，只要不去用看了也就只是輕描淡寫，很難接納和理解。就像設計模式，雖然可能看了幾遍，但是在實際編碼中仍然很少會用，大部分原因還是沒有認認真真的跟着實操。事必躬親才是學習編程的最好是方式。

二、開發環境

JDK 1.8
Idea + Maven
涉及工程三個，可以通過關注公眾號：bugstack蟲洞棧，回復源碼下載獲取(打開獲取的鏈接，找到序號18)

工程	描述
itstack-demo-design-11-01	使用一坨代碼實現業務需求
itstack-demo-design-11-02	通過設計模式優化代碼結構，減少內存使用和查詢耗時

三、享元模式介紹

享元模式，主要在於共享通用對象，減少內存的使用，提升系統的訪問效率。而這部分共享對象通常比較耗費內存或者需要查詢大量接口或者使用數據庫資源，因此統一抽離作為共享對象使用。

另外享元模式可以分為在服務端和客戶端，一般互聯網H5和Web場景下大部分數據都需要服務端進行處理，比如數據庫連接池的使用、多線程線程池的使用，除了這些功能外，還有些需要服務端進行包裝后的處理下發給客戶端，因為服務端需要做享元處理。但在一些遊戲場景下，很多都是客戶端需要進行渲染地圖效果，比如；樹木、花草、魚蟲，通過設置不同元素描述使用享元公用對象，減少內存的佔用，讓客戶端的遊戲更加流暢。

在享元模型的實現中需要使用到享元工廠來進行管理這部分獨立的對象和共享的對象，避免出現線程安全的問題。

四、案例場景模擬

在這個案例中我們模擬在商品秒殺場景下使用享元模式查詢優化

你是否經歷過一個商品下單的項目從最初的日均十幾單到一個月後每個時段秒殺量破十萬的項目。一般在最初如果沒有經驗的情況下可能會使用數據庫行級鎖的方式下保證商品庫存的扣減操作，但是隨着業務的快速發展秒殺的用戶越來越多，這個時候數據庫已經扛不住了，一般都會使用redis的分佈式鎖來控制商品庫存。

同時在查詢的時候也不需要每一次對不同的活動查詢都從庫中獲取，因為這裏除了庫存以外其他的活動商品信息都是固定不變的，以此這裏一般大家會緩存到內存中。

這裏我們模擬使用享元模式工廠結構，提供活動商品的查詢。活動商品相當於不變的信息，而庫存部分屬於變化的信息。

五、用一坨坨代碼實現

邏輯很簡單，就怕你寫亂。一片片的固定內容和變化內容的查詢組合，CV的哪裡都是！

其實這部分邏輯的查詢在一般情況很多程序員都是先查詢固定信息，在使用過濾的或者添加if判斷的方式補充變化的信息，也就是庫存。這樣寫最開始並不會看出來有什麼問題，但隨着方法邏輯的增加，後面就越來越多重複的代碼。

1. 工程結構

itstack-demo-design-11-01
└── src
    └── main
        └── java
            └── org.itstack.demo.design
                └── ActivityController.java

以上工程結構比較簡單，之後一個控制類用於查詢活動信息。

2. 代碼實現

/**
 * 博客：https://bugstack.cn - 沉澱、分享、成長，讓自己和他人都能有所收穫！
 * 公眾號：bugstack蟲洞棧
 * Create by 小傅哥(fustack) @2020
 */
public class ActivityController {

    public Activity queryActivityInfo(Long id) {
        // 模擬從實際業務應用從接口中獲取活動信息
        Activity activity = new Activity();
        activity.setId(10001L);
        activity.setName("圖書嗨樂");
        activity.setDesc("圖書優惠券分享激勵分享活動第二期");
        activity.setStartTime(new Date());
        activity.setStopTime(new Date());
        activity.setStock(new Stock(1000,1));
        return activity;
    }

}

這裏模擬的是從接口中查詢活動信息，基本也就是從數據庫中獲取所有的商品信息和庫存。有點像最開始寫的商品銷售系統，數據庫就可以抗住購物量。
當後續因為業務的發展需要擴展代碼將庫存部分交給redis處理，那麼久需要從redis中獲取活動的庫存，而不是從庫中，否則將造成數據不統一的問題。

六、享元模式重構代碼

接下來使用享元模式來進行代碼優化，也算是一次很小的重構。

享元模式一般情況下使用此結構在平時的開發中並不太多，除了一些線程池、數據庫連接池外，再就是遊戲場景下的場景渲染。另外這個設計的模式思想是減少內存的使用提升效率，與我們之前使用的原型模式通過克隆對象的方式生成複雜對象，減少rpc的調用，都是此類思想。

1. 工程結構

itstack-demo-design-11-02
└── src
    ├── main
    │   └── java
    │       └── org.itstack.demo.design
    │           ├── util
    │           │	└── RedisUtils.java	
    │           ├── Activity.java
    │           ├── ActivityController.java
    │           ├── ActivityFactory.java
    │           └── Stock.java
    └── test
        └── java
            └── org.itstack.demo.test
                └── ApiTest.java

享元模式模型結構

以上是我們模擬查詢活動場景的類圖結構，左側構建的是享元工廠，提供固定活動數據的查詢，右側是Redis存放的庫存數據。
最終交給活動控制類來處理查詢操作，並提供活動的所有信息和庫存。因為庫存是變化的，所以我們模擬的RedisUtils中設置了定時任務使用庫存。

2. 代碼實現

2.1 活動信息

public class Activity {

    private Long id;        // 活動ID
    private String name;    // 活動名稱
    private String desc;    // 活動描述
    private Date startTime; // 開始時間
    private Date stopTime;  // 結束時間
    private Stock stock;    // 活動庫存
    
    // ...get/set
}

這裏的對象類比較簡單，只是一個活動的基礎信息；id、名稱、描述、時間和庫存。

2.2 庫存信息

public class Stock {

    private int total; // 庫存總量
    private int used;  // 庫存已用
    
    // ...get/set
}

這裡是庫存數據我們單獨提供了一個類進行保存數據。

2.3 享元工廠

public class ActivityFactory {

    static Map<Long, Activity> activityMap = new HashMap<Long, Activity>();

    public static Activity getActivity(Long id) {
        Activity activity = activityMap.get(id);
        if (null == activity) {
            // 模擬從實際業務應用從接口中獲取活動信息
            activity = new Activity();
            activity.setId(10001L);
            activity.setName("圖書嗨樂");
            activity.setDesc("圖書優惠券分享激勵分享活動第二期");
            activity.setStartTime(new Date());
            activity.setStopTime(new Date());
            activityMap.put(id, activity);
        }
        return activity;
    }

}

這裏提供的是一個享元工廠，通過map結構存放已經從庫表或者接口中查詢到的數據，存放到內存中，用於下次可以直接獲取。
這樣的結構一般在我們的編程開發中還是比較常見的，當然也有些時候為了分佈式的獲取，會把數據存放到redis中，可以按需選擇。

2.4 模擬Redis類

public class RedisUtils {

    private ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);

    private AtomicInteger stock = new AtomicInteger(0);

    public RedisUtils() {
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            // 模擬庫存消耗
            stock.addAndGet(1);
        }, 0, 100000, TimeUnit.MICROSECONDS);

    }

    public int getStockUsed() {
        return stock.get();
    }

}

這裏處理模擬redis的操作工具類外，還提供了一個定時任務用於模擬庫存的使用，這樣方面我們在測試的時候可以觀察到庫存的變化。

2.4 活動控制類

public class ActivityController {

    private RedisUtils redisUtils = new RedisUtils();

    public Activity queryActivityInfo(Long id) {
        Activity activity = ActivityFactory.getActivity(id);
        // 模擬從Redis中獲取庫存變化信息
        Stock stock = new Stock(1000, redisUtils.getStockUsed());
        activity.setStock(stock);
        return activity;
    }

}

在活動控制類中使用了享元工廠獲取活動信息，查詢后將庫存信息在補充上。因為庫存信息是變化的，而活動信息是固定不變的。
最終通過統一的控制類就可以把完整包裝后的活動信息返回給調用方。

3. 測試驗證

3.1 編寫測試類

public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    private ActivityController activityController = new ActivityController();

    @Test
    public void test_queryActivityInfo() throws InterruptedException {
        for (int idx = 0; idx < 10; idx++) {
            Long req = 10001L;
            Activity activity = activityController.queryActivityInfo(req);
            logger.info("測試結果：{} {}", req, JSON.toJSONString(activity));
            Thread.sleep(1200);
        }
    }

}

這裏我們通過活動查詢控制類，在for循環的操作下查詢了十次活動信息，同時為了保證庫存定時任務的變化，加了睡眠操作，實際的開發中不會有這樣的睡眠。

3.2 測試結果

22:35:20.285 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":1},"stopTime":1592130919931}
22:35:21.634 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":18},"stopTime":1592130919931}
22:35:22.838 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":30},"stopTime":1592130919931}
22:35:24.042 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":42},"stopTime":1592130919931}
22:35:25.246 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":54},"stopTime":1592130919931}
22:35:26.452 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":66},"stopTime":1592130919931}
22:35:27.655 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":78},"stopTime":1592130919931}
22:35:28.859 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":90},"stopTime":1592130919931}
22:35:30.063 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":102},"stopTime":1592130919931}
22:35:31.268 [main] INFO  org.i..t.ApiTest - 測試結果：10001 {"desc":"圖書優惠券分享激勵分享活動第二期","id":10001,"name":"圖書嗨樂","startTime":1592130919931,"stock":{"total":1000,"used":114},"stopTime":1592130919931}

Process finished with exit code 0

可以仔細看下stock部分的庫存是一直在變化的，其他部分是活動信息，是固定的，所以我們使用享元模式來將這樣的結構進行拆分。

七、總結

關於享元模式的設計可以着重學習享元工廠的設計，在一些有大量重複對象可復用的場景下，使用此場景在服務端減少接口的調用，在客戶端減少內存的佔用。是這個設計模式的主要應用方式。
另外通過map結構的使用方式也可以看到，使用一個固定id來存放和獲取對象，是非常關鍵的點。而且不只是在享元模式中使用，一些其他工廠模式、適配器模式、組合模式中都可以通過map結構存放服務供外部獲取，減少ifelse的判斷使用。
當然除了這種設計的減少內存的使用優點外，也有它帶來的缺點，在一些複雜的業務處理場景，很不容易區分出內部和外部狀態，就像我們活動信息部分與庫存變化部分。如果不能很好的拆分，就會把享元工廠設計的非常混亂，難以維護。

八、推薦閱讀

1. 重學 Java 設計模式：實戰工廠方法模式(多種類型商品發獎場景)
2. 重學 Java 設計模式：實戰抽象工廠模式(替換Redis雙集群升級場景)
3. 重學 Java 設計模式：實戰建造者模式(裝修物料組合套餐選配場景)
4. 重學 Java 設計模式：實戰原型模式(多套試每人題目和答案亂序場景)
5. 重學 Java 設計模式：實戰橋接模式(多支付渠道「微信、支付寶」與多支付模式「刷臉、指紋」場景)
6. 重學 Java 設計模式：實戰組合模式(營銷差異化人群發券，決策樹引擎搭建場景)

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

【其他文章推薦】

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

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

※回頭車貨運收費標準

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

※超省錢租車方案

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

使用Apache Spark和Apache Hudi構建分析數據湖

發佈日期: 2020-11-30 作者: admin

1. 引入

大多數現代數據湖都是基於某種分佈式文件系統（DFS），如HDFS或基於雲的存儲，如AWS S3構建的。遵循的基本原則之一是文件的“一次寫入多次讀取”訪問模型。這對於處理海量數據非常有用，如數百GB到TB的數據。

但是在構建分析數據湖時，更新數據並不罕見。根據不同場景，這些更新頻率可能是每小時一次，甚至可能是每天或每周一次。另外可能還需要在最新視圖、包含所有更新的歷史視圖甚至僅是最新增量視圖上運行分析。

通常這會導致使用用於流和批處理的多個系統，前者處理增量數據，而後者處理歷史數據。

處理存儲在HDFS上的數據時，維護增量更新的常見工作流程是這裏所述的Ingest-Reconcile-Compact-Purge策略。

Apache Hudi之類的框架在這裏便可發揮作用。它在後台為我們管理此工作流程，從而使我們的核心應用程序代碼更加簡潔，Hudi支持對最新數據視圖的查詢以及查詢在某個時間點的增量更改。

這篇文章將介紹Hudi的核心概念以及如何在Copy-On-Write模式下進行操作。

本篇文章項目源代碼放在github。

2. 大綱

先決條件和框架版本
Hudi核心概念
初始設置和依賴項
使用CoW表

2.1 先決條件和框架版本

如果你事先了解如何使用scala編寫spark作業以及讀取和寫入parquet文件，那麼本篇文章理解起來將非常容易。

框架版本如下

JDK: openjdk 1.8.0_242
Scala: 2.12.8
Spark: 2.4.4
Hudi Spark bundle: 0.5.2-incubating

注意：在撰寫本文時，AWS EMR與Hudi v0.5.0-incubating集成在一起，該軟件包具有一個bug會導致upsert操作卡死或花費很長時間才能完成，可查看相關issue了解更多，該問題已在當前版本的Hudi（0.5.2-incubating及之後版本）中修復。如果計劃在AWS EMR上運行代碼，則可能要考慮用最新版本覆蓋默認的集成版本。

2.2 Hudi核心概念

先從一些需要理解的核心概念開始。

1. 表類型

Hudi支持兩種表類型

寫時複製（CoW）：寫入CoW表時，將運行Ingest-Reconcile-Compact-Purge周期。每次寫操作后，CoW表中的數據始終是最新記錄，對於需要儘快讀取最新數據的場景，可首選此模式。數據僅以列文件格式（parquet）存儲在CoW表中，由於每個寫操作都涉及壓縮和覆蓋，因此此模式產生的文件最少。
讀時合併（MoR）：MoR表專註於快速寫操作。寫入這些表將創建增量文件，隨後將其壓縮以生成讀取時的最新數據，壓縮操作可以同步或異步完成，數據以列文件格式（parquet）和基於行的文件格式（avro）組合存儲。

這是Hudi文檔中提到的兩種表格格式之間的權衡取捨。

Trade-off	CoW	MoR
數據延遲	Higher	Lower
更新開銷 (I/O)	Higher (重寫整個parquet文件)	Lower (追加到delta log文件)
Parquet文件大小	Smaller (高update(I/0) 開銷)	Larger (低更新開銷)
Write Amplification	Higher	Lower (由compaction策略決定)

2. 查詢類型

Hudi支持兩種主要類型的查詢：“快照查詢”和“增量查詢”。除兩種主要查詢類型外，MoR表還支持“讀優化查詢”。

快照查詢：對於CoW表，快照查詢返回數據的最新視圖，而對於MoR表，則返回接近實時的視圖。對於MoR表，快照查詢將即時合併基本文件和增量文件，因此可能會有一些讀取延遲。使用CoW，由於寫入負責合併，因此讀取很快，只需要讀取基本文件。
增量查詢：增量查詢使您可以通過指定“開始”時間或在特定時間點通過指定“開始”和“結束”時間來查看特定提交時間之後的數據。
讀優化查詢：對於MoR表，讀取優化查詢返回一個視圖，該視圖僅包含基本文件中的數據，而不合併增量文件。

3. 以Hudi格式寫入時的關鍵屬性

hoodie.datasource.write.table.type，定義表的類型-默認值為COPY_ON_WRITE。對於MoR表，將此值設置為MERGE_ON_READ。
hoodie.table.name，這是必填字段，每個表都應具有唯一的名稱。
hoodie.datasource.write.recordkey.field，將此視為表的主鍵。此屬性的值是DataFrame中列的名稱，該列是主鍵。
hoodie.datasource.write.precombine.field，更新數據時，如果存在兩個具有相同主鍵的記錄，則此列中的值將決定更新哪個記錄。選擇諸如時間戳記的列將確保選擇具有最新時間戳記的記錄。
hoodie.datasource.write.operation，定義寫操作的類型。值可以為upsert，insert，bulk_insert和delete，默認值為upsert。

2.3 初始設置和依賴項

1. 依賴說明

為了在Spark作業中使用Hudi，需要使用spark-sql，hudi-spark-bundle和spark-avro依賴項，此外還需要將Spark配置為使用KryoSerializer。

pom.xml大致內容如下

<properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <encoding>UTF-8</encoding>
    <scala.version>2.12.8</scala.version>
    <scala.compat.version>2.12</scala.compat.version>
    <spec2.version>4.2.0</spec2.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-library</artifactId>
        <version>${scala.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-sql_${scala.compat.version}</artifactId>
        <version>2.4.4</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hudi</groupId>
        <artifactId>hudi-spark-bundle_${scala.compat.version}</artifactId>
        <version>0.5.2-incubating</version>
    </dependency>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-avro_${scala.compat.version}</artifactId>
        <version>2.4.4</version>
    </dependency>
</dependencies>

2. 設置Schema

我們使用下面的Album類來表示表的schema。

case class Album(albumId: Long, title: String, tracks: Array[String], updateDate: Long)

3. 生成測試數據

創建一些用於upsert操作的數據。

INITIAL_ALBUM_DATA有兩個記錄，鍵為801。
UPSERT_ALBUM_DATA包含一個更新的記錄和兩個新的記錄。

def dateToLong(dateString: String): Long = LocalDate.parse(dateString, formatter).toEpochDay

private val INITIAL_ALBUM_DATA = Seq(
    Album(800, "6 String Theory", Array("Lay it down", "Am I Wrong", "68"), dateToLong("2019-12-01")),
    Album(801, "Hail to the Thief", Array("2+2=5", "Backdrifts"), dateToLong("2019-12-01")),
    Album(801, "Hail to the Thief", Array("2+2=5", "Backdrifts", "Go to sleep"), dateToLong("2019-12-03"))
  )

  private val UPSERT_ALBUM_DATA = Seq(
    Album(800, "6 String Theory - Special", Array("Jumpin' the blues", "Bluesnote", "Birth of blues"), dateToLong("2020-01-03")),
    Album(802, "Best Of Jazz Blues", Array("Jumpin' the blues", "Bluesnote", "Birth of blues"), dateToLong("2020-01-04")),
    Album(803, "Birth of Cool", Array("Move", "Jeru", "Moon Dreams"), dateToLong("2020-02-03"))
  )

4. 初始化SparkContext

最後初始化Spark上下文。這裏要注意的重要一點是KryoSerializer的使用。

val spark: SparkSession = SparkSession.builder()
    .appName("hudi-datalake")
    .master("local[*]")
    .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    .config("spark.sql.hive.convertMetastoreParquet", "false") // Uses Hive SerDe, this is mandatory for MoR tables
    .getOrCreate()

2.4 使用CoW表

本節將處理CoW表的記錄，如讀取和刪除記錄。

1. basePath(基本路徑)和Upsert方法

定義一個basePath，upsert方法會將表數據寫入該路徑，該方法將以org.apache.hudi格式寫入Dataframe，請確保上面討論的所有Hudi屬性均已設置。

val basePath = "/tmp/store"

private def upsert(albumDf: DataFrame, tableName: String, key: String, combineKey: String) = {
    albumDf.write
      .format("hudi")
      .option(DataSourceWriteOptions.TABLE_TYPE_OPT_KEY, DataSourceWriteOptions.COW_TABLE_TYPE_OPT_VAL)
      .option(DataSourceWriteOptions.RECORDKEY_FIELD_OPT_KEY, key)
      .option(DataSourceWriteOptions.PRECOMBINE_FIELD_OPT_KEY, combineKey)
      .option(HoodieWriteConfig.TABLE_NAME, tableName)
      .option(DataSourceWriteOptions.OPERATION_OPT_KEY, DataSourceWriteOptions.UPSERT_OPERATION_OPT_VAL)
      // Ignore this property for now, the default is too high when experimenting on your local machine
      // Set this to a lower value to improve performance.
      // I'll probably cover Hudi tuning in a separate post.
      .option("hoodie.upsert.shuffle.parallelism", "2")
      .mode(SaveMode.Append)
      .save(s"$basePath/$tableName/")
  }

2. 初始化upsert

插入INITIAL_ALBUM_DATA，我們應該創建2條記錄，對於801，該記錄的日期為2019-12-03。

val tableName = "Album"
upsert(INITIAL_ALBUM_DATA.toDF(), tableName, "albumId", "updateDate")
spark.read.format("hudi").load(s"$basePath/$tableName/*").show()

讀取CoW表就像使用格式（“hudl”）的常規spark.read一樣簡單。

// Output
+-------------------+--------------------+------------------+----------------------+--------------------+-------+-----------------+--------------------+----------+
|_hoodie_commit_time|_hoodie_commit_seqno|_hoodie_record_key|_hoodie_partition_path|   _hoodie_file_name|albumId|            title|              tracks|updateDate|
+-------------------+--------------------+------------------+----------------------+--------------------+-------+-----------------+--------------------+----------+
|     20200412182343|  20200412182343_0_1|               801|               default|65841d0a-0083-447...|    801|Hail to the Thief|[2+2=5, Backdrift...|     18233|
|     20200412182343|  20200412182343_0_2|               800|               default|65841d0a-0083-447...|    800|  6 String Theory|[Lay it down, Am ...|     18231|
+-------------------+--------------------+------------------+----------------------+--------------------+-------+-----------------+--------------------+----------+

另一種確定的方法是查看Workload profile的日誌輸出，內容大致如下

Workload profile :WorkloadProfile {globalStat=WorkloadStat {numInserts=2, numUpdates=0}, partitionStat={default=WorkloadStat {numInserts=2, numUpdates=0}}}

3. 更新記錄

upsert(UPSERT_ALBUM_DATA.toDF(), tableName, "albumId", "updateDate")

查看Workload profile的日誌輸出，並驗證它是否符合預期

Workload profile :WorkloadProfile {globalStat=WorkloadStat {numInserts=2, numUpdates=1}, partitionStat={default=WorkloadStat {numInserts=2, numUpdates=1}}}

查詢輸出如下

spark.read.format("hudi").load(s"$basePath/$tableName/*").show()

//Output
+-------------------+--------------------+------------------+----------------------+--------------------+-------+--------------------+--------------------+----------+
|_hoodie_commit_time|_hoodie_commit_seqno|_hoodie_record_key|_hoodie_partition_path|   _hoodie_file_name|albumId|               title|              tracks|updateDate|
+-------------------+--------------------+------------------+----------------------+--------------------+-------+--------------------+--------------------+----------+
|     20200412183510|  20200412183510_0_1|               801|               default|65841d0a-0083-447...|    801|   Hail to the Thief|[2+2=5, Backdrift...|     18233|
|     20200412184040|  20200412184040_0_1|               800|               default|65841d0a-0083-447...|    800|6 String Theory -...|[Jumpin' the blue...|     18264|
|     20200412184040|  20200412184040_0_2|               802|               default|65841d0a-0083-447...|    802|  Best Of Jazz Blues|[Jumpin' the blue...|     18265|
|     20200412184040|  20200412184040_0_3|               803|               default|65841d0a-0083-447...|    803|       Birth of Cool|[Move, Jeru, Moon...|     18295|
+-------------------+--------------------+------------------+----------------------+--------------------+-------+--------------------+--------------------+----------+

4. 查詢記錄

我們在上面查看數據的方式稱為“快照查詢”，這是默認設置，另外還支持“增量查詢”。

4.1 增量查詢

要執行增量查詢，我們需要在讀取時將hoodie.datasource.query.type屬性設置為incremental，並指定hoodie.datasource.read.begin.instanttime屬性。這將在指定的即時時間之後讀取所有記錄，對於本示例，我們將instantTime指定為20200412183510。

spark.read
    .format("hudi")
    .option(DataSourceReadOptions.QUERY_TYPE_OPT_KEY, DataSourceReadOptions.QUERY_TYPE_INCREMENTAL_OPT_VAL)
    .option(DataSourceReadOptions.BEGIN_INSTANTTIME_OPT_KEY, "20200412183510")
    .load(s"$basePath/$tableName")
    .show()

這將在提交時間20200412183510之後返回所有記錄。

+-------------------+--------------------+------------------+----------------------+--------------------+-------+--------------------+--------------------+----------+
|_hoodie_commit_time|_hoodie_commit_seqno|_hoodie_record_key|_hoodie_partition_path|   _hoodie_file_name|albumId|               title|              tracks|updateDate|
+-------------------+--------------------+------------------+----------------------+--------------------+-------+--------------------+--------------------+----------+
|     20200412184040|  20200412184040_0_1|               800|               default|65841d0a-0083-447...|    800|6 String Theory -...|[Jumpin' the blue...|     18264|
|     20200412184040|  20200412184040_0_2|               802|               default|65841d0a-0083-447...|    802|  Best Of Jazz Blues|[Jumpin' the blue...|     18265|
|     20200412184040|  20200412184040_0_3|               803|               default|65841d0a-0083-447...|    803|       Birth of Cool|[Move, Jeru, Moon...|     18295|
+-------------------+--------------------+------------------+----------------------+--------------------+-------+--------------------+--------------------+----------+

5. 刪除記錄

我們要查看的最後一個操作是刪除，刪除類似於upsert，需要一個待刪除記錄的DataFrame，如下面的示例代碼所示，不需要整行，只需要主鍵即可。

val deleteKeys = Seq(
    Album(803, "", null, 0l),
    Album(802, "", null, 0l)
)

import spark.implicits._

val df = deleteKeys.toDF()

df.write.format("hudi")
    .option(DataSourceWriteOptions.TABLE_TYPE_OPT_KEY, DataSourceWriteOptions.COW_TABLE_TYPE_OPT_VAL)
    .option(DataSourceWriteOptions.RECORDKEY_FIELD_OPT_KEY, "albumId")
    .option(HoodieWriteConfig.TABLE_NAME, tableName)
    // Set the option "hoodie.datasource.write.operation" to "delete"
    .option(DataSourceWriteOptions.OPERATION_OPT_KEY, DataSourceWriteOptions.DELETE_OPERATION_OPT_VAL)
    .mode(SaveMode.Append) // Only Append Mode is supported for Delete.
    .save(s"$basePath/$tableName/")

spark.read.format("hudi").load(s"$basePath/$tableName/*").show()

這是本部分介紹的全部內容。後面我們將探討在MERGE-ON-READ表進行操作。

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

【其他文章推薦】

※超省錢租車方案

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

※回頭車貨運收費標準

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

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

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

國產最快的SUV？這車上市連80萬的特斯拉都得服！

發佈日期: 2020-11-27 作者: admin

買電動車還要注意充電時間要多久，這點上，MODEL X的快充時間為4。5小時，慢充10。5小時。MARVEL X可在40分鐘內把80%的電充滿，就這點而言，明顯優勝於MODEL X。MARVEL X的底盤由保時捷工程師參与設計並調校，參考一下Macan和卡宴在公路上的操控表現，估計MARVEL X也差不到哪裡去。

4月23號下午，上汽集團在五棵松舉辦了第二屆汽車創行者大會。這屆大會一開始的時候，主要還是探討一下未來的汽車發展動向，講的都是頗為抽象的話題。最後才是榮威MARVEL X量產車型的亮相儀式。

去年第一屆汽車創行者大會時，上汽榮威便發布了光之翼概念車，只是那時候沒有實車。今年，光之翼的量產車型MARVEL X能順利亮相，也是給了我們不少驚喜。

MARVEL，原意為“造物的奇迹、令人驚奇的創造力”，而“X”延續了榮威品牌“重探索”的科技精神，更是預示着“新物種”(Xspecies)的鋒芒展露。從命名中可以看出，榮威MARVEL X攜帶了與生俱來的智能天賦和無限的創造力基因。

MARVEL X這款車的外形依舊是採用榮威的家族式前臉，只是整個設計會是家族中最為誇張的一個。前臉的全LED大燈和U型光弧尤為犀利，中網的橫條形鍍鉻裝飾條大氣耐看，與大燈相連的設計一體感較強。

側麵線條簡潔修長，門把手採用了與攬勝星脈一樣的感應式設計，只有用戶靠近時，才會自動彈出。底部的鍍鉻裝飾條頗有高級感，五輻式輪圈帥氣耐看。兩盞尾燈由一條鍍鉻裝飾條相連，加強了一體感。

MARVEL X保留了90%的概念車設計，從造型來看，更像是一台SUV。在聽廠商介紹一些關鍵數據時，發現這款車完全就是對飆MODEL X，甚至MODEL X 75D在它面前都要敗下來。

從上面的表格來看，MARVEL X雖然在風阻係數上高於MODEL X，但在零百加速和續航里程兩個關鍵數據上，都是表現得比MODEL X 75D要好。4秒破百這樣的成績已經是堪比不少超級跑車，所以說MARVEL X是一輛性能怪獸也不為過，這裏的性能僅僅只是指加速性能。

買電動車還要注意充電時間要多久，這點上，MODEL X的快充時間為4.5小時，慢充10.5小時。MARVEL X可在40分鐘內把80%的電充滿，就這點而言，明顯優勝於MODEL X。

MARVEL X的底盤由保時捷工程師參与設計並調校，參考一下Macan和卡宴在公路上的操控表現，估計MARVEL X也差不到哪裡去。除了這些過硬的實力外，MARVEL X還有五個全球第一。

全球第一台搭載“AR增強現實技術”的量產車，圖標直接出現在實景中，讓導航更精準更直觀；全球第一台搭載3.0版本互聯網汽車斑馬智行系統的量產車，配以14寸超級懸浮式大屏和更智能的人機交互，讓用戶搶先體驗到互聯網功能升級；

全球第一套全方位智能迎賓系統，只要用戶靠近，即可自動亮燈並自動調節座椅空間，歡迎用戶上車；全球第一台搭載無線智能給電系統的純電動車，讓電動汽車進入“無線時代”；全球第一台會自己找車位、自己泊車入庫的量產車，實現“人工智能代主泊車”的尊享體驗。

這麼多個第一中，雖然有部分是噱頭，但是最令人期待的莫過於3.0版本互聯網汽車斑馬智行系統，它可以實現更豐富的功能。此次亮相併沒有對內飾進行曝光，這點頗為可惜。

總結

雖然沒有公布預售價，但從各方面來看，MARVEL X將會是繼蔚來ES8后，又一款定位高端的國產電動車。這款車將在6月底開始預售，9月開始交付用戶，具體表現如何，我們大可拭目以待。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR ?

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

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

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