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

時間 2019-11-12

原文原文鏈接

　　此次咱們來講一下咱們的SpringBoot，如今SpringBoot已經成爲趨勢，在我這裏我用三篇文章的形式來說清楚咱們的SpringBoot，大體分爲，第一篇講搭建，基本使用，第二篇三方集成，自動裝配原理，第三篇，將main方法啓動原理，總結史上最全的SpringBoot註解及其含義。後面有機會再細緻的扒一下源碼（書還沒看完，怕誤導你們）。java

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

三種搭建（一）：spring

　　準備工做，咱們是在IntelliJ IDEA的工具上來說解的，用Eclipse或者STS的均可以，大同小異，咱們講三種搭建方式，之後就別某度SpringBoot的搭建了。apache

　　1.咱們先來建立一個maven項目，最簡單的方式建立便可springboot

輸入咱們的GroupID和ArtifactIDmvc

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

本身對比一下建立完成的目錄結構是否是一致的。jsp

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

<?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;
    }


}

View Code

編寫咱們的測試類

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","/");
    }
}