介紹

Spring Boot的starter主要用來簡化依賴用的，對於企業級開發中的與第三方的集成，可以通過一段簡單的配置來完成，這樣開發人員無需再對包依賴的問題頭疼。Spring Boot為我們提供了簡化企業級開發的絕大多數場景的starter pom，只需要指定需要配置的starter，Spring Boot會自動為我們提供配置好的bean。

通常流程

通常我們要搭建一個基於Spring的Web應用，我們需要做以下一些工作：

pom文件中引入相關jar包，包括spring、springmvc、redis、mybaits、log4j、mysql-connector-java 等等相關jar …

配置web.xml，Listener配置、Filter配置、Servlet配置、log4j配置、error配置 …

配置數據庫連接、配置spring事務

配置視圖解析器

開啟註解、自動掃描功能

配置完成後部署tomcat、啟動調試

……

花在搭建一個初始項目，可能一個小時就過去了或者半天就過了，但是用了SpringBoot之後一切都會變得非常便捷。

常用的starter

Spring Boot常用的starter（啟動器）包括：

• Spring-boot-starter-logging ：使用 Spring Boot 默認的日誌框架 Logback。
• Spring-boot-starter-log4j ：添加 Log4j 的支持。
• Spring-boot-starter-web ：支持 Web 應用開發，包含 Tomcat 和 Spring-mvc。
• Spring-boot-starter-tomcat ：使用 Spring Boot 默認的 Tomcat 作為應用服務器。
• Spring-boot-starter-jetty ：使用 Jetty 而不是默認的 Tomcat 作為應用服務器。
• Spring-boot-starter-test ：包含常用的測試所需的依賴，如 Junit、Hamcrest、Mockito 和 Spring-test 等。
• Spring-boot-starter-AOP ：包含 Spring-AOP 和 AspectJ 來支持面向切面編程（AOP）。
• Spring-boot-starter-security ：包含 Spring-security。
• Spring-boot-starter-jdbc ：支持使用 JDBC 訪問數據庫。
• Spring-boot-starter-redis ：支持使用 Redis。
• Spring-boot-starter-data-mongodb ：包含 Spring-data-mongodb 來支持 MongoDB。
• Spring-boot-starter-data-jpa ：包含 Spring-data-jpa、Spring-orm 和 Hibernate 來支持 JPA。
• Spring-boot-starter-amqp ：通過 Spring-rabbit 支持 AMQP。
• Spring-boot-starter-actuator ： 添加適用於生產環境的功能，如性能指標和監測等功能。

當然，如果有必要，也可以定製自己的starter。

起步依賴

在我們的pom文件裏面引入以下jar：

spring-boot-starter-web包自動幫我們引入了web模塊開發需要的相關jar包。

mybatis-spring-boot-starter幫我們引入了dao開發相關的jar包。 spring-boot-starter-xxx是官方提供的starter，xxx-spring-boot-starter是第三方提供的starter。

截圖看一下我們的mybatis-spring-boot-starter

可以看出mybatis-spring-boot-starter並沒有任何源碼，只有一個pom文件，它的作用就是幫我們引入其它jar。

得益於starter的作用，使用SpringBoot確實方便，但對剛剛上手SpringBoot的人來說，可能只知道配置屬性是在application.xml或application.yml中添加，但他們各自的屬性都有哪些，具體怎麼配置，卻無從下手。這裏先解決SpringBoot-starter中各屬性的配置問題。

Mybatis的配置是怎麼生效的？查看示例工程的pom依賴：

注意到mybatis-spring-boot-starter幫我們自動依賴了Mybatis所需jar包，其中有一個負責自動配置的mybatis-spring-boot-autoconfigure.jar，緊接着打開此jar，如下：

META-INF/spring-configuration-metadata.json中便是Mybatis在SpringBoot中的所有配置屬性和介紹。

SpringBoot-starter自動配置bean

現在已得知jar包是怎麼樣自動依賴進來，以及他們的配置屬性，那麼接下來該考慮Mybatis所需的bean（如必需的sqlSessionFactory、sqlSessionTemplate等）是如何被自動加載的？

理所應當地，我們繼續去查看mybatis-spring-boot-autoconfigure.jar，注意到裏面有一個自動配置的類MybatisAutoConfiguration：

（1）@Configuration：被掛上@Configuration註解，表明它是一個配置類，作用等同於xml配置，裏面有被@Bean註解的方法，也等同於xml配置的各種。

（2）@ConditionalOnClass/@ConditionalOnBean：自動配置條件註解，用於在某一部分配置中，將另一模塊部分的配置自動加載進來，因為隨着系統越來越大，配置內容越來越多，我們應當將Mybatis的配置放在一處，將log4j的配置放在一處，將SpringBoot自身的配置放在一處，當他們需要互相依賴時，可通過這類註解進行自動配置，如下：

@ConditionalOnClass @ConditionalOnMissingClass
@ConditionalOnBean @ConditionalOnMissingBean
@ConditionalOnProperty
@ConditionalOnResource
@ConditionalOnWebApplication @ConditionalOnNotWebApplication
@ConditionalOnExpression
 
@AutoConfigureAfter @AutoConfigureBefore @AutoConfigureOrder（指定順序）

（3）@EnableConfigurationProperties：啟用對@ConfigurationProperties註解的bean的支持，這裏對應了配置屬性類MybatisProperties，它裏面定義了Mybatis的所有配置。

（4）@AutoConfigureAfter：應在其他指定的自動配置類之後應用自動配置。即org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration被自動配置后，才會接着自動配置MybatisAutoConfiguration。這裏也解釋了為什麼我們在application.xml中只配置了數據源，而沒有配置Mybatis，但是Mybatis可以正常查庫的原因，就是因為它們配置之間的依賴關係。

到這裏，差不多明白了starter自動配置bean的方式，但是如若再去深究，各種starter的bean是如何被自動加載的，猜想會不會是項目啟動后，SpringBoot自動掃描裏面所有的jar包，再去掃描所有的類，從而將各個bean放置IOC容器中。從結果來看，肯定是SpringBoot在啟動時確確實實地自動加載了數據源和Mybatis相關的bean，不然他們無法正常工作。

回想在我們啟動示例工程時，SpringBoot會自動掃描啟動類所在包下的所有類，而如果還去掃描所有的jar包的話，又是具體怎麼做到的？不妨從入口類調試一把，在SpringApplication.run(DemoApplication.class, args)打斷點，一直追蹤到getSpringFactoriesInstances這塊：

查看SpringFactoriesLoader.loadFactoryNames的方法註釋：

使用給定的類加載器從META-INF / spring.factories加載給定類型的工廠實現的完全限定類名。

這裏的spring.factories剛好也存在於mybatis-spring-boot-autoconfigure.jar中，

繼續調試，進入SpringFactoriesLoader.loadFactoryNames，

這裏用類加載器得到工程中所有jar包中的META-INF/spring.factories文件資源，進而通過此文件得到了一些包括自動配置相關的類的集合，有各種工廠類、監聽器、處理器、過濾器、初始化器等等，如下：

最後的org.springframework.boot.autoconfigure.EnableAutoConfiguration集合中當然包括了org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration和org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration。接着必然是將實例化的各個bean放進IOC容器中。

至此我們便明白了SpringBoot是如何自動配置starter裏面的bean的。

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

【其他文章推薦】

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

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

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

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

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

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

作者：小傅哥
博客：https://bugstack.cn – 原創系列專題文章

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

一、前言

相信相信的力量！

從懵懂的少年，到拿起鍵盤，可以寫一個HelloWorld。多數人在這並不會感覺有多難，也不會認為做不出來。因為這樣的例子，有老師的指導、有書本的例子、有前人的經驗。但隨着你的開發時間越來越長，要解決更複雜的問題或者技術創新，因此在網上搜了幾天幾夜都沒有答案，這個時候是否想過放棄，還是一直堅持不斷的嘗試一點點完成自己心裏要的結果。往往這種沒有前車之鑒需要自己解決問題的時候，可能真的會折磨到要崩潰，但你要願意執着、願意倔強，願意選擇相信相信的力量，就一定能解決。哪怕解決不了，也可以在這條路上摸索出其他更多的收穫，為後續前進的道路填充好墊腳石。

時間緊是寫垃圾代碼的理由？

擰螺絲？Ctrl+C、Ctrl+V？貼膏藥一樣寫代碼？沒有辦法，沒有時間，往往真的是借口，胸中沒用筆墨，才只能湊合。難道一定是好好寫代碼就浪費時間，拼湊CRUD就快嗎，根本不可能的。因為不會，沒用實操過，很少架構出全場景的設計，才很難寫出優良的代碼。多增強自身的編碼(武術)修為，在各種編碼場景中讓自己變得老練，才好應對緊急情況下的需求開發和人員安排。就像韓信一樣有謀有略，才能執掌百萬雄兵。

不要只是做個工具人！

因為日常的編寫簡單業務需求，導致自己像個工具人一樣，日久天長的也就很少去深入學習更多技術棧。看見有工具、有組件、有框架，拿來就用用，反正沒什麼體量也不會出什麼問題。但如果你想要更多的收入，哪怕是重複的造輪子，你也要去嘗試造一個，就算不用到生產，自己玩玩總可以吧。有些事情只有自己經歷過，才能有最深的感觸，參与過實踐過，才好總結點評學習。

二、開發環境

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

三、迭代器模式介紹

迭代器模式，常見的就是我們日常使用的iterator遍歷。雖然這個設計模式在我們的實際業務開發中的場景並不多，但卻幾乎每天都要使用jdk為我們提供的list集合遍歷。另外增強的for循環雖然是循環輸出數據，但是他不是迭代器模式。迭代器模式的特點是實現Iterable接口，通過next的方式獲取集合元素，同時具備對元素的刪除等操作。而增強的for循環是不可以的。

這種設計模式的優點是可以讓我們以相同的方式，遍歷不同的數據結構元素，這些數據結構包括；數組、鏈表、樹等，而用戶在使用遍歷的時候並不需要去關心每一種數據結構的遍歷處理邏輯，從讓使用變得統一易用。

四、案例場景模擬

在本案例中我們模擬迭代遍歷輸出公司中樹形結構的組織架構關係中僱員列表

大部分公司的組織架構都是金字塔結構，也就這種樹形結構，分為一級、二級、三級等部門，每個組織部門由僱員填充，最終體現出一個整體的樹形組織架構關係。

一般我們常用的遍歷就是jdk默認提供的方法，對list集合遍歷。但是對於這樣的偏業務特性較大的樹形結構，如果需要使用到遍歷，那麼就可以自己來實現。接下來我們會把這個組織層次關係通過樹形數據結構來實現，並完成迭代器功能。

五、迭代器模式遍歷組織結構

在實現迭代器模式之前可以先閱讀下java中list方法關於iterator的實現部分，幾乎所有的迭代器開發都會按照這個模式來實現，這個模式主要分為以下幾塊；

1. Collection，集合方法部分用於對自定義的數據結構添加通用方法；add、remove、iterator等核心方法。
2. Iterable，提供獲取迭代器，這個接口類會被Collection繼承。
3. Iterator，提供了兩個方法的定義；hasNext、next，會在具體的數據結構中寫實現方式。

除了這樣通用的迭代器實現方式外，我們的組織關係結構樹，是由節點和節點間的關係鏈構成，所以會比上述的內容多一些入參。

1. 工程結構

itstack-demo-design-15-02
└── src
    ├── main
    │   └── java
    │       └── org.itstack.demo.design
    │           ├── group
    │           │	├── Employee.java
    │           │	├── GroupStructure.java
    │           │	└── Link.java
    │           └──  lang
    │            	├── Collection.java
    │            	├── Iterable.java
    │            	└── Iterator.java
    └── test
        └── java
            └── org.itstack.demo.design.test
                └── ApiTest.java

迭代器模式模型結構

• 以上是我們工程類圖的模型結構，左側是對迭代器的定義，右側是在數據結構中實現迭代器功能。
• 關於左側部分的實現與jdk中的方式是一樣的，所以在學習的過程中可以互相參考，也可以自己擴展學習。
• 另外這個遍歷方式一個樹形結構的深度遍歷，為了可以更加讓學習的小夥伴容易理解，這裏我實現了一種比較簡單的樹形結構深度遍歷方式。後續讀者也可以把遍歷擴展為橫向遍歷也就是寬度遍歷。

2. 代碼實現

2.1 僱員實體類

/**
 * 僱員
 */
public class Employee {

    private String uId;   // ID
    private String name;  // 姓名
    private String desc;  // 備註
    
    // ...get/set
}

• 這是一個簡單的僱員類，也就是公司員工的信息類，包括必要的信息；id、姓名、備註。

2.2 樹節點鏈路

/**
 * 樹節點鏈路
 */
public class Link {

    private String fromId; // 僱員ID
    private String toId;   // 僱員ID    
    
    // ...get/set
}

• 這個類用於描述結構樹中的各個節點之間的關係鏈，也就是A to B、B to C、B to D，以此描述出一套完整的樹組織結構。

2.3 迭代器定義

public interface Iterator<E> {

    boolean hasNext();

    E next();
    
}

• 這裏的這個類和java的jdk中提供的是一樣的，這樣也方面後續讀者可以對照list的Iterator進行源碼學習。
• 方法描述；hasNext，判斷是否有下一個元素、next，獲取下一個元素。這個在list的遍歷中是經常用到的。

2.4 可迭代接口定義

public interface Iterable<E> {

    Iterator<E> iterator();

}

• 這個接口中提供了上面迭代器的實現Iterator的獲取，也就是後續在自己的數據結構中需要實現迭代器的功能並交給Iterable，由此讓外部調用方進行獲取使用。

2.5 集合功能接口定義

public interface Collection<E, L> extends Iterable<E> {

    boolean add(E e);

    boolean remove(E e);

    boolean addLink(String key, L l);

    boolean removeLink(String key);

    Iterator<E> iterator();

}

• 這裏我們定義集合操作接口；Collection，同時繼承了另外一個接口Iterable的方法iterator()。這樣後續誰來實現這個接口，就需要實現上述定義的一些基本功能；添加元素、刪除元素、遍歷。
• 同時你可能注意到這裏定義了兩個泛型<E, L>，因為我們的數據結構一個是用於添加元素，另外一個是用於添加樹節點的鏈路關係。

2.6 (核心)迭代器功能實現

public class GroupStructure implements Collection<Employee, Link> {

    private String groupId;                                                 // 組織ID，也是一個組織鏈的頭部ID
    private String groupName;                                               // 組織名稱
    private Map<String, Employee> employeeMap = new ConcurrentHashMap<String, Employee>();  // 僱員列表
    private Map<String, List<Link>> linkMap = new ConcurrentHashMap<String, List<Link>>();  // 組織架構關係；id->list
    private Map<String, String> invertedMap = new ConcurrentHashMap<String, String>();       // 反向關係鏈

    public GroupStructure(String groupId, String groupName) {
        this.groupId = groupId;
        this.groupName = groupName;
    }

    public boolean add(Employee employee) {
        return null != employeeMap.put(employee.getuId(), employee);
    }

    public boolean remove(Employee o) {
        return null != employeeMap.remove(o.getuId());
    }

    public boolean addLink(String key, Link link) {
        invertedMap.put(link.getToId(), link.getFromId());
        if (linkMap.containsKey(key)) {
            return linkMap.get(key).add(link);
        } else {
            List<Link> links = new LinkedList<Link>();
            links.add(link);
            linkMap.put(key, links);
            return true;
        }
    }

    public boolean removeLink(String key) {
        return null != linkMap.remove(key);
    }

    public Iterator<Employee> iterator() {

        return new Iterator<Employee>() {

            HashMap<String, Integer> keyMap = new HashMap<String, Integer>();

            int totalIdx = 0;
            private String fromId = groupId;  // 僱員ID，From
            private String toId = groupId;   // 僱員ID，To

            public boolean hasNext() {
                return totalIdx < employeeMap.size();
            }

            public Employee next() {
                List<Link> links = linkMap.get(toId);
                int cursorIdx = getCursorIdx(toId);

                // 同級節點掃描
                if (null == links) {
                    cursorIdx = getCursorIdx(fromId);
                    links = linkMap.get(fromId);
                }

                // 上級節點掃描
                while (cursorIdx > links.size() - 1) {
                    fromId = invertedMap.get(fromId);
                    cursorIdx = getCursorIdx(fromId);
                    links = linkMap.get(fromId);
                }

                // 獲取節點
                Link link = links.get(cursorIdx);
                toId = link.getToId();
                fromId = link.getFromId();
                totalIdx++;

                // 返回結果
                return employeeMap.get(link.getToId());
            }
             
            // 給每個層級定義寬度遍歷進度
            public int getCursorIdx(String key) {
                int idx = 0;
                if (keyMap.containsKey(key)) {
                    idx = keyMap.get(key);
                    keyMap.put(key, ++idx);
                } else {
                    keyMap.put(key, idx);
                }
                return idx;
            }
        };
    }

}

• 以上的這部分代碼稍微有點長，主要包括了對元素的添加和刪除。另外最重要的是對遍歷的實現 new Iterator<Employee>。
• 添加和刪除元素相對來說比較簡單，使用了兩個map數組結構進行定義；僱員列表、組織架構關係；id->list。當元素添加元素的時候，會分別在不同的方法中向map結構中進行填充指向關係(A->B)，也就構建出了我們的樹形組織關係。

迭代器實現思路

1. 這裏的樹形結構我們需要做的是深度遍歷，也就是左側的一直遍歷到最深節點。
2. 當遍歷到最深節點后，開始遍歷最深節點的橫向節點。
3. 當橫向節點遍歷完成后則向上尋找橫向節點，直至樹結構全部遍歷完成。

3. 測試驗證

3.1 編寫測試類

@Test
public void test_iterator() { 
    // 數據填充
    GroupStructure groupStructure = new GroupStructure("1", "小傅哥");  
    
    // 僱員信息
    groupStructure.add(new Employee("2", "花花", "二級部門"));
    groupStructure.add(new Employee("3", "豆包", "二級部門"));
    groupStructure.add(new Employee("4", "蹦蹦", "三級部門"));
    groupStructure.add(new Employee("5", "大燒", "三級部門"));
    groupStructure.add(new Employee("6", "虎哥", "四級部門"));
    groupStructure.add(new Employee("7", "玲姐", "四級部門"));
    groupStructure.add(new Employee("8", "秋雅", "四級部門"));   
    
    // 節點關係 1->(1,2) 2->(4,5)
    groupStructure.addLink("1", new Link("1", "2"));
    groupStructure.addLink("1", new Link("1", "3"));
    groupStructure.addLink("2", new Link("2", "4"));
    groupStructure.addLink("2", new Link("2", "5"));
    groupStructure.addLink("5", new Link("5", "6"));
    groupStructure.addLink("5", new Link("5", "7"));
    groupStructure.addLink("5", new Link("5", "8"));       

    Iterator<Employee> iterator = groupStructure.iterator();
    while (iterator.hasNext()) {
        Employee employee = iterator.next();
        logger.info("{}，僱員 Id：{} Name：{}", employee.getDesc(), employee.getuId(), employee.getName());
    }
}

3.2 測試結果

22:23:37.166 [main] INFO  org.itstack.demo.design.test.ApiTest - 二級部門，僱員 Id：2 Name：花花
22:23:37.168 [main] INFO  org.itstack.demo.design.test.ApiTest - 三級部門，僱員 Id：4 Name：蹦蹦
22:23:37.169 [main] INFO  org.itstack.demo.design.test.ApiTest - 三級部門，僱員 Id：5 Name：大燒
22:23:37.169 [main] INFO  org.itstack.demo.design.test.ApiTest - 四級部門，僱員 Id：6 Name：虎哥
22:23:37.169 [main] INFO  org.itstack.demo.design.test.ApiTest - 四級部門，僱員 Id：7 Name：玲姐
22:23:37.169 [main] INFO  org.itstack.demo.design.test.ApiTest - 四級部門，僱員 Id：8 Name：秋雅
22:23:37.169 [main] INFO  org.itstack.demo.design.test.ApiTest - 二級部門，僱員 Id：3 Name：豆包

Process finished with exit code 0

• 從遍歷的結果可以看到，我們是順着樹形結構的深度開始遍歷，一直到右側的節點3；僱員 Id：2、僱員 Id：4...僱員 Id：3

六、總結

• 迭代器的設計模式從以上的功能實現可以看到，滿足了單一職責和開閉原則，外界的調用方也不需要知道任何一個不同的數據結構在使用上的遍歷差異。可以非常方便的擴展，也讓整個遍歷變得更加乾淨整潔。
• 但從結構的實現上可以看到，迭代器模式的實現過程相對來說是比較負責的，類的實現上也擴增了需要外部定義的類，使得遍歷與原數據結構分開。雖然這是比較麻煩的，但可以看到在使用java的jdk時候，迭代器的模式還是很好用的，可以非常方便擴展和升級。
• 以上的設計模式場景實現過程可能對新人有一些不好理解點，包括；迭代器三個和接口的定義、樹形結構的數據關係、樹結構深度遍歷思路。這些都需要反覆實現練習才能深入的理解，事必躬親，親歷親為，才能讓自己掌握這些知識。

七、推薦閱讀

• 1. 重學 Java 設計模式：實戰工廠方法模式「多種類型商品不同接口，統一發獎服務搭建場景」
• 2. 重學 Java 設計模式：實戰原型模式「上機考試多套試，每人題目和答案亂序排列場景」
• 3. 重學 Java 設計模式：實戰橋接模式「多支付渠道(微信、支付寶)與多支付模式(刷臉、指紋)場景」
• 4. 重學 Java 設計模式：實戰組合模式「營銷差異化人群發券，決策樹引擎搭建場景」
• 5. 重學 Java 設計模式：實戰外觀模式「基於SpringBoot開發門面模式中間件，統一控制接口白名單場景」
• 6. 重學 Java 設計模式：實戰享元模式「基於Redis秒殺，提供活動與庫存信息查詢場景」

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

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

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

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

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

※幫你省時又省力,新北清潔一流服務好口碑

※回頭車貨運收費標準