標籤: 網頁設計公司

Spring Boot 概述

Build Anything with Spring Boot：Spring Boot is the starting point for building all Spring-based applications. Spring Boot is designed to get you up and running as quickly as possible, with minimal upfront configuration of Spring.

上面是引自官網的一段話，大概是說： Spring Boot 是所有基於 Spring 開發的項目的起點。Spring Boot 的設計是為了讓你盡可能快的跑起來 Spring 應用程序並且盡可能減少你的配置文件。

什麼是 Spring Boot

• 它使用 “習慣優於配置” （項目中存在大量的配置，此外還內置一個習慣性的配置，讓你無須手動配置）的理念讓你的項目快速運行起來。
• 它並不是什麼新的框架，而是默認配置了很多框架的使用方式，就像 Maven 整合了所有的 jar 包一樣，Spring Boot 整合了所有框架

使用 Spring Boot 有什麼好處

回顧我們之前的 SSM 項目，搭建過程還是比較繁瑣的，需要：

• 1）配置 web.xml，加載 spring 和 spring mvc
• 2）配置數據庫連接、配置日誌文件
• 3）配置家在配置文件的讀取，開啟註解
• 4）配置mapper文件
• …..

而使用 Spring Boot 來開發項目則只需要非常少的幾個配置就可以搭建起來一個 Web 項目，並且利用 IDEA 可以自動生成生成

• 划重點：簡單、快速、方便地搭建項目；對主流開發框架的無配置集成；極大提高了開發、部署效率。

Spring Boot HelloWorld

導入依賴spring boot相關的依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.chenhao</groupId>
    <artifactId>springboot</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

編寫主程序

/**
 * @SpringBootApplication來標註一個主程序類，說明這是一個SpringBoot應用
 */ @SpringBootApplication public class HelloWorldMainApplication {

    public static void main(String[] args) {
        //Spring應用啟動
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

編寫Controller、Service

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return "Hello world";
    }
}

運行主程序測試

使用maven打包命令將其打包成jar包后，直接使用命令：

java -jar xxx.jar

Hello World探究

POM文件

父項目

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/>
</parent>

其父項目是

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

該父項目是真正管理Spring Boot應用裏面的所有依賴的版本：Spring Boot的版本仲裁中心，所以以後導入的依賴默認是不需要版本號。如下

還有很多版本號沒有截圖出來

啟動器

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

​ spring-boot-starter : spring boot場景啟動器；幫助導入web模塊正常運行所依賴的組件；

​ Spring Boot將所有的功能場景抽取出來，做成一個個的starter(啟動器)，只需要在項目中引入這些starter，那麼相關的場景的所有依賴都會導入進項目中。要用什麼功能就導入什麼場景的啟動器。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
</dependency>

添加了 spring-boot-starter-web 依賴，會自動添加 Tomcat 和 Spring MVC 的依賴

spring-boot-starter-web中又引入了spring-boot-starter-tomcat

主程序類（主入口類）

@SpringBootApplication public class HelloWorldMainApplication {

    public static void main(String[] args) {
        //Spring應用啟動
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

@SpringBootApplication

• Spring Boot應用標註在某個類上，說明這個類是SpringBoot的主配置類，SpringBoot就應該運行這個類的main方法來啟動SpringBoot應用。

註解定義如下：

@SpringBootConfiguration @EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {}

@SpringBootConfiguration

• Spring Boot的配置類
• 標註在某個類上，表示這是一個Spring Boot的配置類

註解定義如下：

@Configuration public @interface SpringBootConfiguration {}

其實就是一個Configuration配置類，意思是HelloWorldMainApplication最終會被註冊到Spring容器中

@EnableAutoConfiguration

• 開啟自動配置功能
• 以前使用Spring需要配置的信息，Spring Boot幫助自動配置；
• @EnableAutoConfiguration通知SpringBoot開啟自動配置功能，這樣自動配置才能生效。

註解定義如下：

@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class) public @interface EnableAutoConfiguration {}

@AutoConfigurationPackage

• 自動配置包註解

@Import(AutoConfigurationPackages.Registrar.class) public @interface AutoConfigurationPackage {}

@Import(AutoConfigurationPackages.Registrar.class)：默認將主配置類(
@SpringBootApplication)所在的包及其子包裏面的所有組件掃描到Spring容器中。如下

@Order(Ordered.HIGHEST_PRECEDENCE)
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
          //默認將會掃描@SpringBootApplication標註的主配置類所在的包及其子包下所有組件
        register(registry, new PackageImport(metadata).getPackageName());
    }

    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.<Object>singleton(new PackageImport(metadata));
    }
}

@Import(EnableAutoConfigurationImportSelector.class)

EnableAutoConfigurationImportSelector： 導入哪些組件的選擇器，將所有需要導入的組件以全類名的方式返回，這些組件就會被添加到容器中。

 1 //EnableAutoConfigurationImportSelector的父類：AutoConfigurationImportSelector
 2 @Override
 3 public String[] selectImports(AnnotationMetadata annotationMetadata) {
 4     if (!isEnabled(annotationMetadata)) {
 5         return NO_IMPORTS;
 6     }
 7     try {
 8         AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
 9             .loadMetadata(this.beanClassLoader);
10         AnnotationAttributes attributes = getAttributes(annotationMetadata);
11         List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); 12         configurations = removeDuplicates(configurations);
13         configurations = sort(configurations, autoConfigurationMetadata);
14         Set<String> exclusions = getExclusions(annotationMetadata, attributes);
15         checkExcludedClasses(configurations, exclusions);
16         configurations.removeAll(exclusions);
17         configurations = filter(configurations, autoConfigurationMetadata);
18         fireAutoConfigurationImportEvents(configurations, exclusions);
19         return configurations.toArray(new String[configurations.size()]);
20     }
21     catch (IOException ex) {
22         throw new IllegalStateException(ex);
23     }
24 }

我們主要看第11行List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);會給容器中注入眾多的自動配置類（xxxAutoConfiguration），就是給容器中導入這個場景需要的所有組件，並配置好這些組件。我們跟進去看看

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    //...
    return configurations;
}

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    try {
        //從類路徑的META-INF/spring.factories中加載所有默認的自動配置類
        Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                                 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        List<String> result = new ArrayList<String>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            //獲取EnableAutoConfiguration指定的所有值,也就是EnableAutoConfiguration.class的值
            String factoryClassNames = properties.getProperty(factoryClassName);
            result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
        }
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

SpringBoot啟動的時候從類路徑下的
META-INF/spring.factories中獲取EnableAutoConfiguration指定的值，並將這些值作為自動配置類導入到容器中，自動配置類就會生效，最後完成自動配置工作。EnableAutoConfiguration默認在spring-boot-autoconfigure這個包中，如下圖

最終有96個自動配置類被加載並註冊進Spring容器中

J2EE的整體整合解決方案和自動配置都在spring-boot-autoconfigure-xxx.jar中。在這些自動配置類中會通過@ConditionalOnClass等條件註解判斷是否導入了某些依賴包，從而通過@Bean註冊相應的對象進行自動配置。後面我們會有單獨文章講自動配置的內容

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

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

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

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

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

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

目的

本文主要介紹的內容有以下三點：
一. Elastic Stack是什麼以及組成部分
二. Elastic Stack前景以及業務應用
三. Elasticsearch原理（索引方向）
四. Elasticsearch相對薄弱的地方

一、Elastic Stack是什麼以及組成部分

介紹Elastic Stack是什麼，其實只要一句話就可以，就是: 一套完整的大數據處理堆棧，從攝入、轉換到存儲分析、可視化。

它是不同產品的集合，各司其職，形成完整的數據處理鏈，因此Elastic Stack也可以簡稱為BLEK。

Beats 輕量型數據採集器

Logstash 輸入、過濾器和輸出

Elasticsearch 查詢和分析

Kibana 可視化，可自由選擇如何呈現數據

1. Beats – 全品類採集器，搞定所有數據類型

Filebeat（日誌文件）：對成百上千、甚至上萬的服務器生成的日誌匯總，可搜索。

Metricbeat（指標）: 收集系統和服務指標，CPU 使用率、內存、文件系統、磁盤 IO 和網絡 IO 統計數據。

Packetbeat（網絡數據）：網絡數據包分析器，了解應用程序動態。

Heartbeat（運行時間監控）：通過主動探測來監測服務的可用性
……
Beats支持許許多多的beat，這裏列的都是比較的常用的beat，了解更多可以點擊鏈接：

2. Logstash – 服務器端數據處理管道

介紹Logstash之前，我們先來看下Linux下常用的幾個命令

cat alldata.txt | awk ‘{print $1}’ | sort | uniq | tee filterdata.txt

只要接觸過Linux同學，應該都知道這幾個命名意思

cat alldata.txt #將alldata.txt的內容輸出到標準設備上
awk ‘{print $1}’ #對上面的內容做截取，只取每一行第一列數據
sort | uniq  #對截取后的內容，進行排序和唯一性操作
tee filterdata.txt #將上面的內容寫到filterdata.txt

上面的幾個簡單的命令就可以看出來，這是對數據進行了常規的處理，用名詞修飾的話就是：數據獲取/輸入、數據清洗、數據過濾、數據寫入/輸出

而Logstash做的也是相同的事（看下圖）。

將系統的日誌文件、應用日誌文件、系統指標等數據，輸入到Input，再通過數據清洗以及過濾，輸入到存儲設備中，這裏當然是輸入到Elasticsearch

3. Elasticsearch – 分佈式文檔存儲、RESTful風格的搜索和數據分析引擎

Elasticsearch主要也是最原始的功能就是搜索和分析功能。這裏就簡單說一下，下面講原理的時候會着重講到Elasticsearch

搜索：全文搜索，完整的信息源轉化為計算機可以識別、處理的信息單元形成的數據集合 。

分析：相關度，搜索所有內容，找到所需的具體信息（詞頻或熱度等對結果排序）

4. Kibana- 可視化

可視化看下圖（來源官網）便知

可以對日誌分析、業務分析等做可視化

現在從總體上來了解下，在心中對Elastic Stack有個清楚的認知（下圖）。

二、Elastic Stack前景以及業務應用

1. DB-Engines 排名

Elasticsearch是Elastic Stack核心，由圖可以看出在搜索領域Elasticsearch暫時沒有對手。

2. ES社區

ES中文社區也是相當活躍的，會定期做一下分享，都是大公司的寶貴經驗，值得參考。

3. 2018年攜程的使用情況（讓我們看看能處理多大的數據）

集群數量是94個，最小的集群一般是3個節點。全部節點數量大概700+。

最大的一個集群是做日誌分析的，其中數據節點330個，最高峰一天產生1600億文檔，寫入值300w/s。

現在有2.5萬億文檔，大概是幾個PB的量

三、Elasticsearch（ES）原理

因為篇目有限，本篇只介紹ES的索引原理。

ES為什麼可以做全文搜索，主要就是用了倒排索引，先來看下面的一張圖

看圖可以簡單的理解倒排索引就是：關鍵字 + 頁碼

對倒排索引有個基本的認識后，下面來做個簡單的數據例子。

現在對Name做到排索引，記住：關鍵字 + ID（頁碼）。

對Age做到排索引。

對Intersets做到排索引。

現在搜索Age等於18的，通過倒排索引就可以快速得到1和3的id，再通過id就可以得到具體數據，看，這樣是不是快的狠。

如果是用Mysql等關係數據庫，現在有十多億數據（大數據嘛）,就要一條一條的掃描下去找id，效率可想而知。而用倒排索引，找到所有的id就輕輕鬆鬆了。

在ES中，關鍵詞叫Term，頁碼叫Posting List。

但這樣就行了嗎？ 如果Name有上億個Term，要找最後一個Term，效率豈不是還是很低？

再來看Name的倒排索引，你會發現，將Armani放在了第一個，Tyloo放在了第三個，可以看出來，對Term做了簡單的排序。雖然簡單，但很實用。這樣查找Term就可以用二分查找法來查找了，將複雜度由n變成了logn。

在ES中，這叫Term Dictionary。

到這裏，再來想想MySQL的b+tree， 你有沒有發現原理是差不多的，那為什麼說ES搜索比MySQL快很多，究竟快在哪裡？ 接下來再看。

有一種數據結構叫Trie樹，又稱前綴樹或字典樹，是一種有序樹。這種數據結構的好處就是可以壓縮前綴和提高查詢數據。

現在有這麼一組Term： apps, apple, apply, appear, back, backup, base, bear，用Trie樹表示如下圖。

通過線路路徑字符連接就可以得到完成的Term，並且合用了前綴，比如apps, apple, apply, appear合用了app路徑，節省了大量空間。

這個時候再來找base單詞，立即就可以排除了a字符開頭的單詞，比Term Dictionary快了不知多少。

在ES中，這叫Term Index

現在我們再從整體看下ES的索引

先通過Trie樹快速定位block（相當於頁碼）, 再到Term Dictionary 做二分查找，得到Posting List。

索引優化

ES是為了大數據而生的，這意味着ES要處理大量的數據，它的Term數據量也是不可想象的。比如一篇文章，要做全文索引，就會對全篇的內容做分詞，會產生大量的Term，而ES查詢的時候，這些Term肯定要放在內存裏面的。

雖然Trie樹對前綴做了壓縮，但在大量Term面前還是不夠，會佔用大量的內存使用，於是就有ES對Trie樹進一步演化。

FST（Finite State Transducer ）確定無環有限狀態轉移器 （看下圖）

可以看appear、bear 對共同的後綴做了壓縮。

Posting List磁盤壓縮

假設有一億的用戶數據，現在對性別做搜索，而性別無非兩種，可能”男”就有五千萬之多，按int4個字節存儲，就要消耗50M左右的磁盤空間，而這僅僅是其中一個Term。

那麼面對成千上萬的Term，ES究竟是怎麼存儲的呢？接下來，就來看看ES的壓縮方法。

Frame Of Reference （FOR） 增量編碼壓縮，將大數變小數，按字節存儲

只要能把握“增量，大數變小數，按字節存儲”這幾個關鍵詞，這個算法就很好理解，現在來具體看看。

現在有一組Posting List：[60, 150, 300,310, 315, 340], 按正常的int型存儲，size = 6 * 4（24）個字節。

1. 按增量存儲：60 + 90（150）+ 150（300） + 10（310） + 5（315）+ 25（340），也就是[60, 90, 150, 10, 5, 25]，這樣就將大數變成了小數。

2. 切分成不同的block：[60, 90, 150]、[10, 5, 25]，為什麼要切分，下面講。

3. 按字節存儲：對於[60, 90, 150]這組block，究竟怎麼按字節存儲，其實很簡單，就是找其中最大的一個值，看X個比特能表示這個最大的數，那麼剩下的數也用X個比特表示（切分，可以盡可能的壓縮空間）。

[60, 90, 150]最大數150 < 2^8 = 256，也就是這組每個數都用8個比特表示，也就是 3*8 = 24個比特，再除以8，也就是3個字節存在，再加上一個8的標識位（說明每個數是8個比特存儲）,佔用一個字節，一共4個字節。

[10, 5, 25]最大數25 < 2^5 = 32，每個數用5個比特表示，3*5=15比特，除以8，大約2個字節，加上5的標識位，一共3個字節。

那麼總體size = 4 + 3（7）個字節，相當於24個字節，大大壓縮了空間。

再看下圖表示

Posting List內存壓縮

同學們應該都知道越複雜的算法消耗的CPU性能就越大，比如常見的https，第一次交互會用非對稱密碼來驗證，驗證通過後就轉變成了對稱密碼驗證，FOR同樣如此，那麼ES是用什麼算法壓縮內存中的Posting List呢？

Roaring Bitmaps 壓縮位圖索引

Roaring Bitmaps 涉及到兩種數據結構 short[] 、bitmap。

short好理解就是2個字節的整型。

bitmap就是用比特表示數據，看下面的例子。

Posting List：[1, 2, 4, 7, 10] -> [1, 1, 0, 1, 0, 0, 1,0, 0, 1]，取最大的值10，那麼就用10個比特表示這組Posting List，第1, 2, 4, 7, 10位存在，就將相對應的“位”置為1，其他的為0。

但這種bitmap數據結構有缺陷，看這組Posting List： [1, 3, 100000000] -> [1, 0, 1, 0, 0, 0, …, 0, 0, 1 ]，最大數是1億，就要1億的比特表示，這麼算下來，反而消耗了更多的內存。

那如何解決這個問題，其實也很簡單，跟上面一樣，將大數變成小數。

看下圖：

第一步：將每個數除以65536，得到（商，餘數）。

第二步：按照商，分成不同的block，也就是相同的商，放在同一個block裏面，餘數就是這個值在這個block裏面的位置（永遠不會超過65536，餘數嘛）。

第三步：判斷底層block用什麼數據結構存儲數據，如果block裏面的餘數的個數超過4096個，就用short存儲，反之bitmap。

上面那個圖是官網的圖，看下我畫的圖，可能更好理解些。

到這裏，ES的索引原理就講完了，希望大家都能理解。

四、Elasticsearch（ES）相對薄弱的地方

1. 多表關聯

其實ES有一個很重要的特性這裏沒有介紹到，也就是分佈式，每一個節點的數據和，才是整體數據。

這也導致了多表關聯問題，雖然ES裏面也提供了Nested& Join 方法解決這個問題，但這裏還是不建議用。

那這個問題在實際應用中應該如何解決？ 其實也很簡單，裝換思路，ES無法解決，就到其他層解決，比如：應用層，用面向對象的架構，拆分查詢。

2. 深度分頁

分佈式架構下，取數據便不是那麼簡單，比如取前1000條數據，如果是10個節點，那麼每個節點都要取1000條，10個節點就是10000條，排序后，返回前1000條，如果是深度分頁就會變的相當的慢。

ES提供的是Scroll + Scroll_after，但這個採取的是緩存的方式，取出10000條后，緩存在內存里，再來翻頁的時候，直接從緩存中取，這就代表着存在實時性問題。

來看看百度是怎麼解決這個問題的。

一樣在應用層解決，翻頁到一定的深度后，禁止翻頁。

3. 更新應用

頻繁更新的應用，用ES會有瓶頸，比如一些遊戲應用，要不斷的更新數據，用ES不是太適合，這個看大家自己的應用情況。

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

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

和諧富騰互聯網加智慧電動汽車公司（以下簡稱“和諧富騰”）日前宣佈旗下“互聯網+智慧電動汽車”企業負責人，畢福康博士（Dr. Carsten Breitfeld）將擔任該企業首席執行官，戴雷博士（Dr. Daniel Kirchert）將擔任首席運營官。兩位管理層到任後將即刻啟動企業的運營。畢福康博士和戴雷博士亦將是該企業的事業合夥人和公司董事會成員。

左：畢福康博士（Dr. Carsten Breitfeld）；右：戴雷博士（Dr. Daniel Kirchert）

和諧富騰是由中國和諧新能源汽車控股有限公司、鴻海集團與騰訊集團透過各自附屬實體聯合創立的創新投資平臺，“互聯網+智慧電動汽車”是該平臺旗下核心戰略專案和獨立企業，旨在開發面向未來的個人出行解決方案，塑造源自中國、佈局世界的高端品牌，為消費者提供智慧、愉悅、生態友好的駕乘體驗。

畢福康博士擁有機械工程學博士學位，是全球電動汽車研發領域的一流專家。畢福康博士此前在寶馬集團總部工作20年，擔任過底盤開發、傳動系統開發及產品戰略等方面的多個高級管理崗位，2010年起擔任寶馬集團新一代電動超級跑車i8項目總監，成為這一世界汽車行業劃時代旗艦車型的研發主腦。通過引入革命性的開發流程，畢福康博士帶領團隊實現了i8車型于2014年成功面世，在產品性能、材料、技術革新及研發速度等各個方面顯著優於傳統汽車產品，創下了全球汽車行業新的標杆。在畢福康博士的推動下，i8車型還引進了創新的銷售和客戶體驗機制。

戴雷博士是中國豪華汽車領域擁有最豐富銷售、運營和品牌塑造經驗的高層主管之一，也是業內公認的“中國通”。戴雷博士此前曾擔任東風英菲尼迪汽車有限公司總經理和華晨寶馬汽車有限公司行銷高級副總裁，相關品牌在其任內均創下豪華車市場的銷售增長紀錄，在品牌塑造和市場行銷方面也創造了若干標杆性的案例。戴雷博士在產品戰略、銷售網路發展和合資企業組建運營方面也擁有深厚的經驗。

畢福康博士和戴雷博士將在就任後與傳媒見面，並就“互聯網+智慧電動汽車”的戰略規劃和企業具體運營資訊與傳媒和公眾溝通。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

一、概述

　　HashMap，基於哈希結構的Map接口的一個實現，無序，允許null鍵值對，線程不安全的。可以使用集合工具類Collections中的synchronizedMap方法，去創建一個線程安全的集合map。

　　在jdk1.7中，HashMap主要是基於 數組+鏈表 的結構實現的。鏈表的存在主要是解決 hash 衝突而存在的。插入數據的時候，計算key的hash值，取得存儲的數組下標，如果衝突已有元素，則會在衝突地址上生成個鏈表，再通過key的比較，鏈表是否已存在，存在則覆蓋，不存在則鏈表上添加。這種方式，如果存在大量衝突的時候，會導致鏈表過長，那麼直接導致的就是犧牲了查詢和添加的效率。所以在jdk1.8版本之後，使用的就是 數組 + 鏈表 + 紅黑樹，當鏈表長度超過 8（實際加上初始的節點，整個有效長度是 9） 的時候，轉為紅黑樹存儲。

　　本文中內容，主要基於jdk1.7版本，單線程環境下使用的HahsMap沒有啥問題，但是當在多線程下使用的時候，則可能會出現併發異常，具體表象是CPU會直線上升100%。下面是主要介紹相關的存取以及為什麼會出現線程安全性問題。

二、結構

　　HashMap默認初始化size=16的哈希數組，然後通過計算待存儲的key的hash值，去計算得到哈希數組的下標值，然後放入鏈表中（新增節點或更新）。鏈表的存在即是解決hash衝突的。

三、源碼實現分析

　　1、存儲具體數據的table數組：

　　　　Entry為HashMap中的靜態內部類，其具體結構如下圖

　　　　key、value屬性就是存儲鍵值對的，next則是指向鏈表的下一個元素節點。

     2、 默認初始化方法：

　　  默認構造方法，不對table進行初始化new（真正初始化動作放在put中，後面會看到），只是設置參數的默認值，hashmap長度和table長度初始化成DEFAULT_INITIAL_CAPACITY（16），加載因子loadFactor默認DEFAULT_LOAD_FACTOR（0.75f，至於為什麼是0.75，這個可以參見 ）。

　　  加載因子：默認情況下，16*0.75=12，也就是在存儲第13個元素的時候，就會進行擴容（jdk1.7的threshold真正計算放在第一次初始化中，後面會再提及）。此元素的設置，直接影響到的是key的hash衝突問題。

　　3、put方法

 public V put(K key, V value) {
　　　   if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

　　3.1、EMPTY_TABLE是HashMap中的一個靜態的空的Entry數組，table也是HashMap的一個屬性，默認就是EMPTY_TABLE（這兩句可參見上面源碼），table就是我們真正數據存儲使用的。
　　3.2、前面提及，無參構造的時候，並未真正完成對HashMap的初始化new操作，而僅僅只是設置幾個常量，所以在第一次put數據的時候，table是空的。則會進入下面的初始化table方法中。

if (table == EMPTY_TABLE) {
    inflateTable(threshold);
}

private void inflateTable(int toSize) {
    // Find a power of 2 >= toSize
    int capacity = roundUpToPowerOf2(toSize);

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); //計算加載因子，默認情況下結果為12
    table = new Entry[capacity];  //真正的初始化table數組
    initHashSeedAsNeeded(capacity);
}

　　3.3、key的null判斷

if (key == null)
    return putForNullKey(value);

private V putForNullKey(V value) {
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(0, null, value, 0);
    return null;
}

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

　　具體步驟解析：

　　　　1、key為null，取出table[0]的鏈表結構Enrty，如果取出的元素不為null，則對其進行循環遍歷，查找其中是否存在key為null的節點元素。

　　  　  2、如果存在key == null的節點，則使用新的value去更新節點的oldValue，並且將oldValue返回。

　　　　3、如果不存在key == null的元素，則執行新增元素addEntry方法：

　　　　　　（1）判斷是否需要擴容，size為當前數組table中，已存放的Entry鏈表個數，更直接點說，就是map.size()方法的返回值。threshold上面的真正初始化HashMap的時候已經提到，默認情況下，計算得到 threshold=12。若同時滿足　 (size >= threshold) && (null != table[bucketIndex]) ，則對map進行2倍的擴容，然後對key進行重新計算hash值和新的數組下標。

　　　　　　（2）創建新的節點原色createEntry方法，首先獲取table數組中下標為bucketIndex的鏈表的表頭元素，然後新建個Entry作為新的表頭，並且新表頭其中的next指向老的表頭數據。

　　3.4、key不為null的存儲　　
　　　　原理以及過程上通key==null的大體相同，只不過，key==null的時候，固定是獲取table[0]的鏈表進行操作，而在不為key ！= null的時候，下標位置是通過
  int hash = hash(key); int i = indexFor(hash, table.length); 計算得到的

  static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

　　很清晰的就能看明白，先計算key的hash，然後與當前table的長度進行相與，這樣計算得到待存放數據的下標。得到下標后，過程就與key==null一致了，遍歷是否存在，存在則更新並返回oldVlaue，不存在則新建Entry。

　　4、get方法

 public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

    如果key == null，則調用getForNullKey方法，遍歷table[0]處的鏈表。

private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

　　如果key ！= null，則調用getEntry，根據key計算得到在table數組中的下標，獲取鏈表Entry，然後遍歷查找元素，key相等，則返回該節點元素。

 final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

四、線程不安全分析

　　上述，主要淺析了下HashMap的存取過程，HashMap的線程安全性問題主要也就是在上述的擴容resize方法上，下面來看看在高併發下，擴容后，是如何引起100%問題的。

　　1、在進行新元素 put 的時候，這在上面中的3.3的代碼片段中可以查看，addEntry 添加新節點的時候，會計算是否需要擴容處理：(size >= threshold) && (null != table[bucketIndex]) 。

　　2、如果擴容的話，會接下來調用 resize 方法

 void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        //關鍵性代碼，構建新hashmap並將老的數據移動過來
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

　　3、其中，出現100%問題的關鍵就是上面的 transfer 方法，新建hashmap移動複製老數據

 1  void transfer(Entry[] newTable, boolean rehash) {
 2         int newCapacity = newTable.length;
 3         for (Entry<K,V> e : table) {
 4             // 遍歷老的HashMap，當遇到不為空的節點的是，進入移動方法
 5             while(null != e) {
 6                 // 首先創建個Entry節點 指向該節點所在鏈表的下一個節點數據
 7                 Entry<K,V> next = e.next;
 8                 if (rehash) {
 9                     e.hash = null == e.key ? 0 : hash(e.key);
10                 }
11 　　　           // 計算老的數據在新Hashmap中的下標位置
12                 int i = indexFor(e.hash, newCapacity);
13 　　　　　        // 將新HashMap中相應位置的元素，掛載到老數據的後面（不管有無數據）
14                 e.next = newTable[i];
15                 // 將新HashMap中相應位置指向上面已經成功掛載新數據的老數據
16 　　　　　        newTable[i] = e;
17 　　　　　        // 移動到鏈表節點中的下一個數據，繼續複製節點
18                 e = next;
19             }
20         }
21     }    

　　問題的關鍵就在上述的14、15行上，這兩行的動作，在高併發下可能就會造成循環鏈表，循環鏈表在等待下一個嘗試 get 獲取數據的時候，就悲劇了。下面舉例模擬說說這個過程：

　　（1）假設目前某個位置的鏈表存儲結構為 A -> B -> C，有兩個線程同時進行擴容操作

　　（2）線程1執行到第7行 Entry<K,V> next = e.next; 的時候被掛起了，此時，線程1的 e 指向 A ， next 指向的是 B

　　（3）線程2執行完成了整個的擴容過程，那麼此時的鏈表結構應該是變為了 C -> B -> A

　　（4）線程1喚醒繼續執行，而需要操作的鏈表實際就變成了了上述線程2完成后的 C ->B -> A，下面分為幾步去完成整個操作：

　　　　　 第一次循環：

　　　　　　　　（i）執行 e.next = newTable[i] ，將 A 的 next 指向線程1的新的HashMap，由於此時無數據，所以 e.next = null

　　　　　　　　（ii）執行 newTable[i] = e，將線程1的新的HashMap的第一個元素指向 A 

　　　　　　　　（iii）執行e = next，移動到鏈表中的下一個元素，也就是上面的（2）中的 線程掛起的時候的 B

　　　　　 第二次循環：

　　　　　　　　（i）執行 Entry<K,V> next = e.next，此時的 e 指向 B，next指向 A

　　　　　　　　（ii）執行 e.next = newTable[i] ，將 B 的 next 指向線程1的新的HashMap，由於此時有數據A，所以 e.next = A

　　　　　　　　（iii）執行 newTable[i] = e，將線程1的新的HashMap的第一個元素指向 B，此時線程1的新Hashmap鏈表結構為B -> A

　　　　　　　　（iiii）執行e = next，移動到鏈表中的下一個元素 A

　　　　　 第三次循環：

　　　　　　　　（i）執行 Entry<K,V> next = e.next，此時的 e 指向 A，next指向 null

　　　　　　　　（ii）執行 e.next = newTable[i] ，將 A 的 next 指向線程1的新的HashMap，由於此時有數據B，所以 e.next = B

　　　　　　　　（iii）執行 newTable[i] = e，將線程1的新的HashMap的第一個元素指向 A ，此時線程1的新Hashmap鏈表結構為 A -> B -> A

　　　　　　　　（iiii）執行e = next，移動到鏈表中的下一個元素，已移動到鏈表結尾，結束 while 循環，完成鏈表的轉移。

　　（5）上述過程中，很顯然的，最終的鏈表結構中，出現了 A -> B -> A 的循環結構。擴容完成了，剩下的等待的是get獲取的時候， getEntry 方法中 for循環e = e.next中就永遠出不來了。

　　注意：擴容過程中，newTable是每個擴容線程獨有的，共享的只是每個Entry節點數據，最終的擴容是會調用 table = newTable 賦值操作完成。

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

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

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

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

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

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