但是那樣的路段少之又少，在城市裡面幾乎用不上。為什麼會導致現在這樣尷尬的局面呢。其實現在回頭看市面上搭載9速卻很難用上第9擋的車型大多數小排量車型，因為廠家把9速拿來就是為了宣傳低油耗，但是最後搭配了一個不足以配合9AT的發動機，自由光就是這個反面教材，而像奔馳的GLE400，同樣是9AT，卻可以在80公里時速就輕鬆掛上第9擋，發動機的轉速還很低。

如果要在幾年前和你談十速變速箱，你可能以為我和你說的某台貨車

而現實是謳歌RLX已經搭載了10速變速箱

甚至已經為3離合11速變速箱申請專利

搞得大家沒有個8AT都不好意思出門

在過去很長一段時間里，特別是4AT還大行其道的時候，的確存在這樣一個現象，擋數越高就意味着更高的傳動效率、更好的燃油經濟性、更平順的動力輸出、更爽快的加速體驗，這些不假！

但是現在真實的情況是消費者被一些車商洗腦了，讓大家脫離汽車本身，專註於變速箱去了。像目前6、7速變速箱仍然是大眾的主力變速箱，而且據了解在未來很長一段時間內都不會更換，寶馬也已確定8AT變速箱已基本是終極。 而奔馳通過模擬分析后得出的結論，無需再開發9擋以上的變速度箱，甚至斷言檔數到達9擋以上后，就會成為發動機的累贅，雖然如此果斷的觀點不太妥當，畢竟奔馳打臉的事情也沒少干，最近復活直六發動機的事情也算其中之一吧。

但是之前的實例像Jeep的自由光

它是全球第一台搭載橫置9AT變速箱的車，廠家曾把它的9AT吹得天化亂墜，最後用戶們發現這玩意跟期待中的完全不是那麼一回事，但卻因為它花了大價錢。雖然也有些車主說自由光的9AT也有用到9擋的時候，據統計大多數是在下坡的高速公路路段。但是那樣的路段少之又少，在城市裡面幾乎用不上。

為什麼會導致現在這樣尷尬的局面呢？

其實現在回頭看市面上搭載9速卻很難用上第9擋的車型大多數小排量車型，因為廠家把9速拿來就是為了宣傳低油耗，但是最後搭配了一個不足以配合9AT的發動機，自由光就是這個反面教材，而像奔馳的GLE400，同樣是9AT，卻可以在80公里時速就輕鬆掛上第9擋，發動機的轉速還很低。

所以這個掛不上第9擋的鍋，現在來說不一定是變速箱來背，這就像什麼呢，你去買衣服，明明是140的身高，但是一想190的和140的價格一樣，布料卻更多，買190的比較划算，所以就買了一個並不合身的衣服，布料是賺到了，但是穿着好不好只有自己知道。

而且我們並不能只看變速箱這一點，而是整車動力系統的匹配，就像你女友看到你撅屁股就知道你要放屁。

放到汽車上也是一樣，變速箱更智能积極的換擋邏輯，知道你踩油門應該升擋還是降擋，發動機同時也要能配合，升到最高擋發動機轉速低時，也不會覺得發動機乏力，這些才是我們想要的。如果能夠做到這些又何必在乎它有多少個擋呢？本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

※回頭車貨運收費標準

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

※超省錢租車方案

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

※推薦台中搬家公司優質服務,可到府估價

1秒，最高時速為250km/h（电子限速），標配的前245/35 ZR19后265/35 ZR19輪胎也能夠提供強大的抓地力，為強大的性能提供保障。配合上AMG C 63 Sedan的陶瓷通風剎車盤、後橋限滑差速器等高科技裝備，AMG C 63 Sedan的運動性得到了最好的施展空間。

作為一名汽車編輯，小編有機會試到各種高性能車型，而最讓小編沉醉的就是大排量V8發動機。

V8發動機是目前超級性能車中最常用的發動機類型，我們熟悉的許許多多的超跑和超級性能車都使用的V8發動機，比如法拉利488、邁凱輪p1等車型都使用的V8發動機，在如今小排量車型大行其道的今天，V8發動機仍然有着不可抗拒的魅力。

為什麼V8的魅力依然無可取代？

性能車到底多少個氣缸比較好？在小編看來這個最佳氣缸數非8缸不可，8缸是一個臨界點，12缸發動機雖然有着十分兇猛的動力輸出以及更好的運轉精緻度，但是巨大的尺寸和重量會嚴重影響到性能車的操控表現以及重量分配，許多搭載12缸發動機的車型都有一個嚴重的推頭問題，實際操控性能反倒不如8缸車型。

而6缸發動機先天排量不足，小排量的結構劣勢導致了6缸發動機雖然動力輸出足夠強大，但是和真正的超級性能車型相比它的動力輸出還是有不小差距，即使加上渦輪增壓或者机械增壓之後仍然不能夠表現出性能車該有的兇悍。而如果要強行壓榨動力就必須使用更大的渦輪，這樣小排量渦輪增壓車型的渦輪遲滯問題也就隨之出現了，而使用机械增壓的話效率並不高，而且高轉速的噪音比較大，机械增壓也不利於轉速的提升。

而V8發動機中做的最好的莫過於奔馳AMG，比如說奔馳AMG C 63 Sedan上那台4.0T V8雙渦輪增壓發動機，這台V8發動機尺寸和重量都比較適中，而且由於基礎排量比較大氣缸數也比較多，所以這台V8發動機動力輸出十分強勁，發動機底氣十足，即使在低轉速下也有十分恐怖的扭矩輸出，並且發動機低沉的聲浪以及換擋收油時候的“放炮聲”都十分勾魂，這樣的聲浪聽起來是一種享受。

AMG C 63 Sedan的4.0T V8發動機最大功率476馬力，最大扭矩達到了650牛米。而且發動機的最大扭矩輸出區間為1750-4500轉，寬泛的扭矩輸出平台也保證了動力隨叫隨到，提供最強大的響應性支持。

在如此強大動力的加持下AMG C 63 Sedan的0~100km/h加速時間僅需4.1秒，最高時速為250km/h（电子限速），標配的前245/35 ZR19后265/35 ZR19輪胎也能夠提供強大的抓地力，為強大的性能提供保障。

配合上AMG C 63 Sedan的陶瓷通風剎車盤、後橋限滑差速器等高科技裝備，AMG C 63 Sedan的運動性得到了最好的施展空間。奔馳的動態選檔系統也十分實用，可以說是駕馭住這款性能猛獸的神器，動態選檔系統從運動到舒適一共有5檔可以選擇，通過改變油門的響應性、轉向力度、懸挂的阻尼等實現在運動和舒適之間的平衡。

AMG三個字母是什麼含義？

AMG是頂級性能和極致駕控魅力的代名詞，AMG的造車技術登峰造極，尤其是在發動機的設計與製造上，奔馳 A45AMG上那台2.0T發動機就能夠爆出了380馬力的恐怖輸出，而AMG C 63 Sedan上的4.0T V8雙渦輪增壓發動機的輸出恐怖程度也就可想而知了，正因為奔馳AMG能夠造出輸出十分恐怖的發動機，因此我們熟悉的頂級跑車帕加尼都使用AMG提供的發動機。

AMG的歷史可以追溯到上世紀60年代；1967年6月1日，AMG雛形“AMG 設計與測試賽車發動機技術公司”誕生，從此輝煌45載AMG名聲籍甚，在高性能汽車領域AMG無人不知無人不曉，高性能與創新是AMG至死不渝的造車理念，動力、操控和聲音上AMG都追求極致，AMG致力於製造最完美的高性能汽車，因此AMG也擁有大量的忠實擁躉。

而在創新上AMG也是高性能汽車領域的先行者，1984年工程師Melcher開發了完全獨立的氣缸蓋，因此AMG成為發動機生產公司。強調一人一機理念，目前AMG已經成為擁有1100多人的公司，其中工程師就多達500位。擁有眾多技術高超的工程師和設計師的AMG也就掌握了最先進的研發力量，而AMG每一台發動機，每一台車型都有專門的工程師負責裝配和檢驗，並且在發動機上籤下工程師的名字，細緻的檢測精心的裝配，確保每一台AMG都能夠發揮它的最強勁最穩定的性能。

發動機是AMG的靈魂，也是一台性能車的靈魂，AMG C 63 Sedan代表的不僅僅是一台性能車，而是代表着性能車同級最強的表現，V8的魅力無法拒絕，而更讓人難以拒絕的是奔馳AMG C 63 Sedan的V8。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※超省錢租車方案

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

※回頭車貨運收費標準

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

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

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

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

web最精妙的設計就是通過url把多個頁面串聯起來，並且可以互相跳轉。我們開發系統的時候總是需要使用路由來實現頁面間的跳轉。傳統的web開發主要是使用a標籤或者是服務端redirect來跳轉。那今天來看看Blazor是如何進行路由的。

使用@page指定組件的路由path

我們可以在Blazor里給每個組件指定一個path，當路由匹配的時候會显示這個組件。

@page "/page/a"

 <h2>
     PAGE A
 </h2>

@code {
 
}

訪問/page/a 看到Page A頁面被渲染出來了。

注意：如果是在瀏覽器里敲入url按回車切換頁面，會發生一次http請求，然後重新渲染blazor應用。

使用a標籤進行頁面跳轉

a標籤作為超鏈接是我們web開發最常用的跳轉方式，blazor同樣支持。
新建Page B

@page "/page/b"

 <h2>
     PAGE B
 </h2>

@code {
 
}

在Page A頁面添加一個a標籤進行跳轉：

@page "/page/a"

 <h2>
     PAGE A
 </h2>
<p>
    <a href="/page/b">Page B</a>
</p>

@code {
 
}

運行一下試試：

注意：使用a連接在頁面間進行跳轉不會發生http請求到後台，頁面是直接在前端渲染出來的。

通過路由傳參

通過http的url進行頁面間傳參是我們web開發的常規操作。下面我們演示下如何從Page A傳遞一個參數到Page B。我們預設Page A裏面有個UserName需要傳遞到Page B，並且显示出來。

通過path傳參

通過url傳參一般有兩種方式，一種是直接把參數組合在path里，比如“/page/b/小明”這樣。

修改Page A：

@page "/page/a"

 <h2>
     PAGE A
 </h2>
<p>
    <a href="/page/b/@userName">Page B</a>
</p>

@code {
    private string userName = "小明";
}

通過把userName組合到path上傳遞給Page B。

修改Page B：

@page "/page/b/{userName}"

 <h2>
     PAGE B
 </h2>
<p>
    userName: @userName
</p>

@code {
    [Parameter]
    public string userName { get; set; }
}

Page B 使用一個“/page/b/{userName}” pattern來匹配userName,並且userName需要標記[Parameter]並且設置為public。

通過QueryString傳參

除了把參數直接拼接在path里，我們還習慣通過QueryString方式傳遞，比如“/page/b?username=小明”。

修改Page A：

@page "/page/a"

<h2>
    PAGE A
</h2>
<p>
    <a href="/page/b?username=@userName">Page B</a>
</p>

@code {
    private string userName = "小明";
}

首先安裝一個工具庫：

Install-Package Microsoft.AspNetCore.WebUtilities -Version 2.2.0

修改Page B：

@page "/page/b"

<h2>
    PAGE B
</h2>
<p>
    userName: @UserName
</p>

@using Microsoft.AspNetCore.WebUtilities;

@inject NavigationManager NavigationManager;

@code {
    [Parameter]
    public string UserName { get; set; }


    protected override void OnInitialized()
    {
        var uri = NavigationManager.ToAbsoluteUri(NavigationManager.Uri);
        QueryHelpers.ParseQuery(uri.Query).TryGetValue("username", out Microsoft.Extensions.Primitives.StringValues userName);
        Console.WriteLine(NavigationManager.Uri);
        UserName = userName.ToString();
        Console.WriteLine(UserName);

        base.OnInitialized();
    }
}

頁面獲取QueryString的傳參比較麻煩，Blazor並沒有進行封裝。所以我們需要通過QueryHelpers.ParseQuery方法手工把QueryString格式化成字典形式，然後獲取對應的參數。QueryHelpers類存在Microsoft.AspNetCore.WebUtilities這個庫里，需要通過nuget安裝。

NavLink

NavLink是個導航組件，它其實就是封裝了a標籤。當選中的時候，也就是當前的url跟它的href一致的時候，會自動在class上加上active類，所以可以用來控制選中的樣式。默認的3個導航菜單就是用的NavLink。

比如導航到counter的NavLink：

   <NavLink class="nav-link" href="counter">
                <span class="oi oi-plus" aria-hidden="true"></span> Counter
    </NavLink>

最後翻譯成html：

<a href="counter" class="nav-link active">
                <span class="oi oi-plus" aria-hidden="true"></span> Counter
</a>

NavigationManager

有的時候我們可能需要在代碼里進行導航，如果是JavaScript我們會用window.location來切換頁面，Blazor為我們提供了相應的封裝：NavigationManager。使用NavigationManager可以通過代碼直接進行頁面間的跳轉。我們在Page A頁面放個按鈕然後通過按鈕的點擊事件進行跳轉：

@page "/page/a"

<h2>
    PAGE A
</h2>
<p>
   <button @onclick="GoToB">
       go to B
   </button>
</p>

@inject NavigationManager NavigationManager
@code {

    private void GoToB()
    {
        NavigationManager.NavigateTo("/page/b?username=小貓");
    }

}

修改Page A的代碼，注入NavigationManager對象，通過NavigationManager.NavigateTo方法進行跳轉。

擴展Back方法

Blazor封裝的NavigationManager咋一看以為跟WPF的NavigationService一樣，我想當然的覺得裏面肯定有個Back方法可以進行後退。但是查了一番發現還真的沒有，這就比較尷尬了，沒辦法只能使用JavaScript來實現了。

為了方便我們給NavigationManager直接寫個擴展方法吧。
首先修改Program把IServiceCollection暴露出來：

    public class Program
    {
        public static IServiceCollection Services;

        public static async Task Main(string[] args)
        {
            var builder = WebAssemblyHostBuilder.CreateDefault(args);
            builder.RootComponents.Add<App>("app");

            builder.Services.AddTransient(sp => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
            Services = builder.Services;

            await builder.Build().RunAsync();
        }
    }

擴展類：

  public static class Ext
    {
        public static void Back(this NavigationManager navigation)
        {
            var jsruntime = Program.Services.BuildServiceProvider().GetService<IJSRuntime>();
            jsruntime.InvokeVoidAsync("history.back");
        }
    }

這個擴展方法很簡單，從DI容器里獲取IJSRuntime的實例對象，通過它去調用JavaScript的history.back方法。

修改Page B：

@page "/page/b"

<h2>
    PAGE B
</h2>
<p>
    userName: @UserName
</p>
<p>
    <button @onclick="GoBack">
        Go back
    </button>
</p>

@using Microsoft.AspNetCore.WebUtilities;

@inject NavigationManager NavigationManager;

@code {
    [Parameter]
    public string UserName { get; set; }


    protected override void OnInitialized()
    {
        var uri = NavigationManager.ToAbsoluteUri(NavigationManager.Uri);
        QueryHelpers.ParseQuery(uri.Query).TryGetValue("username", out Microsoft.Extensions.Primitives.StringValues userName);
        Console.WriteLine(NavigationManager.Uri);
        UserName = userName.ToString();
        Console.WriteLine(UserName);

        base.OnInitialized();
    }

    private void GoBack()
    {
        NavigationManager.Back();
    }
}

在Page B頁面上添加一個按鈕，點擊調用NavigationManager.Back方法就能回到上一頁。

總結

到此Blazor路由的內容學習的差不多了，整體上沒有什麼特別的，就是NavigationManager只有前進方法沒有後退是比較讓我震驚的。

相關內容：

ASP.NET Core Blazor Webassembly 之 數據綁定
ASP.NET Core Blazor Webassembly 之 組件
ASP.NET Core Blazor 初探之 Blazor WebAssembly
ASP.NET Core Blazor 初探之 Blazor Server

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

【其他文章推薦】

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

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

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

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

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

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

Unix 與 C 語言的關係

在服務器領域，最著名的系統莫過於Unix了，即便Linux也是類Unix的操作系統。Unix 是用 C 語言編寫的，而且是世界上第一個用 C 語言編寫的操作系統。但是 Unix 是怎麼產生的？C 語言又是怎麼產生的？Unix 為什麼要用 C 語言來編寫？相信看完這篇文章你很快就會有了答案。

 

Multics 和 Unix

1964年，在 Unix 誕生之前，美國貝爾實驗室、通用電氣、和麻省理工學院聯合開發了一個項目，叫做 Multics操作系統。Multics 在當時取得了巨大的成功，因為它給了人們一個真正可用並且很穩定的操作系統。當時從學校到政府機關，到處都在安裝 Multics。

 

但是時間到了 1969年，因為種種原因，貝爾實驗室的 Ken Thompson 和 Dennis Ritchie 決定放棄Multics，於是貝爾實驗室退出了這個項目。Ken Thompson 和 Dennis Ritchie 決定開發一個更為簡單並且高效的操作系統，並把它命名為 Unix，於是他們倆就成為了 Unix 之父。

 

和 Unix 相比，Multics 有兩個比較致命的缺點，一是需要安裝在非常昂貴的機器上，普通的計算機沒有辦法安裝。二是設計非常複雜，這也是貝爾實驗室的工程師退出的主要原因。不過 Ken Thompson 和 Dennis Ritchie 還是從 Multics 上得到很多啟發，可以說 Unix 是 Multics 的簡化以及更新。

 

說到這裏，C 語言還沒有出場，因為它在那個時候還沒有被發明出來。Unix 操作系統的第一個版本是純粹用彙編語言編寫出來的。一直到了 1974年，第四個版本才改用 C 語言進行開發。在講 C 語言之前，我們還不得不先說一下 BCPL 和 B 語言。

 

BCPL 與 B 語言

Ken Thompson 和 Dennis Ritchie 最初用彙編語言來開發 Unix，因為在那個時候，所有的操作系統都是用彙編語言來開發的。不過當時 Multics 是一個例外，Multics 項目組使用了 PL/1 來進行開發。它的價值就在於向世人展示了用一門高級語言也可以開發出一套操作系統。Ken Thompson 和 Dennis Ritchie 也受到了鼓舞，他們決定用彙編之外的語言重新開發 Unix。他們最初的選擇是 BCPL。BCPL 最早是由 Martin Richards 發明用來開發編譯器的語言。但是 Ken Thompson 和 Dennis Ritchie很快發現，如果他們想在小型計算機 DEC PDP-7 上使用 BCPL，就需要對這個語言本身進行一些修改。於是就產生了後來的 B 語言。

 

 B 語言作為系統開發語言，也存在很多的缺點，於是後來它又被改進為 NB 語言 （New B）。可是 NB 還是有很多的問題，於是 Dennis Ritchie 就又發明了 C 語言，最終在 1974年，Ken Thompson 和 Dennis Ritchie 一起用 C 語言重新編寫了第四版的 Unix 系統。現在，C 語言已經成為了操作系統開發最常用的編程語言。

 

通往 C 語言與 Unix 之路

Dennis Ritchie 曾經解釋過自己為什麼要發明 C 語言，以及使用 B 語言過程中遇到的一些困難：

• 只能處理計算機字：B語言所有的操作都是通過計算機字來處理的，在那個時候，能夠處理字節的編程語言對工程師們來說是一個夢。

• 沒有類型：準確的說，B語言只有一種類型，計算機字。如果你有一個字符串，可能你需要把它分成多個變量來保存，比如一個21個字符的字符串，就需要 6 個變量。

• 不支持浮點類型運算：在那個時候，大部分硬件已經都可以開始支持浮點運算了，但是 B 語言還不支持這種操作。 

 

B 語言的這些問題，開發低效，在機器上運行緩慢等等，都迫使 Dennis Ritchie 發明一種新的編程語言。最開始被稱為 New B，後來逐漸演化成了 C 語言。

 

C 語言解決了 B 語言的很多缺陷，並很快成為了開發操作系統最流行的一種編程語言。新版本的 Unix 以及今天很多類 Unix 的操作系統都是用 C 語言開發出來的。

 

好了，講到這裏，我想大家都清楚了 Unix 和 C 語言是怎麼來的了，以及為什麼要用 C 語言來編寫 Unix。現在有很多非常流行的語言比如 Java 和 Python，它們是一種更高級的編程語言，是在 C 語言這一層之上的。但是如果大家想做設備驅動或者系統內核模塊的修改，還是離不開 C 語言這把利器。

 

 

推薦閱讀：

《一篇文章帶你快速弄清楚什麼是終端》

《一篇文章看清楚 Linux 的職業發展方向》

《2020年你最需要掌握的11種編程語言》

《微軟：懸賞10萬美金破解 Linux 系統》

《安卓到底是不是Linux》

 

  

 

獲取知識乾貨、增加面試經驗、了解程序人生

歡迎關注微信公眾號

回復【面試】，獲取技術大廠面試寶典

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

【其他文章推薦】

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

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

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

※回頭車貨運收費標準

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

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

萬字長文，完全虛構。

 

（一）

 

組裡來了個實習生，李大胖面完之後，覺得水平一般，但還是留了下來，為什麼呢？各自猜去吧。

李大胖也在心裏開導自己，學生嘛，不能要求太高，只要肯上進，慢慢來。就稱呼為小白吧。

小白每天來的很早，走的很晚，都在用功學習，時不時也向別人請教。只是好像天資差了點。

都快一周了，才能寫些“簡單”的代碼，一個註解，一個接口，一個類，都來看看吧：

public @interface Health {

    String name() default "";
}


public interface Fruit {

    String getName();

    void setName(String name);

    int getColor();

    void setColor(int color);
}


@Health(name = "健康水果")
public class Apple implements Fruit {

    private String name;
    private int color;
    private double weight = 0.5;

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int getColor() {
        return color;
    }

    @Override
    public void setColor(int color) {
        this.color = color;
    }

    public double weight() {
        return weight;
    }

    public void weight(double weight) {
        this.weight = weight;
    }
}

與周圍人比起來，小白進步很慢，也許是自己不夠聰明，也許是自己不適合干這個，小白好像有點動搖了。

這幾天，小白明顯沒有一開始那麼上進了，似乎有點想放棄，這不，趴在桌子上竟然睡着了。

 

（二）

 

在夢中，小白來到一個奇怪又略顯陰森的地方，眼前有一個破舊的小房子，從殘缺不全的門縫裡折射出幾束光線。

小白有些害怕，但還是鎮定了下，深呼吸幾口，徑直朝着小房子走去。

小白推開門，屋裡沒有人。只有一個“機器”在桌子旁大口大口“吃着”東西，背後也不時的“拉出”一些東西。

小白很好奇，就湊了上去，準備仔細打量一番。

“你要幹嘛，別影響我工作”。突然冒出一句話，把小白嚇了一大跳，慌忙後退三步，媽呀，心都快蹦出來了。

“你是誰呀？”，驚慌中小白說了句話。

“我是編譯器”，哦，原來這個機器還會說話，小白這才緩了過來。

“編譯器”，小白好像聽說過，但一時又想不起，於是猜測到。

“網上評論留言里說的小編是不是就是你啊”？

“你才是呢”，編譯器白了一眼，沒好聲氣的說到。

要不是看在長得還行的份上，早就把你趕走了，編譯器心想。

“哦，我想起來了，編譯器嘛，就是編譯代碼的那個東西”，小白恍然大悟到。

“請注意你的言詞，我不是個東西，哦，不對，我是個東西，哦，好像也不對，我。。我。。”，編譯器自己也快暈了。

編譯器一臉的無奈，遇上這樣的人，今天我認栽了。

小白才不管呢，心想，今天我竟然見到了編譯器，我得好好請教請教他。

那編譯器會幫助她嗎？

 

 

（三）

 

小白再次走上前來，定睛一看，才看清楚，編譯器吃的是Java源碼，拉的是class（字節碼）文件。

咦，為啥這個代碼這麼熟悉呢，不就是我剛剛寫的那些。“停，停，快停下來了”。編譯器被小白叫停了。

“你又要幹嘛啊”？編譯器到。

“嘻嘻，這個代碼是我寫的，我想看看它是怎麼被編譯的”，小白到。

編譯器看了看這個代碼，這麼“簡單”，她絕對是個菜鳥。哎，算了，還是讓她看看吧。

不過編譯器又到，“整個編譯過程是非常複雜的，想要搞清楚裏面的門道是不可能的，今天也就只能看個熱鬧了”。

“編譯后的內容都是二進制數據，再通俗點說，就是一個長長的字節數組（byte[]）”，編譯器繼續說，“通常把它寫入文件，就是class文件了”。

“但這不是必須的，也可以通過網絡傳到其它地方，或者保存在內存中，用完之後就丟棄”。

“哇，還可以這樣”，小白有些驚訝。編譯器心想，你是山溝里出來的，沒見過世面，大驚小怪。

繼續到，“從數據結構上講，數組就是一段連續的空間，是‘沒有結構’的，就像一個線段一樣，唯一能做的就是按索引訪問”。

小白到，“編譯后的內容一定很繁多，都放到一個數組裡面，怎麼知道什麼東西都在哪呢？不都亂套了嘛”。

編譯器覺得小白慢慢上道了，心裏有一絲安慰，至少自己的講解不會完全白費。於是繼續到。

“所以JVM的那些大牛們早就設計好了字節碼的格式，而且還把它們放入到了一個字節數組裡面”。

小白很好奇到，“那是怎麼實現的呢”？

“其實也沒有太高深的內容，既然數組是按位置的，那就規定好所有內容的先後順序，一個接一個往數組裡放唄”。

“如果內容的長度是固定（即定長）的，那最簡單，直接放入即可”。

“如果內容長度是不固定（即變長）的，也很簡單，在內容前用一到兩個字節存一下內容的長度不就OK了”。

 

 

（四）

 

“字節碼的前4個字節必須是一個固定的数字，它的十進制是3405691582，大部分人更熟悉的是它的十六進制，0xCAFEBABE”。

“通常稱之為魔術数字（Magic），它主要是用來區分文件類型的”，編譯器到。

“擴展名（俗稱後綴名）不是用來區分文件類型的嗎”？小白說到，“如.java是Java文件，.class是字節碼文件”。

“擴展名確實可以區分，但大部分是給操作系統用的，或給人看到。如我們看到.mp3時知道是音頻、.mp4是知道是視頻、.txt是文本文件”。

“操作系統可以用擴展名來關聯打開它的軟件，比如.docx就會用word來打開，而不會用文本文件”。編譯器繼續到。

“還有一個問題就是擴展名可以很容易被修改，比如把一個.java手動改為.class，此時讓JVM來加載這個假的class文件會怎樣呢”？

“那JVM先讀取開頭4個字節，發現它不是剛剛提到的那個魔數，說明它不是合法的class文件，就直接拋異常唄”，小白說到。

“很好，真是孺子可教”，編譯器說道，“不過還有一個問題，不知你是否注意到？4個字節對應Java的int類型，int類型的最大值是2147483647”。

“但是魔數的值已經超過了int的最大值，那怎麼放得下呢，難道不會溢出嗎”？

“確實啊，我怎麼沒發現呢，那它到底是怎麼放的呢”？小白到。

“其實說穿了不值得一提，JVM是把它當作無符號數對待的。而Java是作為有符號數對待的。無符號數的最大值基本上是有符號數最大值的兩倍”。

“接下來的4個字節是版本號，不同版本的字節碼格式可能會略有差異，其次在運行時會校驗，如JDK8編譯后的字節碼是不能放到JDK7上運行的”。

“這4個字節中的前2個是次（minor）版本，后2個是主（major）版本”。編譯器繼續到，“比如我現在用的JDK版本是1.8.0_211，那次版本就是0，主版本就是52”。

“所以前8個字節的內容是，0xCAFEBABE，0，52，它們並不是源代碼里的內容”。

Magic [getMagic()=0xcafebabe]
MinorVersion [getVersion()=0]
MajorVersion [getVersion()=52]

 

（五）

 

當編譯器讀到源碼中的public class的時候，然後就就去查看一個表格，如下圖：

自顧自的說著，“public對應的是ACC_PUBLIC，值為0x0001，class默認就是，然後又讀ACC_SUPER的值0x0020”。

“最後把它倆合起來（按位或操作），0x0001 | 0x0020 => 0x0021，然後把這個值存起來，這就是這個類的訪問控制標誌”。

小白這次算是開了眼界了，只是還有一事不明，“這個ACC_SUPER是個什麼鬼”？

編譯器解釋到，“這是歷史遺留問題，它原本表達在調用父類方法時會特殊處理，不過現在已經不再管它了，直接忽略”。

接着讀到了Apple，它是類名。編譯器首先要獲取類的全名，org.cnt.java.Apple。

然後對它稍微轉換一下形式，變成了，org/cnt/java/Apple，“這就是類名在字節碼中的表示”。

編譯器發現這個Apple類沒有顯式繼承父類，表明它繼承自Object類，於是也獲取它的全名，java/lang/Object。

接着讀到了implements Fruit，說明該類實現了Fruit接口，也獲取全名，org/cnt/java/Fruit。

小白說到，“這些比較容易理解，全名中把點號（.）替換為正斜線（/）肯定也是歷史原因了。但是這些信息如何存到數組裡呢”？

“把點號替換為正斜線確實是歷史原因”，編譯器繼續到，“這些字符串雖然都是類名或接口名，但本質還是字符串，類名、接口名只是賦予它的意義而已”。

“除此之外，像字段名、方法名也都是字符串，同理，字段名、方法名也是賦予它的意義。所以字符串是一種基本的數據，需要得到支持”。

“除了字符串之外，還有整型数字，浮點数字，這些也是基本的數據，也需要得到支持”。

因此，設計者們就設計出了以下幾種類型，如圖：

“左邊是類型名稱，方便理解，右邊是對應的值，用於存儲”，編譯器繼續到。

“這裏的Integer/Long/Float/Double和Utf8都是具體保存數據用的，表示整型數/浮點數和字符串。其它的類型大都是對字符串的引用，並賦予它一定的意義”。

“所以類名首先被存儲為一個字符串，也就是Utf8，它的值對應的是1”。編譯器接着到，“由於字符串是一個變長的，所以就先用兩個字節存儲字符串的長度，接着跟上具體的字符串內容”。

所以字符串的結構就是這樣，如圖：

“類名字符串的存儲數據為，1、18、org/cnt/java/Apple。第一個字節為1，表明是Utf8類型，第2、3兩個字節存儲18，表示字符串長度是18，接着存儲真正的字符串。所以共用去1 + 2 + 18 => 21個字節”。

“父類名字符串存儲為，1、16、java/lang/Object。共用去19個字節”。

“接口名字符串存儲為，1、18、org/cnt/java/Fruit。共用去21個字節”。

小白聽的不住點頭，編譯器喘口氣，繼續講解。

“字符串存好后，就該賦予它們意義了，在後續的操作中肯定涉及到對這些字符串的引用，所以還要給每個字符串分配一個編號”。

如Apple為#2，即2號，Object為#4，Fruit為#6。

“由於這三個字符串都是類名或接口名，按照設計規定應該使用Class表示，對應的值為7，然後再指定一個字符串的編號即可”。

因此類或接口的表示如下圖：

“先用1個字節指明是類（接口），然後再用2個字節存儲一個字符串的編號。整體意思很直白，就是把這個編號的字符串當作類名或接口名”。

“類就表示為，7、#2。7表示是Class，#2表示類名稱那個字符串的存儲編號。共用去3個字節”。

“父類就表示，7、#4。共用去3個字節。接口就表示為，7、#6。共用去3個字節”。

其實這三個Class也分別給它們一個編號，方便別的地方再引用它們。

 

 

（六）

 

“其實上面這些內容都是常量，它們都位於常量池中，它們的編號就是自己在常量池中的索引”。編譯器說到。

“常量池很多人都知道，起碼至少是聽說過。但絕大多數人對它並不十分熟悉，因為很少有人見過它”。

編譯器繼續到，“今天你可算是來着了”，說著就把小白寫的類編譯後生成的常量池擺到了桌子上。

“這是什麼東西啊，這麼多，又很奇怪”，小白說到，這也是她第一次見。

ConstantPoolCount [getCount()=46]
ConstantPool [
#0 = null
#1 = ConstantClass [getNameIndex()=2, getTag()=7]
#2 = ConstantUtf8 [getLength()=18, getString()=org/cnt/java/Apple, getTag()=1]
#3 = ConstantClass [getNameIndex()=4, getTag()=7]
#4 = ConstantUtf8 [getLength()=16, getString()=java/lang/Object, getTag()=1]
#5 = ConstantClass [getNameIndex()=6, getTag()=7]
#6 = ConstantUtf8 [getLength()=18, getString()=org/cnt/java/Fruit, getTag()=1]
#7 = ConstantUtf8 [getLength()=4, getString()=name, getTag()=1]
#8 = ConstantUtf8 [getLength()=18, getString()=Ljava/lang/String;, getTag()=1]
#9 = ConstantUtf8 [getLength()=5, getString()=color, getTag()=1]
#10 = ConstantUtf8 [getLength()=1, getString()=I, getTag()=1]
#11 = ConstantUtf8 [getLength()=6, getString()=weight, getTag()=1]
#12 = ConstantUtf8 [getLength()=1, getString()=D, getTag()=1]
#13 = ConstantUtf8 [getLength()=6, getString()=<init>, getTag()=1]
#14 = ConstantUtf8 [getLength()=3, getString()=()V, getTag()=1]
#15 = ConstantUtf8 [getLength()=4, getString()=Code, getTag()=1]
#16 = ConstantMethodRef [getClassIndex()=3, getNameAndTypeIndex()=17, getTag()=10]
#17 = ConstantNameAndType [getNameIndex()=13, getDescriptorIndex()=14, getTag()=12]
#18 = ConstantDouble [getDouble()=0.5, getTag()=6]
#19 = null
#20 = ConstantFieldRef [getClassIndex()=1, getNameAndTypeIndex()=21, getTag()=9]
#21 = ConstantNameAndType [getNameIndex()=11, getDescriptorIndex()=12, getTag()=12]
#22 = ConstantUtf8 [getLength()=15, getString()=LineNumberTable, getTag()=1]
#23 = ConstantUtf8 [getLength()=18, getString()=LocalVariableTable, getTag()=1]
#24 = ConstantUtf8 [getLength()=4, getString()=this, getTag()=1]
#25 = ConstantUtf8 [getLength()=20, getString()=Lorg/cnt/java/Apple;, getTag()=1]
#26 = ConstantUtf8 [getLength()=7, getString()=getName, getTag()=1]
#27 = ConstantUtf8 [getLength()=20, getString()=()Ljava/lang/String;, getTag()=1]
#28 = ConstantFieldRef [getClassIndex()=1, getNameAndTypeIndex()=29, getTag()=9]
#29 = ConstantNameAndType [getNameIndex()=7, getDescriptorIndex()=8, getTag()=12]
#30 = ConstantUtf8 [getLength()=7, getString()=setName, getTag()=1]
#31 = ConstantUtf8 [getLength()=21, getString()=(Ljava/lang/String;)V, getTag()=1]
#32 = ConstantUtf8 [getLength()=16, getString()=MethodParameters, getTag()=1]
#33 = ConstantUtf8 [getLength()=8, getString()=getColor, getTag()=1]
#34 = ConstantUtf8 [getLength()=3, getString()=()I, getTag()=1]
#35 = ConstantFieldRef [getClassIndex()=1, getNameAndTypeIndex()=36, getTag()=9]
#36 = ConstantNameAndType [getNameIndex()=9, getDescriptorIndex()=10, getTag()=12]
#37 = ConstantUtf8 [getLength()=8, getString()=setColor, getTag()=1]
#38 = ConstantUtf8 [getLength()=4, getString()=(I)V, getTag()=1]
#39 = ConstantUtf8 [getLength()=3, getString()=()D, getTag()=1]
#40 = ConstantUtf8 [getLength()=4, getString()=(D)V, getTag()=1]
#41 = ConstantUtf8 [getLength()=10, getString()=SourceFile, getTag()=1]
#42 = ConstantUtf8 [getLength()=10, getString()=Apple.java, getTag()=1]
#43 = ConstantUtf8 [getLength()=25, getString()=RuntimeVisibleAnnotations, getTag()=1]
#44 = ConstantUtf8 [getLength()=21, getString()=Lorg/cnt/java/Health;, getTag()=1]
#45 = ConstantUtf8 [getLength()=12, getString()=健康水果, getTag()=1]
]

“在常量池前面會用2個字節來存儲常量池的大小，需要記住的是，這個大小不一定就是池中常量的個數。但它減去1一定是最大的索引”。

“因為，常量池中為0的位置（#0）永遠不使用，還有Long和Double類型一個常量佔2個連續索引（沒錯，又是歷史原因），實際只是用了第1個索引，第2個索引永遠空着（參見#18、#19）”。

編譯器繼續到，“#0是特殊的，用來表示‘沒有’的意思，其它地方如果想表達沒有的話，可以指向它。如Object是沒有父類的，所以它的父類指向#0，即沒有”。

“所以常量都是從#1開始。可以看看#1到#6的內容，就是剛剛上面講的”。編譯器說到。

“真是學到不少知識啊”，小白說到，“關於常量池能不能再多講點”？編譯器只好繼續講。

 

 

（七）

 

“常量池就是一個容器，它裏面放了各種各樣的所有信息，並且為每個信息分配一個編號（即索引），如果想要在其它地方使用這些信息，直接使用這個編號就行了”。

編譯器繼續到，“這個常量池在一些語言中也被稱為‘符號表’，通過編號來使用的這種方式也被稱為‘符號引用’”。

相信很多愛學習的同學對符號表和符號引用這兩個詞都很熟悉，不管之前是不是真懂，至少現在應該是真的搞懂了。因為你已經看到了。

“採用這種常量池和常量引用方式的好處其實很多，就說個最容易想到的，就是重複利用，節省空間，便於管理”。編譯器繼續說。

“比如一個類里有10個方法，每個方法里都定義一個length的局部變量，那麼length這個名字就會出現在常量池裡面，且只會出現一次，那10個方法都是對它的引用而已”。

“如果有一個方法的名字也叫length的話，那也是對同一個常量的引用，因為這個length常量只是個字符串數據而已，本身沒有明確含義，它的含義來自於引用它的常量”。

“哦，原來如此”，小白開悟到，“‘符號表、符號引用’這些‘高大上’的叫法，不過就是根據索引去列表裡獲取元素罷了”，哈哈。

編譯器看到小白這麼開心，就準備拋出一個問題，“打壓”一下她。於是說到。

“常量池看上去和數組/列表非常相似，都是容器且都是基於索引訪問的。為啥常量池只被稱為符號表，而不是符號數組或符號列表呢”？

小白自然回答不上來。編譯器繼續說，“表的英文單詞是Table。它和數組/列表的唯一區別就是，數組/列表裡的元素長度都是固定的。表裡的元素長度是不固定的”。

“常量池中的好幾種常量的長度都是變長的，所以自然是表了”。

小白點了點頭，心裏想，這編譯器就是厲害，我這輩子看來都無法達到他的高度了。

編譯器繼續說到，“字節碼的前8個字節存儲魔數和版本，接着的2個（9和10）字節存儲常量池的大小，後面接着（從11開始）就是整個常量池的內容了”。

“之所以把常量池放這麼靠前，是因為後面的所有內容都要依賴它、引用它”。

緊跟在常量池之後的就是這個類的基本信息，如下：

“首先用2個字節存儲上面已經計算好的訪問控制標誌，即0x0021”。

“然後用2個字節存儲這個類在常量池中的索引，就是#1”。

“然後用2個字節存儲該類的父類在常量池中的索引，就是#3”。

“由於接口可以有多個，所以再用2個字節存儲接口的個數，因為只實現了1個接口，所以就存儲数字1”。

“接着存儲所有接口在常量池中的索引，每個接口用2個字節。因為只實現了1個接口，所以存儲的索引就是#5”。

AccessFlags [getAccessFlags()=0x21, getAccessFlagsString()=[ACC_PUBLIC, ACC_SUPER]]
ThisClass [getClassIndex()=1, getClassName()=org/cnt/java/Apple]
SuperClass [getClassIndex()=3, getClassName()=java/lang/Object]
InterfacesCount [getCount()=1]
Interfaces [getClassIndexes()=[5], getClassNames()=[org/cnt/java/Fruit]]

 

 

 

（八）

 

編譯器繼續到，“接下來該讀取字段信息了”。當讀到private時，就去下面這張表裡找：

找到ACC_PRIVATE，把它的值0x0002保存以下，這就是該字段的訪問控制標誌。

接着讀到的是String，這是字段的類型，然後會把這個String類型存入常量池，對應的索引是#8。

可以看到是一個Utf8，說明是字符串，內容是 Ljava/lang/String; ，以大寫L開頭，已分號;結尾，中間是類型全名，這是在字節碼中表示類（對象）類型的方式。

接着讀到的是name，這是字段名稱，也是個字符串，同樣也把它放入常量池，對應的索引是#7。

編譯器說到，“現在一個字段的信息已經讀取完畢，按照相同的方式把剩餘的兩個字段也讀取完畢”。

“那字段的信息又該怎麼存儲呢”？小白問到。“不要着急嘛”，編譯器說著就拿出了字段的存儲格式：

首先2個字節是訪問控制標誌，接着2個字節是字段名稱在常量池中的索引，接着2個字節是字段描述（即類型）在常量池中的索引。

接着2個字節就是屬性個數，然後就是具體的屬性信息了。例如字段上標有註解的話，這個註解信息就會放入屬性信息里。

編譯器繼續說到，“屬性信息是字節碼中比較複雜的內容，這裏就不說太多了”。接着就可以按格式整理數據了。

因為一個類的字段可以有多個，所以先用2個字節存儲一下字段數目，本類有3個字段，所以就存儲個3。

第一個字段，0x0002、#7、#8、0。共用去8個字節，因為自動沒有屬性內容。

第二個字段，0x0002、#9、#10、0。共用去8個字節。

第二個字段，0x0002、#11、#12、0。共用去8個字節。

編譯器接着說，“所以存儲這3個字段信息共用去2 + 8 + 8 + 8 => 26個字節”。

小白說到，“我現在基本已經搞明白套路了。其實有些東西沒有想象中的那麼複雜啊”。

“複雜的東西還是有的，我們現在先不考慮”，編譯器說到，“還有一個問題，不知你發現了沒有”。

字段color的類型是int，但是在常量池中卻變為大寫字母I，同樣weight的類型是double，常量池中卻是大寫字母D。

小白說到，“我來猜測一下吧，int、double是Java中的數據類型，I、D是與之對應的在JVM中的表示形式。對吧”？

“算你聰明”，編譯器說到，“其實Java和JVM之間關於類型這塊有一個映射表”，如下：

有兩個需要注意。“第一點上面已經說過了，就是類都會映射成LClassName;這種形式，如Object映射為Ljava/lang/Object;”。

第二點是數組，“數組在Java中用一對中括號（[]）表示，在JVM中只用左中括號（[）表示。也就是[]映射為[”。

“多維數組也一樣，[][][]映射為[[[”。然後還有類型，“Java是把類型放到前面，JVM是把類型放到後面”。如double[]映射為[D。

“double[][][]映射為[[[D”。同理，“String[]映射為[Ljava/lang/String;，Object[][]映射為[[Ljava/lang/Object;”。

“我似乎又明白了一些，Java有自己的規範，字節碼也有自己的規範，它們之間的映射關係早都已經定義好了”。小白繼續到。

“只要按照這種映射關係，就能把Java源碼給轉換為字節碼。是吧”？

“粗略來說，可以這麼理解，其實這就是編譯了，但一定要清楚，真正的編譯是非常複雜的一個事情”，編譯器到。

小白說到，“字段完了之後，肯定該方法了，就交給我吧，讓我也試試”。

“年輕人啊，就是生猛，你來試試吧”。編譯器說到。

FieldsCount [getCount()=3]
Fields [
#0 = FieldInfo [getAccessFlags()=FieldAccessFlags [getAccessFlags()=0x2, getAccessFlagsString()=[ACC_PRIVATE]], getNameIndex()=7, getName()=name, getDescriptorIndex()=8, getDescriptor()=Ljava/lang/String;, getAttributesCount()=0, getAttributes()=[]]
#1 = FieldInfo [getAccessFlags()=FieldAccessFlags [getAccessFlags()=0x2, getAccessFlagsString()=[ACC_PRIVATE]], getNameIndex()=9, getName()=color, getDescriptorIndex()=10, getDescriptor()=I, getAttributesCount()=0, getAttributes()=[]]
#2 = FieldInfo [getAccessFlags()=FieldAccessFlags [getAccessFlags()=0x2, getAccessFlagsString()=[ACC_PRIVATE]], getNameIndex()=11, getName()=weight, getDescriptorIndex()=12, getDescriptor()=D, getAttributesCount()=0, getAttributes()=[]]
]

 

 

 

（九）

 

小白說，“方法呢肯定也有自己的格式，你把它找出來我看看”。

“好好，我這就找”，編譯器苦笑到。我堂堂一個編譯器，今天竟然成了小白的助手，慚愧啊。

說著編譯器就找到了，於是放到了桌子上：

“咦，怎麼和字段的一模一樣”，小白到。那這就更簡單了。

先是訪問控制標誌，接着是方法名稱索引，然後是方法描述索引，最後是和方法關聯的屬性。於是照貓畫虎，小白就開始了。

先讀到public關鍵字，這是個訪問控制修飾符，肯定也有一張表和它對應，可以找到這個關鍵字對應的數值。

還沒等小白開口，編譯器就趕緊把表找出來了：

小白繼續，ACC_PUBLIC對應的值是0x0001，就把這個值先保存起來。

然後是方法的名字，getName，是一個字符串，照例把它存入常量池，並且有一個索引，就是#26。

接着該方法的描述了，小白認為方法和字段是不同的，除了有返回類型之外，還有參數呢，這該咋整呢？

於是就問編譯器，“方法的描述應該也有格式吧”？

“你越來越聰明了”，編譯器說到，“其實也很簡單，我來簡單說下吧”。

“在Java中如果把訪問控制符、方法名、參數名、方法體都去掉，其實就剩下‘方法簽名’了”。

例如，沒有入參沒有返回值的，就是這個樣子，void()。

返回值為String，入參為int，double，String的，其實就是這樣個子，String(int, double, String)。

“這個方法簽名其實就是在Java中對方法的描述，在字節碼中和它差不多，就是把返回類型放到後面，把參數間的逗號去掉”。

因此void()映射為()V，這裏要注意的是void對應的是大寫字母V。

String(int, double, String)映射為(IDLjava/lang/String;)Ljava/lang/String;

“不難，不難”，小白說到，於是又繼續開始了。

小白按照這種格式，把剛剛的那個方法描述也存入了常量池，得到的索引就是#27。

小白按這個套路把6個方法都整理好了，接下來該按格式把數據寫入字節數組了。

編程新說注：方法的代碼對應的是JVM的指令，這裏就忽略不談了，後續可能會單獨再說。

編譯器提醒小白說，“你是不是還漏掉了一個方法啊”？

小白又看了一遍Java源碼，仔細數了數，是6個呀，沒錯啊。

編譯器說到，你在學習時有沒有見過這樣一句話，“當類沒有定義構造函數時，編譯器會為它生成一個默認的無參構造函數”。

小白連忙點頭，“嗯嗯嗯，見過的”。

“這就是了”，編譯器說道，“不過需要注意的是，在字節碼中構造方法的名字都是<init>，返回類型都是V”。

“這也是規定的吧”，小白說到，編譯器點了點頭。

編譯器又說到，“其實還有方法的參數信息，如參數位置，參數類型，參數名稱，參數的訪問控制標誌等”。

“這些信息都是放在方法格式里最後的屬性信息中的，咱們也暫時不說它們了”。

編程新說注：

在JDK7及以前，字節碼中不包含方法的參數名。因為JVM執行指令時，參數是按位置傳入的，所以參數名對代碼的執行沒有用處。

由於越來越多的框架採用按方法參數名進行數值綁定，Java也只好在JDK8時加入了對參數名的支持。

不過需要設置一下編譯器的–parameters參數，這樣才能把方法參數名也放入字節碼中。

可以看看常量池中的#32是“MethodParameters”字符串，說明字節碼中已經包含參數名了。

常量池中#7、#9、#11三個字符串就是參數名，同時也是字段名，這就是復用的好處。

編程新說注：方法的格式和字段的格式完全一樣，就不再演示寫入過程了。

因此這個類共有7個方法。

MethodsCount [getCount()=7]
Methods [
#0 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=13, getName()=<init>, getDescriptorIndex()=14, getDescriptor()=()V, getAttributesCount()=1, getAttributes()=[Code [getMaxStack()=3, getMaxLocals()=1, getCodeLength()=12, getJvmCode()=JvmCode [getCode()=12], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=3, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=8], LineNumTable [getStartPc()=4, getLineNumber()=12], LineNumTable [getStartPc()=11, getLineNumber()=8]]], LocalVariableTable [getLocalVarTableLength()=1, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=12, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0]]]]]]]
#1 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=26, getName()=getName, getDescriptorIndex()=27, getDescriptor()=()Ljava/lang/String;, getAttributesCount()=1, getAttributes()=[Code [getMaxStack()=1, getMaxLocals()=1, getCodeLength()=5, getJvmCode()=JvmCode [getCode()=5], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=1, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=16]]], LocalVariableTable [getLocalVarTableLength()=1, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=5, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0]]]]]]]
#2 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=30, getName()=setName, getDescriptorIndex()=31, getDescriptor()=(Ljava/lang/String;)V, getAttributesCount()=2, getAttributes()=[Code [getMaxStack()=2, getMaxLocals()=2, getCodeLength()=6, getJvmCode()=JvmCode [getCode()=6], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=2, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=21], LineNumTable [getStartPc()=5, getLineNumber()=22]]], LocalVariableTable [getLocalVarTableLength()=2, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=6, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0], LocalVarTable [getStartPc()=0, getLength()=6, getNameIndex()=7, getDescriptorIndex()=8, getIndex()=1]]]]], MethodParameters [getParametersCount()=1, getParameters()=[Parameter [getNameIndex()=7, getAccessFlags()=0x0]]]]]
#3 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=33, getName()=getColor, getDescriptorIndex()=34, getDescriptor()=()I, getAttributesCount()=1, getAttributes()=[Code [getMaxStack()=1, getMaxLocals()=1, getCodeLength()=5, getJvmCode()=JvmCode [getCode()=5], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=1, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=26]]], LocalVariableTable [getLocalVarTableLength()=1, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=5, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0]]]]]]]
#4 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=37, getName()=setColor, getDescriptorIndex()=38, getDescriptor()=(I)V, getAttributesCount()=2, getAttributes()=[Code [getMaxStack()=2, getMaxLocals()=2, getCodeLength()=6, getJvmCode()=JvmCode [getCode()=6], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=2, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=31], LineNumTable [getStartPc()=5, getLineNumber()=32]]], LocalVariableTable [getLocalVarTableLength()=2, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=6, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0], LocalVarTable [getStartPc()=0, getLength()=6, getNameIndex()=9, getDescriptorIndex()=10, getIndex()=1]]]]], MethodParameters [getParametersCount()=1, getParameters()=[Parameter [getNameIndex()=9, getAccessFlags()=0x0]]]]]
#5 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=11, getName()=weight, getDescriptorIndex()=39, getDescriptor()=()D, getAttributesCount()=1, getAttributes()=[Code [getMaxStack()=2, getMaxLocals()=1, getCodeLength()=5, getJvmCode()=JvmCode [getCode()=5], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=1, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=35]]], LocalVariableTable [getLocalVarTableLength()=1, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=5, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0]]]]]]]
#6 = MethodInfo [getAccessFlags()=MethodAccessFlags [getAccessFlags()=0x1, getAccessFlagsString()=[ACC_PUBLIC]], getNameIndex()=11, getName()=weight, getDescriptorIndex()=40, getDescriptor()=(D)V, getAttributesCount()=2, getAttributes()=[Code [getMaxStack()=3, getMaxLocals()=3, getCodeLength()=6, getJvmCode()=JvmCode [getCode()=6], getExceptionTableLength()=0, getExceptionTables()=[], getAttributesCount()=2, getAttributes()=[LineNumberTable [getLineNumTableLength()=2, getLineNumTables()=[LineNumTable [getStartPc()=0, getLineNumber()=39], LineNumTable [getStartPc()=5, getLineNumber()=40]]], LocalVariableTable [getLocalVarTableLength()=2, getLocalVarTables()=[LocalVarTable [getStartPc()=0, getLength()=6, getNameIndex()=24, getDescriptorIndex()=25, getIndex()=0], LocalVarTable [getStartPc()=0, getLength()=6, getNameIndex()=11, getDescriptorIndex()=12, getIndex()=1]]]]], MethodParameters [getParametersCount()=1, getParameters()=[Parameter [getNameIndex()=11, getAccessFlags()=0x0]]]]]
]

編程新說注：方法部分的輸出內容很多，是因為包含了方法體的代碼的信息。

 

 

（十）

 

“真是後生可畏啊”，編譯器感慨到。“小白竟然也能按照套路去在做點事情了”。

不過編譯器並不自危，因為最核心的內容是，可執行代碼如何轉換為JVM指令集中的指令，這可是“壓箱底”的乾貨，可不能隨便告訴別人，長得再好看也不行。哈哈，O(∩_∩)O。

接着編譯器拿出一個完整的字節碼文件格式圖給小白看：

小白看完后說，“和剛剛講的一樣，只是最後也有這個屬性信息啊”。

編譯器說，“屬性信息是字節碼文件中非常複雜的內容，可以暫時不管用了”。

上面已經說了，至少註解的相關內容是放在屬性信息里的。

那就看看你寫的這個類的屬性信息都是什麼吧：

AttributesCount [getCount()=2]
Attributes [
#0 = SourceFile [getSourcefileIndex()=42]
#1 = RuntimeVisibleAnnotations [getNumAnnotations()=1, getAnnotations()=[Annotation [getTypeIndex()=44, getNumElementValuePairs()=1, getElementValuePairs()=[ElementValuePair [getElementNameIndex()=7, getElementValue()=ElementValue [getTag()=ElementValueTag [getTagChar()=s], getUnion()=ElementValueUnion [getConstValueIndex()=45]]]]]]]
]

編譯器繼續說，共有2條屬性信息，第一條是源代碼文件的名字，在常量池中的#42。其實就是Apple.java了。

第二條是運行時可見的註解信息，本類共有1個註解，註解類型是常量池中的#44。其實就是Lorg/cnt/java/Health;了。

該註解共顯式設置了1對屬性值。屬性名稱是常量池中的#7，就是name了，類型是小寫的s，表示String類型，屬性值是#45，也就是“健康水果”了。

下圖中的這些類型，都是可以用於註解屬性的類型：

最後，編譯器打印出一行信息：

—–bytes=1085—–

小白說，“這是什麼意思”？“這是編譯后產生的字節碼的總長度，是1085個字節”，編譯器到。

小白剛想表達對編譯器的感謝，忽然聞到一陣香味，而且是肉香。

PS：最後幾句話就不寫了，請你來補充完整吧，嘻嘻。

 

 

>>> 熱門文章集錦 <<<

 

畢業10年，我有話說

【面試】我是如何面試別人List相關知識的，深度有點長文

我是如何在畢業不久只用1年就升為開發組長的

爸爸又給Spring MVC生了個弟弟叫Spring WebFlux

【面試】我是如何在面試別人Spring事務時“套路”對方的

【面試】Spring事務面試考點吐血整理（建議珍藏）

【面試】我是如何在面試別人Redis相關知識時“軟懟”他的

【面試】吃透了這些Redis知識點，面試官一定覺得你很NB（乾貨 | 建議珍藏）

【面試】如果你這樣回答“什麼是線程安全”，面試官都會對你刮目相看（建議珍藏）

【面試】迄今為止把同步/異步/阻塞/非阻塞/BIO/NIO/AIO講的這麼清楚的好文章（快快珍藏）

【面試】一篇文章幫你徹底搞清楚“I/O多路復用”和“異步I/O”的前世今生（深度好文，建議珍藏）

【面試】如果把線程當作一個人來對待，所有問題都瞬間明白了

Java多線程通關———基礎知識挑戰

品Spring：帝國的基石

 

 

 

作者是工作超過10年的碼農，現在任架構師。喜歡研究技術，崇尚簡單快樂。追求以通俗易懂的語言解說技術，希望所有的讀者都能看懂並記住。下面是公眾號的二維碼，歡迎關注！

 

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

【其他文章推薦】

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

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

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

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

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

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

※回頭車貨運收費標準

目錄

• 前言
• 實現思路
• 實現方法
  • 最簡單的實現方法
  • 如果多線程亂入？
  • 線程安全的單例模式
    • Lock版本
    • 靜態構造器版本
    • Lazy版本
• 總結

前言

Singleton是二十三個設計模式中比較重要也比較經常使用的模式。但是這個模式雖然簡單，實現起來也會有一些小坑，讓我們一起來看看吧！

實現思路

首先我們看看這個設計模式的UML類圖。

很清晰的可以看到，有三點是需要我們在實現這個模式的時候注意的地方。

• 私有化的構造器
• 全局唯一的靜態實例
• 能夠返回全局唯一靜態實例的靜態方法

其中，私有化構造器是防止外部用戶創建新的實例而靜態方法用於返回全局唯一的靜態實例供用戶使用。原理清楚了，接下來我們看看一些典型的實現方式和其中的暗坑。

實現方法

最簡單的實現方法

最簡單的實現方法自然就是按照UML類圖直接寫一個類，我們看看代碼。

    class Program
    {
        static void Main(string[] args)
        {
        	var single1 = Singleton.Instance;
            var single2 = Singleton.Instance;
            Console.WriteLine(object.ReferenceEquals(single1, single2));
            Console.ReadLine();
        }
    }

    class Singleton
    {
        private static Singleton _Instance = null;
        private Singleton()
        {
            Console.WriteLine("Created");
        }

        public static Singleton Instance
        {
            get
            {
                if (_Instance == null)
                {
                    _Instance = new Singleton();
                }
                return _Instance;
            }
        }

        public void DumbMethod()
        {

        }
    }

這段代碼忠實的實現了UML類圖裡面的一切，查看輸出結果，

證實了Singleton確實起了作用，多次調用僅僅產生了一個實例，似乎這麼寫就可以實現這個模式了。但是，真的會那麼簡單嗎？

如果多線程亂入？

現在我們給剛剛的例子加點調料，假設多個對實例的調用，並不是簡單的，彬彬有禮的順序關係，二是以多線程的方式調用，那麼剛剛那種實現方法，還能從容應對嗎？讓我們試試。把Main函數裏面的調用改成這樣。

	static void Main(string[] args)
        {
            int TOTAL = 10000;
            Task[] tasks = new Task[TOTAL];
            for (int i = 0; i < TOTAL; i++)
            {
                tasks[i] = Task.Factory.StartNew(() =>
                {
                    Singleton.Instance.DumbMethod();
                });
            }
			Task.WaitAll(tasks);
            Console.ReadLine();
        }

通過Factory創造出1萬個Task，幾乎同時去請求這個單例，看看輸出。

咦，我們剛剛寫的Singleton模式失效了，這個類被創造了5次（這段代碼運行多次，這個数字不一定相同），一定是多線程搞的鬼，我們剛剛寫的代碼沒有辦法應對多線程，換句話說，是非線程安全的(thread-safe)，那有沒有辦法來攻克這個難關呢？

線程安全的單例模式

Lock版本

提到線程安全，很多同學第一反應就是用lock，不錯，lock是個可行的辦法，讓我們試試。添加一個引用類型的對象作為lock對象，修改代碼如下（什麼？你問我為什必須是引用類型的對象而不能是值類型的對象？因為lock的時候，如果對象是值類型，那麼lock僅僅鎖住了它的一個副本，另外一個線程可以暢通無阻的再次lock，這樣lock就失去了阻塞線程的意義）

	private static object _SyncObj = new object();
        public static Singleton Instance
        {
            get
            {
                lock (_SyncObj)
                {
                    if (_Instance == null)
                    {
                        _Instance = new Singleton();
                    }
                    return _Instance;
                }                
            }
        }

運行一下，輸出

只有一個實例創建，證明Lock起作用了，這個模式可行！不過有些不喜歡用Lock的同學可能要問，還有沒有其他辦法呢？答案是有的。

靜態構造器版本

回想一下，C#中的類靜態構造器，只會在這個類第一次被使用的時候調用一次，天然的線程安全，那我們試試不用Lock使用類靜態構造器？修改Singleton類如下：

    class Singleton
    {
        private static Singleton _Instance = null;
        private Singleton()
        {
            Console.WriteLine("Created");
        }

        static Singleton()
        {
            _Instance = new Singleton();
        }

        //private static object _SyncObj = new object();
        public static Singleton Instance
        {
            get { return _Instance; }
        }

        public void DumbMethod()
        {

        }
    }

去掉了Lock，添加了一個類靜態構造器，試一試。

完美！對於不喜歡用Lock（在這個例子中，實例只會創建一次但是之後的所有線程都要先排隊Lock再進入Critical code進行檢查，效率比較低下）的同學，類靜態構造器提供了一種很好的選擇。
不過俗話說，人心苦不足 ， 我們總是追求卓越。這個版本比Lock版本似乎更好一點，那還有沒有更好的版本呢？有的。

Lazy版本

從net 4.0開始，C#開始支持延遲初始化，通過Lazy關鍵字，我們可以聲明某個對象為僅僅當第一次使用的時候，再初始化，如果一直沒有調用，那就不初始化，省去了一部分不必要的開銷，提升了效率。如果你不熟悉Lazy或者想更多了解它，請參考。我們今天關注的重點在於，Lazy也是天生線程安全的，所以我們嘗試用它來實現Singleton模式？修改代碼如下：

    class Singleton
    {
        private static Lazy<Singleton> _Instance = new Lazy<Singleton>(() => new Singleton());
        private Singleton()
        {
            Console.WriteLine("Created");
        }

        public static Singleton Instance
        {
            get
            {
                return _Instance.Value;
            }
        }

        public void DumbMethod()
        {

        }
    }

輸出結果中可以看到，我們達到了想要的效果：

在上面的代碼中，私有變量_Instance現在是被聲明為延遲初始化，這樣不但天然實現了線程安全，同時在沒有調用Instance靜態方法的時候（也即沒有調用_Instance.Value），初始化不會發生，這樣就提高了效率。

總結

Singleton模式很常見，實現起來也很簡單，只是要小心線程安全。以上三種方法都可以實現線程安全的Singleton模式。如果net 版本在4.0之上，建議使用Lazy版本，畢竟對比Lock版本，Lazy版本可以免去實現手動Lock之苦，對比Static版本，又有延遲初始化的性能優勢，何樂而不為呢？

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

【其他文章推薦】

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

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

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

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

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

※回頭車貨運收費標準

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

系列文章

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

上篇文章完成了分類和標籤頁面相關的共6個接口，本篇繼續來寫博客增刪改查API的業務。

供前端查詢用的接口還剩下一個，這裏先補上。

友鏈列表

分析：返回標題和對應的鏈接即可，傳輸對象FriendLinkDto.cs。

//FriendLinkDto.cs
namespace Meowv.Blog.Application.Contracts.Blog
{
    public class FriendLinkDto
    {
        /// <summary>
        /// 標題
        /// </summary>
        public string Title { get; set; }

        /// <summary>
        /// 鏈接
        /// </summary>
        public string LinkUrl { get; set; }
    }
}

添加查詢友鏈列表接口和緩存接口。

//IBlogService.FriendLink.cs
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.ToolKits.Base;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Blog
{
    public partial interface IBlogService
    {
        /// <summary>
        /// 查詢友鏈列表
        /// </summary>
        /// <returns></returns>
        Task<ServiceResult<IEnumerable<FriendLinkDto>>> QueryFriendLinksAsync();
    }
}

//IBlogCacheService.FriendLink.cs
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.ToolKits.Base;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Caching.Blog
{
    public partial interface IBlogCacheService
    {
        /// <summary>
        /// 查詢友鏈列表
        /// </summary>
        /// <param name="factory"></param>
        /// <returns></returns>
        Task<ServiceResult<IEnumerable<FriendLinkDto>>> QueryFriendLinksAsync(Func<Task<ServiceResult<IEnumerable<FriendLinkDto>>>> factory);
    }
}

接下來，實現他們。

//BlogCacheService.FriendLink.cs
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.ToolKits.Base;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using static Meowv.Blog.Domain.Shared.MeowvBlogConsts;

namespace Meowv.Blog.Application.Caching.Blog.Impl
{
    public partial class BlogCacheService
    {
        private const string KEY_QueryFriendLinks = "Blog:FriendLink:QueryFriendLinks";

        /// <summary>
        /// 查詢友鏈列表
        /// </summary>
        /// <param name="factory"></param>
        /// <returns></returns>
        public async Task<ServiceResult<IEnumerable<FriendLinkDto>>> QueryFriendLinksAsync(Func<Task<ServiceResult<IEnumerable<FriendLinkDto>>>> factory)
        {
            return await Cache.GetOrAddAsync(KEY_QueryFriendLinks, factory, CacheStrategy.ONE_DAY);
        }
    }
}

//BlogService.FriendLink.cs
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.Domain.Blog;
using Meowv.Blog.ToolKits.Base;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Blog.Impl
{
    public partial class BlogService
    {
        /// <summary>
        /// 查詢友鏈列表
        /// </summary>
        /// <returns></returns>
        public async Task<ServiceResult<IEnumerable<FriendLinkDto>>> QueryFriendLinksAsync()
        {
            return await _blogCacheService.QueryFriendLinksAsync(async () =>
            {
                var result = new ServiceResult<IEnumerable<FriendLinkDto>>();

                var friendLinks = await _friendLinksRepository.GetListAsync();
                var list = ObjectMapper.Map<IEnumerable<FriendLink>, IEnumerable<FriendLinkDto>>(friendLinks);

                result.IsSuccess(list);
                return result;
            });
        }
    }
}

直接查詢所有的友鏈數據，這裏使用前面講到的AutoMapper處理對象映射，將IEnumerable<FriendLink>轉換為IEnumerable<FriendLinkDto>。

在MeowvBlogAutoMapperProfile.cs中添加一條配置：CreateMap<FriendLink, FriendLinkDto>();，在BlogController中添加API。

/// <summary>
/// 查詢友鏈列表
/// </summary>
/// <returns></returns>
[HttpGet]
[Route("friendlinks")]
public async Task<ServiceResult<IEnumerable<FriendLinkDto>>> QueryFriendLinksAsync()
{
    return await _blogService.QueryFriendLinksAsync();
}

編譯運行，打開查詢友鏈的API，此時沒數據，手動添加幾條數據進去再試試吧。

文章管理

後台文章管理包含：文章列表、新增、更新、刪除文章，接下來依次完成這些接口。

文章列表

這裏的文章列表和前台的文章列表差不多，就是多了一個Id，以供編輯和刪除使用，所以可以新建一個模型類QueryPostForAdminDto繼承QueryPostDto，添加PostBriefForAdminDto繼承PostBriefDto同時新增一個字段主鍵Id。

在QueryPostForAdminDto中隱藏基類成員Posts，使用新的接收類型：IEnumerable<PostBriefForAdminDto>。

//PostBriefForAdminDto.cs
namespace Meowv.Blog.Application.Contracts.Blog
{
    public class PostBriefForAdminDto : PostBriefDto
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int Id { get; set; }
    }
}

//QueryPostForAdminDto.cs
using System.Collections.Generic;

namespace Meowv.Blog.Application.Contracts.Blog
{
    public class QueryPostForAdminDto : QueryPostDto
    {
        /// <summary>
        /// Posts
        /// </summary>
        public new IEnumerable<PostBriefForAdminDto> Posts { get; set; }
    }
}

添加分頁查詢文章列表的接口：QueryPostsForAdminAsync()，關於後台的一些接口就不添加緩存了。

//IBlogService.Admin.cs
using Meowv.Blog.Application.Contracts;
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.ToolKits.Base;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Blog
{
    public partial interface IBlogService
    {
        /// <summary>
        /// 分頁查詢文章列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        Task<ServiceResult<PagedList<QueryPostForAdminDto>>> QueryPostsForAdminAsync(PagingInput input);
    }
}

然後實現這個接口。

//BlogService.Admin.cs
using Meowv.Blog.Application.Contracts;
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.ToolKits.Base;
using Meowv.Blog.ToolKits.Extensions;
using System.Linq;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Blog.Impl
{
    public partial class BlogService
    {
        /// <summary>
        /// 分頁查詢文章列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<ServiceResult<PagedList<QueryPostForAdminDto>>> QueryPostsForAdminAsync(PagingInput input)
        {
            var result = new ServiceResult<PagedList<QueryPostForAdminDto>>();

            var count = await _postRepository.GetCountAsync();

            var list = _postRepository.OrderByDescending(x => x.CreationTime)
                                      .PageByIndex(input.Page, input.Limit)
                                      .Select(x => new PostBriefForAdminDto
                                      {
                                          Id = x.Id,
                                          Title = x.Title,
                                          Url = x.Url,
                                          Year = x.CreationTime.Year,
                                          CreationTime = x.CreationTime.TryToDateTime()
                                      })
                                      .GroupBy(x => x.Year)
                                      .Select(x => new QueryPostForAdminDto
                                      {
                                          Year = x.Key,
                                          Posts = x.ToList()
                                      }).ToList();

            result.IsSuccess(new PagedList<QueryPostForAdminDto>(count.TryToInt(), list));
            return result;
        }
    }
}

實現邏輯也非常簡單和之前一樣，就是在Select的時候多了一個Id，添加一個新的Controller：BlogController.Admin.cs，添加這個接口。

//BlogController.Admin.cs
using Meowv.Blog.Application.Contracts;
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.ToolKits.Base;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using static Meowv.Blog.Domain.Shared.MeowvBlogConsts;

namespace Meowv.Blog.HttpApi.Controllers
{
    public partial class BlogController
    {
        /// <summary>
        /// 分頁查詢文章列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet]
        [Authorize]
        [Route("admin/posts")]
        [ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
        public async Task<ServiceResult<PagedList<QueryPostForAdminDto>>> QueryPostsForAdminAsync([FromQuery] PagingInput input)
        {
            return await _blogService.QueryPostsForAdminAsync(input);
        }
    }
}

因為是後台的接口，所以加上AuthorizeAttribute，指定接口組為GroupName_v2，參數方式為[FromQuery]。

當沒有進行授權的時候，是無法訪問接口的。

新增文章

在做新增文章的時候要注意幾點，不是單純的添加文章數據就結束了，要指定文章分類，添加文章的標籤。添加標籤我這裡是從標籤庫中去取得數據，只存標籤Id，所以添加標籤的時候就可能存在添加了標籤庫中已有的標籤。

新建一個新增和更新文章的通用輸出參數模型類，起名：EditPostInput，繼承PostDto，然後添加標籤Tags字段，返回類型IEnumerable<string>。

//EditPostInput.cs
using System.Collections.Generic;

namespace Meowv.Blog.Application.Contracts.Blog.Params
{
    public class EditPostInput : PostDto
    {
        /// <summary>
        /// 標籤列表
        /// </summary>
        public IEnumerable<string> Tags { get; set; }
    }
}

添加新增文章的接口：InsertPostAsync。

/// <summary>
/// 新增文章
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> InsertPostAsync(EditPostInput input);

然後去實現這個接口，實現之前，配置AutoMapper實體映射。

CreateMap<EditPostInput, Post>().ForMember(x => x.Id, opt => opt.Ignore());

將EditPostInput轉換為Post，並且忽略Id字段。

/// <summary>
/// 新增文章
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<ServiceResult> InsertPostAsync(EditPostInput input)
{
    var result = new ServiceResult();

    var post = ObjectMapper.Map<EditPostInput, Post>(input);
    post.Url = $"{post.CreationTime.ToString(" yyyy MM dd ").Replace(" ", "/")}{post.Url}/";
    await _postRepository.InsertAsync(post);

    var tags = await _tagRepository.GetListAsync();

    var newTags = input.Tags
                       .Where(item => !tags.Any(x => x.TagName.Equals(item)))
                       .Select(item => new Tag
                       {
                           TagName = item,
                           DisplayName = item
                       });
    await _tagRepository.BulkInsertAsync(newTags);

    var postTags = input.Tags.Select(item => new PostTag
    {
        PostId = post.Id,
        TagId = _tagRepository.FirstOrDefault(x => x.TagName == item).Id
    });
    await _postTagRepository.BulkInsertAsync(postTags);

    result.IsSuccess(ResponseText.INSERT_SUCCESS);
    return result;
}

URL字段，根據創建時間按照yyyy/MM/dd/name/格式拼接。

然後找出是否有新標籤，有的話批量添加至標籤表。

再根據input.Tags構建PostTag列表，也進行批量保存，這樣才算是新增好一篇文章，最後輸出ResponseText.INSERT_SUCCESS常量，提示成功。

在BlogController.Admin.cs添加API。

/// <summary>
/// 新增文章
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
[Route("post")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> InsertPostAsync([FromBody] EditPostInput input)
{
    return await _blogService.InsertPostAsync(input);
}

更新文章

更新操作和新增操作輸入參數一樣，只新增一個Id用來標識更新那篇文章，添加UpdatePostAsync更新文章接口。

/// <summary>
/// 更新文章
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> UpdatePostAsync(int id, EditPostInput input);

同樣的實現這個接口。

/// <summary>
/// 更新文章
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
public async Task<ServiceResult> UpdatePostAsync(int id, EditPostInput input)
{
    var result = new ServiceResult();

    var post = await _postRepository.GetAsync(id);
    post.Title = input.Title;
    post.Author = input.Author;
    post.Url = $"{input.CreationTime.ToString(" yyyy MM dd ").Replace(" ", "/")}{input.Url}/";
    post.Html = input.Html;
    post.Markdown = input.Markdown;
    post.CreationTime = input.CreationTime;
    post.CategoryId = input.CategoryId;

    await _postRepository.UpdateAsync(post);

    var tags = await _tagRepository.GetListAsync();

    var oldPostTags = from post_tags in await _postTagRepository.GetListAsync()
                      join tag in await _tagRepository.GetListAsync()
                      on post_tags.TagId equals tag.Id
                      where post_tags.PostId.Equals(post.Id)
                      select new
                      {
                          post_tags.Id,
                          tag.TagName
                      };

    var removedIds = oldPostTags.Where(item => !input.Tags.Any(x => x == item.TagName) &&
                                               tags.Any(t => t.TagName == item.TagName))
                                .Select(item => item.Id);
    await _postTagRepository.DeleteAsync(x => removedIds.Contains(x.Id));

    var newTags = input.Tags
                       .Where(item => !tags.Any(x => x.TagName == item))
                       .Select(item => new Tag
                       {
                           TagName = item,
                           DisplayName = item
                       });
    await _tagRepository.BulkInsertAsync(newTags);

    var postTags = input.Tags
                        .Where(item => !oldPostTags.Any(x => x.TagName == item))
                        .Select(item => new PostTag
                        {
                            PostId = id,
                            TagId = _tagRepository.FirstOrDefault(x => x.TagName == item).Id
                        });
    await _postTagRepository.BulkInsertAsync(postTags);

    result.IsSuccess(ResponseText.UPDATE_SUCCESS);
    return result;
}

ResponseText.UPDATE_SUCCESS是常量更新成功。

先根據Id查詢到數據庫中的這篇文章數據，然後根據input參數，修改需要修改的數據，最後保存。

注意的是，如果修改的時候修改了標籤，有可能新增也有可能刪除，也許會又有新增又有刪除。

這時候就需要注意，這裏做了一個比較通用的方法，找到數據庫中當前文章Id的所有Tags，然後根據參數input.Tags可以找出被刪掉的標籤的PostTags的Id，調用刪除方法刪掉即可，同時也可以獲取到新增的標籤，批量進行保存。

完成上面操作后，才保存新加標籤與文章對應的數據，最後提示更新成功，在BlogController.Admin添加API。

/// <summary>
/// 更新文章
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
[HttpPut]
[Authorize]
[Route("post")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> UpdatePostAsync([Required] int id, [FromBody] EditPostInput input)
{
    return await _blogService.UpdatePostAsync(id, input);
}

[HttpPut]指定請求方式為put請求，一般需要修改用put，添加用post。

[Required]指定參數id必填且是FromQuery的方式，input為[FromBody]。

更新一下上面新增的數據試試。

刪除文章

刪除相對來說就非常簡單了，一般刪除都會做邏輯刪除，就是避免某些手殘刪除了，有找回的餘地，我們這裏就直接Delete了，也沒什麼重要數據。

添加接口：DeletePostAsync。

/// <summary>
/// 刪除文章
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<ServiceResult> DeletePostAsync(int id);

實現接口。

/// <summary>
/// 刪除文章
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task<ServiceResult> DeletePostAsync(int id)
{
    var result = new ServiceResult();

    var post = await _postRepository.GetAsync(id);
    if (null == post)
    {
        result.IsFailed(ResponseText.WHAT_NOT_EXIST.FormatWith("Id", id));
        return result;
    }

    await _postRepository.DeleteAsync(id);
    await _postTagRepository.DeleteAsync(x => x.PostId == id);

    result.IsSuccess(ResponseText.DELETE_SUCCESS);
    return result;
}

刪除的時候同樣去查詢一下數據，來判斷是否存在。

ResponseText.DELETE_SUCCESS是添加的常量刪除成功，刪除成功同時也要將post_tags表的標籤對應關係也幹掉才算完整，在BlogController.Admin添加API。

/// <summary>
/// 刪除文章
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete]
[Authorize]
[Route("post")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> DeletePostAsync([Required] int id)
{
    return await _blogService.DeletePostAsync(id);
}

[HttpDelete]指定請求方式是刪除資源，[Required]指定參數Id必填。

刪掉上面添加的文章看看效果。

至此，完成了博客文章的增刪改接口，未完待續…

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

搭配下方課程學習更佳 ↓ ↓ ↓

http://gk.link/a/10iQ7

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

【其他文章推薦】

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

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

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

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

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

※回頭車貨運收費標準

※台中搬家公司費用怎麼算?

在 YouTube 的知名虐機頻道 JerryRigEverything 上個月才回顧完 2020 年智慧型手機耐用獎，而 2021 年目前為止已發表的旗艦新機中，不久前才在中國以外市場進行全球發表的小米11 ，這次也不意外在 JerryRigEverything 進行一連串的虐機耐用性測試，未來小米11 也有機會在不久後引進台灣市場販售，對於未來有意入手的消費者不妨能將這次測試作為購買前的參考依據。

小米11 虐機耐用性測試，究竟能通過一連串嚴苛考驗嗎？

小米於 2020 年底在中國發表首款搭載高通 Snapdragon 888 旗艦手機小米11 ，也很快在本月 8 日「小米11 全球線上發佈會」正式在國際市場推出，後續也將在台灣登場。
在國際市場發表後， YouTube 以嚴苛耐用性測試著名的 JerryRigEverything 日前也釋出了小米11 虐機耐用性測試影片，其中小米11 螢幕升級為 6.81 吋 WQHD+ 解析度、120Hz TrueColor AMOLED 四曲面螢幕，加上螢幕玻璃則採用康寧最新大猩猩玻璃 Gorilla Glass Victus 保護，官方抗摔性相較前代提升 1.5倍、耐刮性能提升 2 倍，至於在實測下來如何呢？就讓 JerryRigEverything 帶著大家看下去吧！

小米11 不僅盒裝標配軟質的手機保護套，出廠時也預先貼上螢幕保護貼，讓小米11 用戶能省下一筆保護貼的開銷，也同時為手機能有螢幕有基礎保護。不過既然要測試耐用性，還是得將原廠的保護貼給卸下：

按照慣例在手機螢幕上貼上寫著數字的標籤，接著莫氏硬度標準進行測試：

小米11 的螢幕玻璃採用康寧大猩猩玻璃 Victus ，不過實測下來與之前像是採用超瓷晶盾面板的 iPhone 12 系列，或其他數十款智慧型手機沒有太大差別，耐刮程度仍為第 6 級開始出現刮痕，接著在第 7 級開始會出現更深的刮痕：

小米11 在邊框則採用電鍍工藝的 7000系鋁合金邊框，不過在銳利的刀片的刮過還是留下明顯痕跡：

至於機身背面，小米11 之前在中國版推出時分為 AG工藝的玻璃材質或皮質質感的聚碳酸酯塑料材質，不過先前在小米11 國際版僅有玻璃材質可選擇。不過機身背面的玻璃在美工刀這類物品劃過並未留下刮痕：

主相機鏡頭部份也順利通過考驗：

後來也針對小米11 進行了耐火測試，但小米11 並未像是之前採用超瓷晶盾面板的 iPhone 12 系列那般令人意外強大，最終在打火機燃燒後還是留下因熱量讓顯示面板的像素損壞的痕跡：

最後，也針對小米11 進行彎曲測試，所幸還是輕易地通過考驗沒有被扳彎。

完整測試影片

 

圖片/消息來源： JerryRigEverything（YouTube）

延伸閱讀：
小米11 國際版正式發表：盒裝標配 55W GaN 氮化鎵充電器、售價約 25,150 元

小米11 骨牌挑戰影片！以 4100支成功完成挑戰

您也許會喜歡：

【推爆】終身$0月租 打電話只要1元/分

立達合法徵信社-讓您安心的選擇

【其他文章推薦】

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

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

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

※超省錢租車方案

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

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

※回頭車貨運收費標準

在本月 25 日 Redmi K40 系列才要發表，也外傳小米接下來在不久後也會發表多款小米11 系列新機，其中也包括最大尺寸、規格最旗艦的小米11 Ultra 。稍早，在 YouTube 頻道 Tech Buff PH 聲稱取得兩款尚未發表的「小米11 Ultra」手機，也讓小米11 Ultra 就這樣突如其來其然的被提前曝光！

小米11 Ultra 實機動手玩影片流出！配備 120x 變焦相機和副螢幕

日前小米才剛在「小米11 全球線上發佈會」正式在國際市場率先在歐洲推出小米11 標準版後，也傳聞小米11 系列有望推出多款新機，包括小米11 Lite 、小米11 Pro 和小米11 Ultra 。稍早有名菲律賓 YouTuber Tech Buff PH 豪不客氣地直接搶先洩密聲稱取得分別為白色和黑色的兩款小米11 Ultra 實機，儘管無法完全確認這次洩漏的真實性，不過各方面透露的資訊可信度確實相當高。

在機身背面顯示的型號為 M2102K1G ，與最近通過印度 BIS 和歐盟 EEC 認證的小米裝置相吻合。

根據 Tech Buff PH 的描述，小米11 Ultra 硬體規格方面除了支持高螢幕更新率螢幕、搭載 Qualacomm Snapdragon 888 旗艦行動平台，內建 5000mAh 大容量電池快速充電支持小米三重快充技術，分別為 67W 有線快充、67W 無線快充以及 10W 無線反向充電。

螢幕方面，小米11 Ultra 同樣配備 6.81 吋 WQHD+ 解析度、120Hz 更新率的 TrueColor AMOLED 四曲面螢幕，螢幕採用孔洞式設計並配備 2000 萬像素前置自拍相機，螢幕表面也比照小米11 覆蓋康寧最新 Gorilla Glass Victus 大猩猩玻璃保護。

另外，從影片多角度也顯示這款手機預載 MIUI 12.5 Global 版本，或許這次也不像是去年小米10 Ultra（小米10 至尊紀念版）僅限於中國市場販售，終於要將小米旗艦系列最高規的機種推向國際市場。

至於相機也是小米11 Ultra 最具辨識度的設計重點，畢竟在機身背面橫向排列著如此龐大具有凸起的相機模組，內部容納了三鏡頭主相機和一個小型的副螢幕：

根據他的說明，小米11 Ultra 主相機配備 5000 萬像素主鏡頭、 4800 萬像素超廣角鏡頭和 4800 萬像素潛望式望遠變焦鏡頭所組成，在相機上文字顯示「120X Ultra Pixel AI Camera」可得知小米11 Ultra 相機擁有著 120X 變焦、 12-120mm 等效焦距，不過目前尚無法得知光學變焦的倍率為何。

小米11 Ultra 機身背面主相機位置除了擁有碩大的鏡頭，另一側則搭載微型的副螢幕設計，即便目前無法得知該顯示器的規格、尺寸尺寸看似也不大，但實用性或許比大家想像中來得高呀！因為這塊小型的副螢幕並非只能顯示新訊息、未接來電這種通知類的內容，
，從 Tech Buff PH 的動手玩影片我們能看到他可以顯示小米11 Ultra 主螢幕的完整畫面，甚至是開啟瀏覽器或各種應用程式都沒問題。

當然，這塊副螢幕最主要的目的並非是用來觀看手機螢幕的整個畫面，主要的用途還是用於輔助用戶進行自拍照片或影片。筆者認為，小米11 Ultra 之所以能顯示整個主螢幕的原因在於，許多用戶在自拍時並不會使用系統內建的相機 App ，而是使用這種自己慣用的美顏 App ，那麼這樣的設計就顯得相當貼心了。

小米11 Ultra 採用四曲面機身設計，機身中框比照去年小米10 Ultra 的模式改為不鏽鋼材質，也毫無意外配備 Harman Kardon 專業調音的雙立體揚聲器系統，小米11 Ultra 提供影院級音效體驗。其他方面，小米11 Ultra 當然也支持 IP68 防水等級。

最後，即便現階段無法證實 Tech Buff PH 影片洩漏的小米11 Ultra 外觀以及透露的規格配置是否屬為真，以及小米11 Ultra 何時才會發表，不過根據先前微博的爆料指出小米11 Ultra 預計會在 Redmi K40 之後，最快在 3 月份就會正式發表。

完整影片（備份）

目前 Tech Buff PH 已將原影片瀏覽權限改為私人，不過目前已經有人將影片備份上傳（如影片下架請見諒）。

 

圖片/消息來源： TECH BUFF PH（YouTube）

延伸閱讀：
小米11 虐機耐用性測試，究竟能通過一連串嚴苛考驗嗎？

小米11 骨牌挑戰影片！以 4100支成功完成挑戰

您也許會喜歡：

【推爆】終身$0月租 打電話只要1元/分

立達合法徵信社-讓您安心的選擇

【其他文章推薦】

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

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

※超省錢租車方案

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

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

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

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!