三天講透SpringBoot-初識基礎使用

　　這次我們來說一下我們的SpringBoot，現在SpringBoot已經成為趨勢，在我這里我用三篇文章的形式來講清楚我們的SpringBoot，大致分為，第一篇講搭建，基本使用，第二篇三方集成，自動裝配原理，第三篇，將main方法啟動原理，總結史上最全的SpringBoot注解及其含義。后面有機會再細致的扒一下源碼（書還沒看完，怕誤導大家）。

　　我們先來看我們的搭建，很簡單，我們來一個最小最簡潔的啟動方式。

三種搭建（一）：

　　准備工作，我們是在IntelliJ IDEA的工具上來講解的，用Eclipse或者STS的都可以，大同小異，我們講三種搭建方式，以后就別某度SpringBoot的搭建了。

　　1.我們先來創建一個maven項目，最簡單的方式創建即可

 輸入我們的GroupID和ArtifactID

 

 點擊我們的Finish，我們的第一步就完成了。

 自己對比一下創建完成的目錄結構是不是一致的。

　　2.接下來我們導入我們的jar依賴，修改我們的pom.xml

<?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>com.springboot_xiaocai</groupId>
    <artifactId>springboot_xiaocai</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 加入springboot依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.7.RELEASE</version>
        </dependency>

        <!-- 加入spring mvc-web依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 引入一個springboot插件,可以支持我們將web應用打成jar包-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

所有加粗字體為我后來加的，你也可以全部復制到你的pom.xml文件下（注意項目名）。

　　3.加入我們的配置文件yml，在resources目錄下創建application.yml，不創建也可以

application.yml

server:
  port: 8888

　　4.寫入我們的啟動類，MainStart.java

MainStart.java 

package com.springboot_xiaocai.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MainStart {

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

}

　　5.隨便編寫一個Controller測試類，運行main方法，走起。（貼圖帶目錄結構，自己對比一下自己的對不對）

 

我們的第一種簡單搭建就完成了。配置比較麻煩，不建議這樣搭建，我們來看第二種搭建方式

三種搭建（二）： 

　　1.我們還是來構建一個項目，這里選擇Spring Initializr

 　　2.輸入參數，點擊next

 　　3.選擇Web，勾選Spring Web，點擊next（有的版本可能沒有Spring Web，那你就勾選Spring Web Starter），最上方可以設置spring boot的版本，我這里是2.1.9。

　　4.隨便編寫一個測試類，啟動，看效果。

 三種搭建（三）：

 　　第三種幾乎沒人用的，不是很方便，我只是帶着說一下，直接登錄https://start.spring.io/ 然后設置相關參數，點擊Generate就會生成我們想要的SpringBoot項目了。

上述三種方式，第二種是最好用，也是最常用的，我們只需要記住第二種就可以了。

 配置文件：

　　有的小伙伴看到我的前兩種搭建方式配置文件並不一樣，一種是application.yml，另外一種是application.properties，這兩種配置文件都是可以的，官方推薦我們使用application.yml文件，我可以不接受他的意見，按照個人喜好來咯。

　　我們很多時候我們的生產環境和我們的開發環境的配置是完全不一致的，我們可以這樣來設置

application.yml

spring:
  profiles:
    active: pro
---
spring:
  profiles: dev
server:
  port: 1111
---
spring:
  profiles: pro
server:
  port: 2222

意思就是我們激活pro的配置，下面用三個減號來設置多文檔塊。

　　貌似這樣的設置還不是特別好，我們再來改一下。將application.yml復制多份，分別叫application-dev.yml和application-pro.yml

 

application-pro.yml

server:
  port: 2222

這樣我們就更好的區分了，我們的配置環境，但貌似還不是很好的，我們的主配置是激活我們的pro配置，不能每次我們開發都設置激活我們的開發環境，然后部署的時候再改為激活生產環境吧。我們再來改一下。

　　我們保持application.yml配置不動，還是激活我們的Pro配置文件，我們來設置一下我們的啟動參數

 選擇我們的主啟動類，將我們的啟動參數-Dspring.profiles.active=dev配置進去，如果要激活多個可以用|連接，例如-Dspring.profiles.active=dev|pro|st

這樣配置，我們再啟動的時候就管你application.yml配置的激活什么配置，也是不起作用的，只有在我們的編輯器內部配置的參數才是生效的。

JAR與WAR

　　我們都知道SpringBoot打包出來的都是jar包，我們有時候不得不弄成war包的，比如遇到使用jsp的情況。

首先我們改一下我們的pom文件，設置成<packaging>war</packaging>

 再來一下spring-boot-starter設置為provided

 

 最后一步，改我們的啟動類，繼承SpringBootServletInitializer類，重寫configure方法。

package com.springboot_xiaocaijishu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class SpringbootXiaocaijishuApplication extends SpringBootServletInitializer {

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

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootXiaocaijishuApplication.class);
    }

}

打包，配置Tomcat，啟動，進入測試類，走起。

 

 這里帶兩個別的知識，不屬於本節的SpringBoot的。

我們嫌棄包的名字太長，不方便，我們可以在<build>標簽下設置<finalName>來指定我們的war包名。

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
    <finalName>xiaocaijishu</finalName>
</build>

讀取配置文件：

 　　有時候我們需要讀取配置文件的數據，比如自動任務開關，還有一些靜態的參數配置，我們可以這樣來寫

假設我們要讀取application.yml的person數據。

先來改我們的pom文件。添加依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

編寫接收參數對象，在上面給予@ConfigurationProperties(prefix = "person")注解，prefix的值就是我們配置文件外層節點的值。

package com.springboot_xiaocaijishu.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.List;
import java.util.Map;

@ConfigurationProperties(prefix = "person")
public class PersonBean {

    private String name;
    private int age;
    private Map<String, Object> address;
    private List<String> hobbit;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Map<String, Object> getAddress() {
        return address;
    }

    public void setAddress(Map<String, Object> address) {
        this.address = address;
    }

    public List<String> getHobbit() {
        return hobbit;
    }

    public void setHobbit(List<String> hobbit) {
        this.hobbit = hobbit;
    }


}

編寫我們的測試類

package com.springboot_xiaocaijishu.controller;

import com.springboot_xiaocaijishu.bean.PersonBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableConfigurationProperties(PersonBean.class)
public class UserController {

    @Autowired
    private PersonBean personBean;

    @GetMapping("getPerson")
    public PersonBean getPersonBean(){
        return personBean;
    }

}

測試走起，看結果。

 SelectCompent：（Select過濾器）

　　以前我們的項目都有web.xml來配置我們的Servlet，現在沒有了，我們來看一下配置，我們先創建一個ServletConifg類

ServletConifg類

package com.springboot_xiaocaijishu.servlet;

import com.springboot_xiaocaijishu.controller.ServletController;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ServletConifg{

    @Bean
    public ServletRegistrationBean addServlet() {
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new ServletController(),"/hello_servlet");
        return servletRegistrationBean;
    }
}

編寫一個ServletController類

package com.springboot_xiaocaijishu.controller;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class ServletController extends HttpServlet {

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("hello Servlet");
    }

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
}

這時我們啟動項目，訪問http://localhost:8080/hello_servlet就可以跳轉到我們的Servlet下，有了Servlet，我們來添加過濾器吧。添加一個CustomFilter類。

CustomFilter類

package com.springboot_xiaocaijishu.CustomFilter;

import javax.servlet.*;
import java.io.IOException;

public class CustomFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("CustomFilter的doFilter方法");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

將我們我Filter注冊到Servlet中去，回到我們的ServletConifg類中，添加這樣的代碼。

/**
 * 注冊一個filter
 * @return
 */
@Bean
public FilterRegistrationBean<CustomFilter> filterFilterRegistrationBean() {
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    filterRegistrationBean.setFilter(new CustomFilter());
    filterRegistrationBean.addUrlPatterns("/*");
    return filterRegistrationBean;
}

攔截器：

　　定義一個CustomInterceptor類，實現HandlerInterceptor類。后期我會說下HandlerInterceptor類內部的源碼。

package com.springboot_xiaocaijishu.CustomInterceptor;

import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class CustomInterceptor implements HandlerInterceptor {

    /**
     * 方法執行之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        System.out.println("preHandle");
        return true;
    }

    /**
     * 調用目標方法之后,渲染視圖之前
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");

    }

    /**
     * 渲染視圖之后
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

添加WebConifg類，注冊我們的攔截器

package com.springboot_xiaocaijishu.servlet;

import com.springboot_xiaocaijishu.CustomInterceptor.CustomInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
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 WebConifg implements WebMvcConfigurer {

    @Autowired
    private CustomInterceptor CustomInterceptor;

    /**
     * 注冊攔截器
     * @param registry
     */
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(CustomInterceptor).addPathPatterns("/**").excludePathPatterns("/login","/");
    }
}

東西實在太多了，有點弄不完了，代碼還忘記保留了，下次我一起傳代碼吧，下次說一下我們繼承那些三方插件吧~！ 

 

最進弄了一個公眾號，小菜技術，歡迎大家的加入