14 微服務電商【黑馬樂優商城】：day01-springboot（理論篇）

 

本項目的筆記和資料的Download，請點擊這一句話自行獲取。

day01-springboot（理論篇） ；day01-springboot（實踐篇） ；day01-springboot（Thymeleaf快速入門）

14 微服務電商【黑馬樂優商城】：day01-springboot

---

 

 1.1.什么是SpringBoot

SpringBoot是Spring項目中的一個子工程，與我們所熟知的Spring-framework 同屬於spring的產品:

> Takes an opinionated view of building production-ready Spring applications. Spring Boot favors convention over configuration and is designed to get you up and running as quickly as possible.

翻譯一下：

> 用一些固定的方式來構建生產級別的spring應用。Spring Boot 推崇約定大於配置的方式以便於你能夠盡可能快速的啟動並運行程序。

 

要先學完maven高級課程，理解子模塊繼承父工程的依賴原理。

2.2.1.添加父工程坐標

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

2.2.2.添加web啟動器

為了讓SpringBoot幫我們完成各種自動配置，我們必須引入SpringBoot提供的自動配置依賴，我們稱為啟動器。因為我們是web項目，這里我們引入web啟動器：

        <!--相當於springMVC的依賴坐標-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

需要注意的是，我們並沒有在這里指定版本信息。因為SpringBoot的父工程已經對版本進行了管理了。

2.2.3.管理jdk版本

默認情況下，maven工程的jdk版本是1.5，而我們開發使用的是1.8，因此這里我們需要修改jdk版本，只需要簡單的添加以下屬性即可：

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

下面會使用注解導入配置信息，建議使用下面的 springboot注解配置處理器

        <!--注解@ConfigurationProperties的提示處理器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

2.3.啟動類

Spring Boot項目通過main函數即可啟動，我們需要創建一個啟動類：

然后編寫main函數：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2.5.啟動測試

運行main函數，查看控制台，可以看到監聽的端口信息：

 

• 1）監聽的端口是8080
• 2）SpringMVC的映射路徑是：/
• 3）/hello路徑已經映射到了HelloController中的hello()方法

 

---

3.Java配置

使用spring boot開發項目 ，如果沒有任何的xml，那么我們如果要配置一個Bean該怎么辦？比如我們要配置一個數據庫連接池，以前會這么玩：

<!-- 配置連接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

3.2.嘗試java配置的@Value注解

java配置主要靠java類和一些注解，比較常用的注解有：

• @Configuration：聲明一個類作為配置類，代替xml文件
• @Bean：聲明在方法上，將方法的返回值加入Bean容器，代替<bean>標簽
• @value：屬性注入
• @PropertySource：指定外部屬性文件

我們接下來用java配置來嘗試實現連接池配置：

首先引入Druid連接池依賴：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.9</version>
</dependency>

創建一個jdbc.properties文件，編寫jdbc屬性：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou
jdbc.username=root
jdbc.password=root

然后編寫代碼：

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

 

解讀：

• @Configuration：聲明我們JdbcConfig是一個配置類
• @PropertySource：指定屬性文件的路徑是:classpath:jdbc.properties
• 通過@Value為屬性注入值
• 通過@Bean將 dataSource()方法聲明為一個注冊Bean的方法，Spring會自動調用該方法，將方法的返回值加入Spring容器中。

然后我們就可以在任意位置通過@Autowired注入DataSource了！

我們在HelloController中測試：

@RestController
public class HelloController {

    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello() {
        return "hello, spring boot!" + dataSource;
    }
}

然后Debug運行並查看，屬性注入成功了。

@GetMapping是一個組合注解，是@RequestMapping(method = RequestMethod.GET)的縮寫。

3.3.SpringBoot的屬性注入

在上面的案例中，我們實驗了java配置方式。不過屬性注入使用的是@Value注解。這種方式雖然可行，但是不夠強大，因為它只能注入基本類型值。

在SpringBoot中，提供了一種新的屬性注入方式，支持各種java基本數據類型及復雜類型的注入。

1）我們新建一個類，用來進行屬性注入：

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    // getters 和 setters方法
}

 

• 在類上通過@ConfigurationProperties注解聲明當前類為屬性讀取類

• prefix="jdbc"讀取屬性文件中，前綴為jdbc的值。

• 在類上定義各個屬性，名稱必須與屬性文件中jdbc.后面部分一致

• 需要注意的是，這里我們並沒有指定屬性文件的地址，所以我們需要把jdbc.properties名稱改為application.properties，這是SpringBoot默認讀取的屬性文件名：

 

#yml配置文件注釋使用#
#數據庫四項連接配置
jdbc:
  driver:com.mysql.cj.jdbc.Driver
  url:jdbc:mysql://localhost:3306/itheima?serverTimezone=Asia/Shanghai
  username:root
  password:root

 

2）在配置類JdbcConfig中使用這個屬性：

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {

    @Bean public DataSource dataSource(JdbcProperties jdbc) {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        dataSource.setUsername(jdbc.getUsername());
        dataSource.setPassword(jdbc.getPassword());
        return dataSource;
    }
}

 

• 通過@EnableConfigurationProperties(JdbcProperties.class)來聲明要使用JdbcProperties這個類的對象

• 然后你可以通過以下方式注入JdbcProperties：

  • @Autowired注入

    @Autowired
    private JdbcProperties prop;

     

  • 構造函數注入

    private JdbcProperties prop;
    public JdbcConfig(Jdbcproperties prop){
        this.prop = prop;
    }

     

  • 由@Bean聲明的方法參數注入

    @Bean
    public Datasource dataSource(JdbcProperties prop){
        // ...
    }

     

本例中，我們采用的是第三種方式。

 

3.4、更優雅的注入

事實上，如果一段屬性只有一個Bean需要使用，我們無需將其注入到一個類（JdbcProperties）中。而是直接在需要的地方聲明即可：

@Configuration
public class JdbcConfig {

    @Bean
    // 聲明要注入的屬性前綴，SpringBoot會自動把相關屬性通過檢測到有的set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

我們直接把@ConfigurationProperties(prefix = "jdbc")聲明在需要使用的@Bean的方法上，然后SpringBoot就會自動調用這個Bean（此處是DataSource）的set方法，然后完成注入。使用的前提是：該類必須有對應屬性的set方法！

 

---

4.自動配置原理

使用SpringBoot之后，一個整合了SpringMVC的WEB工程開發，變的無比簡單，那些繁雜的配置都消失不見了，這是如何做到的？

一切魔力的開始，都是從我們的main函數來的，所以我們再次來看下啟動類：

我們發現特別的地方有兩個：

• 注解：@SpringBootApplication
• run方法：SpringApplication.run()

我們分別來研究這兩個部分。

4.1.了解@SpringBootApplication

點擊進入，查看源碼：

這里重點的注解有3個：

• @SpringBootConfiguration
• @EnableAutoConfiguration
• @ComponentScan

4.1.1.@SpringBootConfiguration

我們繼續點擊查看源碼：

通過這段我們可以看出，在這個注解上面，又有一個@Configuration注解。通過上面的注釋閱讀我們知道：這個注解的作用就是聲明當前類是一個配置類，然后Spring會自動掃描到添加了@Configuration的類，並且讀取其中的配置信息。而@SpringBootConfiguration是來聲明當前類是SpringBoot應用的配置類，項目中只能有一個。所以一般我們無需自己添加。

4.1.2.@EnableAutoConfiguration

關於這個注解，官網上有一段說明：

The second class-level annotation is @EnableAutoConfiguration. This annotation tells Spring Boot to “guess” how you want to configure Spring, based on the jar dependencies that you have added. Since spring-boot-starter-web added Tomcat and Spring MVC, the auto-configuration assumes that you are developing a web application and sets up Spring accordingly.

簡單翻譯以下：

第二級的注解@EnableAutoConfiguration，告訴SpringBoot基於你所添加的依賴，去“猜測”你想要如何配置Spring。比如我們引入了spring-boot-starter-web，而這個啟動器中幫我們添加了tomcat、SpringMVC的依賴。此時自動配置就知道你是要開發一個web應用，所以就幫你完成了web及SpringMVC的默認配置了！

總結，SpringBoot內部對大量的第三方庫或Spring內部庫進行了默認配置，這些配置是否生效，取決於我們是否引入了對應庫所需的依賴，如果有那么默認配置就會生效。

所以，我們使用SpringBoot構建一個項目，只需要引入所需框架的依賴，配置就可以交給SpringBoot處理了。除非你不希望使用SpringBoot的默認配置，它也提供了自定義配置的入口。

4.1.3.@ComponentScan

我們跟進源碼：

 並沒有看到什么特殊的地方。我們查看注釋：

大概的意思：

配置組件掃描的指令。提供了類似與<context:component-scan>標簽的作用

通過basePackageClasses或者basePackages屬性來指定要掃描的包。如果沒有指定這些屬性，那么將從聲明這個注解的類所在的包開始，掃描包及子包

而我們的@SpringBootApplication注解聲明的類就是main函數所在的啟動類，因此掃描的包是該類所在包及其子包。因此，一般啟動類會放在一個比較前的包目錄中。

---

4.2.默認配置原理

4.2.1默認配置類

通過剛才的學習，我們知道@EnableAutoConfiguration會開啟SpringBoot的自動配置，並且根據你引入的依賴來生效對應的默認配置。那么問題來了：

• 這些默認配置是在哪里定義的呢？
• 為何依賴引入就會觸發配置呢？

其實在我們的項目中，已經引入了一個依賴：spring-boot-autoconfigure，其中定義了大量自動配置類：

 還有：

非常多，幾乎涵蓋了現在主流的開源框架，例如：

• redis
• jdbc
• jackson
• mongodb
• jpa
• solr
• elasticsearch
• ……

我們來看一個我們熟悉的，例如SpringMVC，查看mvc 的自動配置類：

 打開WebMvcAutoConfiguration：

我們看到這個類上的4個注解：

• @Configuration：聲明這個類是一個配置類

• @ConditionalOnWebApplication(type = Type.SERVLET)

  ConditionalOn，翻譯就是在某個條件下，此處就是滿足項目的類是是Type.SERVLET類型，也就是一個普通web工程，顯然我們就是

• @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })

  這里的條件是OnClass，也就是滿足以下類存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中Servlet只要引入了tomcat依賴自然會有，后兩個需要引入SpringMVC才會有。這里就是判斷你是否引入了相關依賴，引入依賴后該條件成立，當前類的配置才會生效！

• @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

  這個條件與上面不同，OnMissingBean，是說環境中沒有指定的Bean這個才生效。其實這就是自定義配置的入口，也就是說，如果我們自己配置了一個WebMVCConfigurationSupport的類，那么這個默認配置就會失效！

接着，我們查看該類中定義了什么：

視圖解析器：

 處理器適配器（HandlerAdapter）：

4.2.2.默認配置屬性

另外，這些默認配置的屬性來自哪里呢？

 

 我們看到，這里通過@EnableAutoConfiguration注解引入了兩個屬性：WebMvcProperties和ResourceProperties。

 我們查看這兩個屬性類：

 1、找到了內部資源視圖解析器的prefix和suffix屬性。

 

2、ResourceProperties中主要定義了靜態資源（.js,.html,.css等)的路徑：

 如果我們要覆蓋這些默認屬性，只需要在application.properties中定義與其前綴prefix和字段名一致的屬性即可。

 

 application*.yml  配置文件格式使用可參考：

 黑馬_13 Spring Boot：04.spring boot 配置文件

 實際運行spring boot開發的項目，取上述兩個配置文件的並集，並且以 application*.properties定義的優先級更高。

4.3.總結

SpringBoot為我們提供了默認配置，而默認配置生效的條件一般有兩個：

• 你引入了相關依賴
• 你自己沒有配置

1）啟動器

所以，我們如果不想配置，只需要引入依賴即可，而依賴版本我們也不用操心，因為只要引入了SpringBoot提供的stater（啟動器），就會自動管理依賴及版本了。

因此，玩SpringBoot的第一件事情，就是找啟動器，SpringBoot提供了大量的默認啟動器，參考課前資料中提供的《SpringBoot啟動器.txt》

2）全局配置

另外，SpringBoot的默認配置，都會讀取默認屬性，而這些屬性可以通過自定義application.properties文件來進行覆蓋。這樣雖然使用的還是默認配置，但是配置中的值改成了我們自定義的。

因此，玩SpringBoot的第二件事情，就是通過application.yml來覆蓋默認屬性值，形成自定義配置。我們需要知道SpringBoot的默認屬性key，非常多，參考課前資料的：《SpringBoot全局屬性.md》

---

5.SpringBoot實踐

接下來，我們來看看如何用SpringBoot來玩轉以前的SSM,我們沿用之前講解SSM用到的數據庫tb_user和實體類User

day01springboot 5.4實踐整合mybatis（實戰篇）代碼和內容

請點擊上面的超鏈接，跳轉到我的CSDN博客，如有疑問請在CSDN評論區留言。

5.1.1.修改端口 

#tomcat服務器映射端口
server:
 port: 8080
 servlet:
   #對應於視圖層Controller類中的@RequestMapping的("/*.do")
   path: "*.do"

上面的配置信息相當於SSM整合Web項目中WEB-INF目錄中的web.xml

5.1.2.訪問靜態資源

現在，我們的項目是一個jar工程，那么就沒有webapp，我們的靜態資源該放哪里呢？

回顧我們上面看的源碼，有一個叫做ResourceProperties的類，里面就定義了靜態資源的默認查找路徑：

 

默認的靜態資源路徑為：

• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public/

只要靜態資源放在這些目錄中任何一個，SpringMVC都會幫我們處理。

我們習慣會把SpringBoot靜態資源放在classpath:/static/目錄下。我們創建目錄，並且添加一些靜態資源：

 

5.1.3.添加攔截器

攔截器也是我們經常需要使用的，在SpringBoot中該如何配置呢？

攔截器不是一個普通屬性，而是一個Java類，所以就要用到上面講過的java配置方式。在SpringBoot官方文檔中有這么一段說明：

如果你想要保持Spring Boot的一些默認MVC特征，同時又想自定義一些MVC配置（包括：攔截器，格式化器, 視圖控制器、消息轉換器 等等），你應該讓一個類實現WebMvcConfigurer，並且添加@Configuration注解，但是千萬不要加@EnableWebMvc解。如果你想要自定義HandlerMapping、HandlerAdapter、ExceptionResolver等組件，你可以創建一個WebMvcRegistrationsAdapter實例 來提供以上組件。

如果你想要完全自定義SpringMVC，不保留SpringBoot提供的一切特征，你可以自己定義類並且添加@Configuration注解和@EnableWebMvc注解。

package cn.bjut.interceptor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 自定義攔截器XXXInterceptor implements HandlerInterceptor{}
public class LoginInterceptor implements HandlerInterceptor {
    //工廠模式獲得一個Logger實例對象
    private Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        logger.debug("preHandle method is now running!");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        logger.debug("postHandle method is now running!");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        logger.debug("afterCompletion method is now running!");
    }
}

然后，我們用定義配置類，注冊攔截器： 

package cn.bjut.config;

import cn.bjut.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration public class MvcConfigurer implements WebMvcConfigurer {
    /**
     * 通過@Bean注解，將我們定義的攔截器注冊到Spring容器
     * @return
     */
    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }

    /**
     * 重寫接口中的addInterceptors方法，添加自定義攔截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通過registry來注冊攔截器，通過addPathPatterns來添加攔截路徑
        registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");
    }
}

 接下來運行並查看日志：

 你會發現日志中什么都沒有，因為我們記錄的log4j級別是debug，默認是顯示info級，我們需要進行配置。

 application.properties

# 設置com.leyou包的日志級別為debug
logging.level.com.leyou=debug

 application.yml

#log4j日志輸出控制
logging:
 level:
  cn.bjut.interceptor: debug

 

---

5.2.整合jdbc和事務

spring中的jdbc連接和事務是配置中的重要一環，在SpringBoot中該如何處理呢？

答案是不需要特殊處理，我們只要找到SpringBoot提供的啟動器即可。

當然，不要忘了數據庫驅動，SpringBoot並不知道我們用的什么數據庫。

        <!-- springboot整合JDBC事務並包含HikariCP連接池的啟動器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!-- MySQL數據庫連接驅動 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
            <scope>runtime</scope>
        </dependency>

SpringBoot中通過注解來控制事務，就是我們熟知的 @Transactional

 

================================================

參考資料：

14 微服務電商【樂優商城】：day01-springboot（實踐篇）

14 微服務電商【黑馬樂優商城】：day01-springboot（Thymeleaf快速入門）

學習Spring Boot：（十五）使用Lombok來優雅的編碼

lombok踩坑與思考

end