Análise de código-fonte SpringBoot - conhecimento básico

A diferença entre SpringBoot 1.xe 2.x
Spring Boot depende do Spring e Spring Cloud depende do Spring Boot, então o lançamento do Spring Boot 2.0 oficialmente integra muitos recursos do Spring 5.0, e a versão mais recente do Spring Cloud também precisa ser lançado mais tarde. Integre o conteúdo mais recente do Spring Boot2.0.
Novos recursos do SpringBoot2

1. Com base em Java 8, o suporte a Java 9
   significa que a versão mínima do Spring Boot 2.0 é JDK8

2. 
   A programação reativa usa Spring WebFlux / WebFlux.fn para fornecer suporte de programação responsivo da Web. Webflux é uma nova estrutura funcional reativa sem bloqueio da Web que pode ser usada para construir serviços assíncronos, sem bloqueio e orientados a eventos, em termos de escalabilidade. o desempenho é muito bom, esse recurso vem do Spring5.0. O Spring Boot 2.0 também fornece configuração automática de programação reativa, como: Reactive Spring Data, Reactive Spring Security, etc.

3. Suporte a HTTP / 2 HTTP / 2 já é compatível
   com Tomcat, Undertow e Jetty

4. Suporte para Kotlin
   Apresenta o suporte para Kotlin 1.2.x e fornece uma função runApplication que permite executar aplicativos Spring Boot por meio do Kotlin idiomático.

5. A nova arquitetura do atuador A
   nova arquitetura do atuador suporta Spring MVC, WebFlux e Jersey

6. Suporte para Quartz
   Spring Boot 1.0 não oferece suporte para Quartz. Vários esquemas de integração já apareceram. Spring Boot 2.0 fornece o método de integração mais simples.

7. Segurança
   simplifica muito a configuração automática de segurança

8. Em termos de Metrics
   Metrics, Spring Boot 2 apresenta Micrometer para unificar as especificações de métricas, para que os desenvolvedores possam entender melhor e usar o módulo de métricas sem se preocupar com o armazenamento específico do docking.

9. Em termos de monitoramento,
   Spring Boot 2 aprimora a integração do Micrômetro. RabbitMQ, threads de JVM e métricas de coleta de lixo serão monitorados automaticamente pelo instrumento e controladores assíncronos também serão adicionados automaticamente ao monitoramento. Por meio da integração, o servidor InfluxDB também pode ser monitorado.

10. Em termos de
    banco de dados de dados , o HikariCP é introduzido por padrão, substituindo o pool de tomcat anterior como o pool de conexão de banco de dados subjacente. Comparado com o pool de tomcat, o HikariCP tem melhor desempenho. Em suma, melhora a velocidade de acesso do banco de dados e suporta JOOQ. Para Redis, Lettuce é introduzido por padrão, que substitui o jedis anterior como o método de link redis subjacente.

11. Thymeleaf3
    Spring Boot 2 suporta Thymeleaf 3. A melhoria de desempenho do Thymeleaf 3 em comparação com o Thymeleaf 2 não é um pouco, porque o desempenho do 2.0 não é realmente bom e também usa um novo sistema de análise de página.

12. OAuth 2.0
    também adiciona suporte para OAuth 2.0, tornando mais amigável para os desenvolvedores usarem spring-security para concluir o desenvolvimento de módulos de permissão

O conceito de design é
totalmente na forma de anotações

Ideia central

1. Pode ajudar os desenvolvedores a integrar rapidamente estruturas de terceiros (princípio: pacote de dependência Maven, inicializador)
2. Remova a configuração xml e use anotações (princípio: anotações integradas no sistema Spring)
3. Não há necessidade de Tomcat externo, implementação de servidor interno (princípio: a linguagem Java suporta a criação de um servidor Tomcat e, em seguida, o arquivo de classe local é entregue ao tomcat para carregamento)

Vamos primeiro entender como escrever à mão com o servidor Tomcat integrado. (SpringMVC + Tomcat annotation start)
Vamos criar um projeto SpringBoot primeiro, encontrar a dependência maven de spring-boot-starter-web entre eles, podemos clicar nele para ver se

há um starter sobre o tomcat. Vamos dar uma olhada na configuração

que foi introduzida no interior. Haverá um pacote básico desse tipo. Então, também podemos apresentar este pacote básico.
Antes de iniciar manualmente o tomcat, precisamos configurar o formulário de anotação para iniciar o MVC.Como mencionado no SpringMVC conhecimento básico de análise de código-fonte (2) , não vou repeti-lo aqui. Vá diretamente para o código.

Código do projeto de inicialização de anotação SpringMVC + Tomcat: SpringMVC_Tomcat
SpringMVCConfig.java

package com.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

/**
 * @author 龙小虬
 * @date 2021/3/20 17:31
 */
@Configuration
@EnableWebMvc
@ComponentScan("com.controller")
public class SpringMVCConfig {
    
    

}

MyWebApplicationInitializer.java

package com.initializer;

import com.config.SpringMVCConfig;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

/**
 * @author 龙小虬
 * @date 2021/3/20 17:34
 */
public class MyWebApplicationInitializer  implements WebApplicationInitializer {
    
    

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
    
    
        AnnotationConfigWebApplicationContext annotationConfigWebApplicationContext = new AnnotationConfigWebApplicationContext();
        annotationConfigWebApplicationContext.register(SpringMVCConfig.class);
        DispatcherServlet dispatcherServlet = new DispatcherServlet(annotationConfigWebApplicationContext);
        ServletRegistration.Dynamic dynamic = servletContext.addServlet("dispatcherServlet", dispatcherServlet);
        dynamic.addMapping("/");
        dynamic.setLoadOnStartup(1);
    }

Escreva um controlador para acessar
MyController.java

package com.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 龙小虬
 * @date 2021/3/20 17:44
 */
@RestController
public class MyController {
    
    

    @RequestMapping("/test")
    public String test(){
    
    
        return "tesat";
    }
}

Agora vamos começar a configurar o tomcat para
criar Application.java e escrever a função principal

package com;

import org.apache.catalina.LifecycleException;
import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.webresources.DirResourceSet;
import org.apache.catalina.webresources.StandardRoot;

import java.io.File;

/**
 * @author 龙小虬
 * @date 2021/3/20 18:20
 */
public class Application {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //创建Tomcat服务器
        Tomcat tomcatServer = new Tomcat();
        //指定端口号
        tomcatServer.setPort(8080);
        //读取项目路径
        StandardContext ctx = (StandardContext) tomcatServer.addWebapp("/", new File("src/main").getAbsolutePath());
        //禁止重新载入
        ctx.setReloadable(false);
        //class文件读取地址
        File additionWebInfClasses = new File("target/classes");
        //创建webroot
        WebResourceRoot resources = new StandardRoot(ctx);
        //tomcat内部读取class执行
        resources.addPreResources(new DirResourceSet(resources, "/target/classes", additionWebInfClasses.getAbsolutePath(), "/"));
        tomcatServer.start();
        //异步等待请求执行
        tomcatServer.getServer().await();
    }
}

As notas estão todas acima, só precisamos entender.
Execute, você verá que o seguinte erro
provavelmente significa que jsp não é suportado, então nós adicionamos diretamente a configuração no pom

<!-- Tomcat对jsp支持 -->
 <dependency>
   <groupId>org.apache.tomcat</groupId>
   <artifactId>tomcat-jasper</artifactId>
   <version>8.5.16</version>
 </dependency>

Basta executá-lo novamente.

Você pode ver esta pasta, que são os dados de execução do tomcat.

Bem, entendemos como o método Springboot embutido no tomcat, vamos dar uma olhada novamente, como integrar rapidamente estruturas de terceiros, ou seja, starter personalizado.
Antes de personalizar o starter, deixe-me falar sobre as regras de personalização do starter. Na convenção de nomenclatura, spring-boot-starter-XXX é o starter oficial definido pelo SpringBoot. Se XXX-spring-boot-starter for o starter definido por um terceiro , não é oficial de. Por exemplo, starte of mybatis

agora nos permite definir um
endereço de projeto token-redis-spring-boot-starter : token-redis-spring-boot-starter para
criar um projeto SpringBoot. E introduza a configuração do pom

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

Criar TokenProperties.java

package com.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author 龙小虬
 * @date 2021/3/20 18:32
 */
@ConfigurationProperties(prefix = "lxq")
public class TokenProperties {
    
    
    private String host;
    private String pwd;

    public String getHost() {
    
    
        return host;
    }

    public void setHost(String host) {
    
    
        this.host = host;
    }

    public String getPwd() {
    
    
        return pwd;
    }

    public void setPwd(String pwd) {
    
    
        this.pwd = pwd;
    }

    @Override
    public String toString() {
    
    
        return "TokenProperties{" +
                "host='" + host + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

TokenService.java

package com.service;

import com.properties.TokenProperties;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author 龙小虬
 * @date 2021/3/20 18:36
 */
public class TokenService {
    
    

    @Autowired
    TokenProperties tokenProperties;

    public String getToken(){
    
    
        return "result:" + tokenProperties.toString();
    }
}

TokenAutoConfiguration.java

package com.config;

import com.properties.TokenProperties;
import com.service.TokenService;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 龙小虬
 * @date 2021/3/20 18:34
 */
@EnableConfigurationProperties(TokenProperties.class)
@Configuration
public class TokenAutoConfiguration {
    
    

    @Bean
    public TokenService tokenService(){
    
    
        return new TokenService();
    }
}

Depois de escrever, você encontrará
esse aviso. Ele provavelmente quer dizer que nenhum processador foi encontrado e que esse processador é usado para avisar em application.yml. Apresentamos esta configuração

<!--  能够给开发者引入该jar包后 有一定提示 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
</dependency>

Seu papel é semelhante a
este prompt.
Depois de resolver esse prompt, também precisamos configurar um EnableAutoConfiguration para

adicionar dadosorg.springframework.boot.autoconfigure.EnableAutoConfiguration=com.config.TokenAutoConfiguration

Com base nisso, terminamos de escrever um iniciador personalizado.
Vá para este projeto a partir da janela de comando e execute o comando mvn clean install.
Se ele avisar que o comando mvn não pode ser encontrado , temos que encontrar nossa própria pasta maven, configurar variáveis ​​globais e configurar o diretório bin do maven na variável de ambiente path Isso

pode ser resolvido.
Agora podemos apresentar e

criar novos projetos diretamente . Importar e usar.

Compreensão inicial da inicialização do SpringBoot Quando
usarmos o SpringBoot, usaremos @SpringBootApplicationesta anotação. Entre e veja.

Vamos dar uma olhada. Se @SpringBootConfiguration

não vemos nada de especial, existe um @Configuration. Por que @SpringBootConfigurationdeveríamos embalá-lo na China?
Na verdade, é apenas para facilitar a adição de pacotes jar de terceiros no principal e gerenciá-los.