Guía de uso del marco Spring Boot

Language 2023-07-21 07:33:37 views: null

descripción general

Sitio web oficial de Spring: https://spring.io/projects

Spring Boot es un marco completamente nuevo creado sobre la base del marco Spring. Es un subproyecto en el proyecto Spring y pertenece a productos Spring como Spring-framework.

Spring Boot se denomina andamiaje para la creación de programas. Su función principal es crear rápidamente un gran proyecto de Spring y reducir todas las configuraciones xml tanto como sea posible, de modo que se pueda usar de forma inmediata y comenzar rápidamente, lo que permite a los desarrolladores centrarse en el negocio en lugar de la configuración.

Spring Boot simplifica el desarrollo de aplicaciones basadas en Spring y proporciona configuraciones listas para usar para la plataforma Spring y bibliotecas de terceros (proporciona configuraciones predeterminadas y el paquete que almacena la configuración predeterminada es el iniciador). La mayoría de las aplicaciones Spring Boot solo necesitan una pequeña cantidad de configuración de Spring. Spring Boot tiene Tomcat incorporado, por lo que no es necesario configurar Tomcat por separado.

El propósito del diseño Spring Boot es simplificar el proceso de construcción y desarrollo de las aplicaciones Spring. No solo tiene todas las características excelentes de Spring, sino que también tiene las siguientes características notables:

  • Proporcione un uso más fácil y habilidades de desarrollo rápido para el desarrollo de Spring
  • Con la función de configuración predeterminada lista para usar, se puede configurar automáticamente de acuerdo con las dependencias del proyecto
  • Tiene un sistema de servicio más potente, que incluye servicios integrados, seguridad, indicadores de rendimiento, controles de salud, etc.
  • Absolutamente sin generación de código, ya no se requiere configuración XML, lo que hace que la aplicación sea más liviana y flexible
  • Spring Boot proporciona una integración perfecta para el uso de algunas tecnologías de terceros y es fácil de usar.

Construcción del proyecto SpringBoot

Introducción a la dependencia básica

Lista de versiones del sitio web oficial de Spring Boot: https://spring.io/projects/spring-boot#learn

  • VERSIÓN GA: Disponibilidad general, la versión lanzada oficialmente, recomendada oficialmente para usar esta versión.
  • INSTANTÁNEA: versión instantánea, que se puede usar de manera estable y aún se está mejorando.
  • PRE: versión de vista previa, versión beta interna, principalmente para desarrolladores y probadores para probar y encontrar errores, no se recomienda su uso.
<?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.test</groupId>
    <artifactId>spring-boot-ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 使用SpringBoot框架必须引入 spring-boot-starter-parent 作为父项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
    </parent>
    
    <properties>
        <!-- 设置JDK版本 -->
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <!-- web启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 单元测试启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!---- 数据库相关 ---->
        <!-- jdbc启动器，spring-boot-starter-jdbc默认集成了HikariCP连接池 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- druid连接池启动器 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.17</version>
        </dependency>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- 持久层框架启动器 -->

        
        <!---- 工具类 ---->
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

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

clase de inicio

Aplicación.java

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

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

Configuración de Spring Boot

Anotaciones para la configuración con resorte

  • @Configuration : declarar una clase como una clase de configuración en lugar de un archivo xml

  • **@Bean **: declarar en el método, agregar el valor de retorno del método al contenedor Bean en lugar de <bean>la etiqueta

  • @Value : inyección de atributo, en lugar de inyección de atributo en xml

    Formato: @Valor("${propiedad}")

  • @PropertySource : carga el archivo de propiedades especificado (*.properties) en el entorno de Spring

    Se puede usar con @Value y @ConfigurationProperties

    • Combinación de @PropertySource y @Value:

      Puede inyectar el valor de la variable de propiedad en el archivo de propiedad personalizado en la variable miembro anotada con @Value de la clase actual.

    • Combinación de @PropertySource y @ConfigurationProperties:

      El archivo de propiedades se puede vincular a una clase Java y los valores de las variables en el archivo de propiedades se pueden inyectar en las variables miembro de la clase Java.

@ConfigurationProperties: enlaces de configuración automática

@ConfigurationProperties : se utiliza para configurar automáticamente las propiedades del archivo de configuración yml vinculante y las propiedades del objeto Java

Atributos de soporte:

  • atributo de valor/prefijo: prefijo del elemento de configuración del archivo de configuración
  • Atributo ignoreInvalidFields: el valor predeterminado es falso, si el tipo de valor no coincide, se lanzará una excepción
  • Atributo ignoreUnknownFields: el valor predeterminado es verdadero, ignorando los campos desconocidos en el objeto

Uso 1 : marca en la clase, convierte los elementos de configuración del archivo de configuración en objetos de frijol

  • Aviso:
    • Las clases anotadas con @ConfigurationProperties deben registrarse en el contenedor de primavera de dos maneras:
      • Método 1: use @componet y otras anotaciones IOC en clases marcadas con anotaciones @ConfigurationProperties
      • Método 2: marque @EnableConfigurationProperties(bean class name.class) en la clase marcada con anotaciones IOC como @componet o en la clase de configuración
    • Requiere métodos constructor, getter y setter sin argumentos
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "app.mycar")
public class Car {
    
    
    private int price;
    private String brand;
}

@Configuration
@EnableConfigurationProperties(Car.class) 
public class Config {
    
    
}

Uso 2 : marque el método de la clase de configuración, utilícelo con @bean y vincule propiedades de terceros

@Configuration
public class DbConfig {
    
    
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSource datasource(){
    
    
        return new DruidDataSource();
    }
}

Entorno: obtener variables de entorno en ejecución

El Environment en Spring se utiliza para representar el entorno de tiempo de ejecución de toda la aplicación. Puede utilizar la clase Environment para obtener información de configuración en todo el entorno de tiempo de ejecución.

método:

public String getProperty(String key)
public <T> T getProperty(String key, Class<T> targetType)
    
// 注：key为配置文件中的key

Ejemplo:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

@Configuration  // 声明这个类是一个配置类
@PropertySource(value = "classpath:user.properties") //加载配置文件
public class UserConfig {
    
    
    @Autowired
    private Environment environment;
    
    @Bean   //创建User对象，交给spring容器 User对象中的值从配置文件中获取
    public User getUser() {
    
    
        User user = new User();
        user.setUsername(environment.getProperty("user.username"));
        user.setPassword(environment.getProperty("user.password"));
        return user;
    }
}

Prioridades y tipos de perfil admitidos

  • aplicación.propiedades
  • aplicación.yml
  • aplicación.yaml

La prioridad de los archivos de configuración que se cargan es:

  • propiedades > yml > yaml

  • Si se configura la misma configuración en varios tipos de archivos de configuración, tendrá efecto la configuración con mayor prioridad.

Configuración por defecto y configuración básica común

Spring Boot encapsula una gran cantidad de configuraciones predeterminadas:

  • Directorio de documentos de cada versión de Spring boot: https://docs.spring.io/spring-boot/docs/

  • La lista de configuración predeterminada de la versión SpringBoot 2.3.0.RELEASE (otras versiones son similares):

    https://docs.spring.io/spring-boot/docs/2.3.0.RELEASE/reference/html/appendix-application-properties.html

Configuración básica común de Spring Boot:

server:
  # 服务端口号，默认8080
  port: 8080

logging:
  level:
    # 微服务的日志配置。格式：包路径: 日志级别
    com.test: debug

spring:
  application:
    name: test-service
  datasource:     # 数据源配置
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/leyou?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource

Configuración Spring MVC

configuración del puerto

Establecer puerto de acceso web

server:
 port: 8080

configuración de registro

Los niveles de registro se dividen en niveles FATAL, ERROR, WARN, INFO, DEBUG, ALL o definidos por el usuario.

Log4j recomienda usar solo cuatro niveles, la prioridad de mayor a menor es ERROR, WARN, INFO, DEBUG

  • En el entorno de producción de una empresa, generalmente se establece en el nivel INFO, lo que significa que los registros del nivel INFO y superior se imprimen, y los registros del nivel DEBUG y por debajo no se imprimen

  • Entorno de desarrollo y prueba, generalmente establecido en el nivel DEBUG, lo que significa que se pueden generar todos los niveles de registros

Control de nivel de registro:

logging:
  level:
    com.test: debug
    org.springframework.web: debug

ilustrar:

  • logging.level: método de escritura fijo, lo que indica que la siguiente es la configuración de nivel de registro, y también se pueden usar otras configuraciones relacionadas con el registro
  • com.test y org.springframework son los nombres de paquete especificados, y la configuración posterior solo es válida para este paquete

recursos estáticos

La ruta de recursos estática predeterminada es:

  • classpath:/META-INF/recursos/
  • classpath:/recursos/
  • classpath:/estático/
  • ruta de clase:/público

Siempre que los recursos estáticos se coloquen en cualquiera de estos directorios, SpringMVC los manejará.

Generalmente, los recursos estáticos se colocan classpath:/static/en el directorio.

interceptador

  • Si desea mantener algunas de las características predeterminadas de MVC de Spring Boot, pero también desea personalizar algunas configuraciones de MVC (incluidos: interceptores, formateadores, controladores de vista, convertidores de mensajes, etc.), puede hacer que una clase implemente la interfaz y agregue anotaciones, pero no WebMvcConfigurerpuede @Configurationagregar @EnableWebMvcanotaciones

  • Si desea personalizar HandlerMapping, y otros componentes, puede crear una HandlerAdapterinstancia para proporcionar los componentes anterioresExceptionResolverWebMvcRegistrationsAdapter

  • Si desea personalizar Spring MVC por completo sin conservar todas las funciones proporcionadas por Spring Boot, puede definir sus propias clases y agregar @Configurationanotaciones y @EnableWebMvcanotaciones .

  1. Interceptor personalizado (implementa la interfaz HandlerInterceptor)
@Slf4j
public class MyInterceptor implements HandlerInterceptor {
    
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        log.debug("preHandle方法执行...");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
    
        log.debug("postHandle方法执行...");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        log.debug("afterCompletion方法执行...");
    }
}
  1. Agregar clase de configuración (implementar la interfaz WebMvcConfigurer), interceptor de registro
@Configuration
public class MyWebConfig implements WebMvcConfigurer {
    
    
    /**
     * 注册自定义拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    
    
        // 通过registry来注册拦截器，通过addPathPatterns来添加拦截路径
        registry.addInterceptor(new MyInterceptor())
                .addPathPatterns("/user/**")
                .excludePathPatterns("/user/login");  // 这个地址的不拦截
    }
}

Interfaz de ApplicationRunner

  • método:

    Solo se define un método de ejecución (ApplicationArguments args)

    El parámetro ApplicationArguments del método run puede obtener los parámetros de comando de la ejecución del proyecto actual (por ejemplo, cuando el proyecto se ejecuta como un jar, los parámetros se pueden obtener a través de ApplicationArguments).

    Dado que este método se ejecuta después de que se inicia el contenedor, también se pueden obtener otros frijoles inyectados del contenedor de resorte.

  • Escenas a utilizar:

    Cuando se inicia el proyecto springBoot, si desea ejecutar una determinada pieza de código directamente después del inicio, puede personalizar una clase para implementar la interfaz ApplicationRunner y reescribir el método de ejecución de la interfaz.

@Component  // 此类必须要交给spring管理才生效
public class ConsumerRunner implements Application{
    
    
	@Oberride
	public void run(ApplicationArgumers args) throws Exception{
    
    
		//代码
		System.out.println("需要在springBoot项目启动时执行的代码---");
	}
}

  • En el mismo proyecto, se pueden definir varias clases de implementación de ApplicationRunner.

    Si hay varias clases de implementación y deben ejecutarse en un orden determinado al mismo tiempo, se puede lograr agregando la anotación @Order a la clase de implementación o implementando la interfaz ordenada .

    SpringBoot se ejecutará de acuerdo con el valor del valor en @Order de menor a mayor. Es decir, cuanto menor sea el valor, mayor será la prioridad, y cuanto menor sea el valor, el primero en cargarse.

    Nota: Los valores pueden ser negativos.

Principio de configuración automática

descripción general

Spring Boot integra una gran cantidad de servicios de terceros internamente, proporciona una configuración predeterminada y los pasos para que la configuración predeterminada surta efecto:

  • La anotación @EnableAutoConfiguration irá a todos los paquetes para encontrar los archivos META-INF/spring.factories y leerá los nombres de todas las clases con EnableAutoConfiguration como clave. Estas clases son clases de configuración automática escritas de antemano.
  • Todas estas clases declaran la anotación @Configuration y configuran todas las instancias requeridas por adelantado a través de la anotación @Bean
  • Sin embargo, estas configuraciones no necesariamente surten efecto, ya que existen anotaciones @Conditional, que solo surtirán efecto cuando se cumplan ciertas condiciones.
  • Solo es necesario introducir las dependencias pertinentes (arrancadores), se cumplen las condiciones requeridas por la configuración anterior y entra en vigor la configuración automática.
  • Si configura beans relacionados usted mismo, anulará los beans configurados automáticamente por defecto
  • También puede anular las propiedades en la configuración automática configurando el archivo application.properties(yml)

La razón por la que Spring Boot se puede desarrollar rápidamente es que hay muchas configuraciones predeterminadas integradas de componentes de terceros. Los pasos son los siguientes:

  1. usar lanzador

    Si no desea configurarlo usted mismo, solo necesita introducir la dependencia de inicio, y no tiene que preocuparse por la versión de la dependencia, porque siempre que se introduzca el stater (iniciador) proporcionado por Spring Boot, la dependencia y la versión se administrarán automáticamente.

  2. Reemplazar la configuración predeterminada

    La configuración de SpringBoot tendrá propiedades predeterminadas y estas propiedades se pueden anular modificando el archivo application.properties.

Notas clave

@Condicional

@Condition es una función de juicio de condición agregada en Spring 4.0 A través de esta función, se puede realizar la creación selectiva de operaciones Bean.

@Condicional está marcado en la clase de configuración o en el método de la clase de configuración. Se usa junto con @Configuración. Cuando se cumplen las condiciones especificadas por @Condicional, el contenido de la clase de configuración tendrá efecto.

Anotaciones de condiciones comunes de SpringBoot:

  • @ConditionalOnBean : el Bean especificado existe en el contenedor
  • @ConditionalOnMissingBean : el bean especificado no existe en el contenedor
  • @ConditionalOnProperty : si la propiedad especificada en el sistema tiene el valor especificado
  • @ConditionalOnClass : hay una clase específica en el sistema
  • @ConditionalOnMissingClass: la clase especificada no existe en el sistema
  • @ConditionalOnExpression: satisface la especificación de la expresión SpEL
  • @ConditionalOnSingleCandidate: solo hay un bean especificado en el contenedor, o este bean es el bean preferido
  • @ConditionalOnResource: si el archivo de recursos especificado existe en la ruta de clases
  • @ConditionalOnWebApplication: el entorno web actual
  • @ConditionalOnNotWebApplication: actualmente no es un entorno web
  • @ConditionalOnJava: si la versión Java del sistema cumple con los requisitos

Ejemplo:

clase de usuario

@Data
public class User {
    
    
    private String username;
    private Integer age;
}

clase de configuración

@Configuration
@ConditionalOnProperty(value = "user.enable")	// 配置文件存在该配置项时该配置类才生效
public class UserConfig {
    
    
    @Bean
    public User user(){
    
    
        User user = new User();
        user.setUsername("tom");
        user.setAge(18);
        return user;
    }
}

Agregue la siguiente configuración al archivo de configuración:

user:
  enable: true

Agregar caso de prueba

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTests {
    
    
    
    @Autowired
    private User user;
    @Test
    public void testUser(){
    
    
        System.out.println(user);
    }
}

Diagrama de flujo de configuración automática de SpringBoot

inserte la descripción de la imagen aquí

Al usarlo, solo necesita introducir el iniciador correspondiente. El iniciador es una señal indicadora. Después de introducir la dependencia, el bean correspondiente se registrará cuando se cumplan las condiciones correspondientes.

@Importar

referencia:

  • https://blog.csdn.net/weixin_44360895/article/details/112758122
  • https://blog.csdn.net/mamamalululu00000000/article/details/86711079

Anotación @Import : importa la clase en el contenedor Spring IOC

Hay muchas formas de agregar clase a la gestión de contenedores IOC, como @Bean, @Component, etc. @Import es otra forma, que es más rápida.

Se admiten tres métodos:

  • Clases de configuración con @Configuration (solo las clases de configuración se pueden importar antes de la versión 4.2 y las clases ordinarias también se pueden importar después de la versión 4.2)
  • Implementación de ImportSelector
  • Implementación de ImportBeanDefinitionRegistrar

Uso principal:

  • Rellene la matriz de clase directamente

    @Configuration
@Import({
      
      User.class})   // 大括号中可以添加多个类，使用逗号分隔，例如 {User.class,UserInfo.class}
public class UserConfig {
      
      }

  • Método ImportSelector (la capa inferior de Spring Boot usa muchos métodos)

    // 自定义ImportSelector
public class MyImportSelector implements ImportSelector {
      
      
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
      
      
        // 返回的是需要加载的类名数组  注意这里需要的是类的全路径
        return new String[]{
      
      "com.itheima.redis.entity.User"};
    }
}

    @Configuration
@Import(MyImportSelector.class)
public class UserConfig {
      
      }

  • Método ImportBeanDefinitionRegistrar

    Este método es similar al método ImportSelector, pero este método puede personalizar el nombre del Bean en el contenedor

    // 自定义ImportBeanDefinitionRegistrar
public class TestImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
      
      
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
      
      
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TestD.class);
        //自定义注册bean
        registry.registerBeanDefinition("testD1111",rootBeanDefinition);
    }
}

    @Import({
      
      TestImportBeanDefinitionRegistrar.class})
@Configuration
public class ImportConfig {
      
      }
  • Nota: Los tres métodos de uso se pueden usar en una @Importación. Debe tenerse en cuenta que en el método de matriz de clase y el método ImportSelector, el nombre del bean en el contenedor IOC es el nombre de clase completo de la clase, mientras que el método ImportBeanDefinitionRegistrar es un nombre personalizado

@SpringBootApplication

diagrama de flujo

inserte la descripción de la imagen aquí

ver código fuente

inserte la descripción de la imagen aquí

Hay 3 notas clave:

  • @SpringBootConfiguration
  • @EnableAutoConfiguration
  • @ComponentScan

@SpringBootConfiguration

código fuente:

@Target({
    
    ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    
    
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

Hay una anotación @Configuration en esta anotación. La función de la anotación @Configuration es declarar que la clase actual es una clase de configuración, y luego Spring escaneará automáticamente a la clase con @Configuration agregado y leerá la información de configuración en ella.

@SpringBootConfiguration es declarar que la clase actual es la clase de configuración de la aplicación SpringBoot.

@EnableAutoConfiguration

código fuente:

@Target({
    
    ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({
    
    AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    
    
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {
    
    };

    String[] excludeName() default {
    
    };
}

Con ayuda @Import(AutoConfigurationImportSelector.class), @EnableAutoConfigurationpuede ayudar a las aplicaciones Spring Boot a cargar todas @Configurationlas configuraciones elegibles en el contenedor IOC creado y utilizado por Spring Boot actual.

  1. AutoConfigurationImportSelectorCódigo fuente, ver selectImportsmétodo:

    inserte la descripción de la imagen aquí

  2. Continúe con el seguimiento del método getAutoConfigurationEntry

    inserte la descripción de la imagen aquí

  3. getCandidateConfigurationsHay una pista en el método :

    inserte la descripción de la imagen aquí

  4. Método de seguimiento loadFactoryNames:

    inserte la descripción de la imagen aquí

  5. Puede ver que la configuración se carga desde esta ubicación:

    inserte la descripción de la imagen aquí

  6. encuentra el archivo de configuración

    inserte la descripción de la imagen aquí

    Hay configuración automática aquí:

    inserte la descripción de la imagen aquí

    Una gran cantidad de clases de configuración de middleware de terceros están integradas en el paquete de configuración automática:

inserte la descripción de la imagen aquí

Resumen: @EnableAutoConfigurationbusque todos los archivos de configuración de classpath META-INF/spring.factoriesy org.springframework.boot.autoconfigure.EnableAutoConfiguration cree instancias de los elementos de configuración correspondientes en la clase de configuración del contenedor IOC correspondiente en forma de JavaConfig marcado con @Configuration a través de la reflexión, y luego resúmalos en uno y cárguelo en el contenedor IOC.

@ComponentScan

Active el escaneo de componentes. Proporciona <context:component-scan>un rol similar a la etiqueta.

Especifique los paquetes para escanear a través de las propiedades basePackageClasses o basePackages. Si no se especifican estos atributos, el paquete y los subpaquetes se escanearán a partir del paquete donde se encuentra la clase que declara esta anotación.

La clase declarada por la anotación @SpringBootApplication es la clase de inicio donde se encuentra la función principal, por lo que el paquete escaneado es el paquete donde se encuentra la clase y sus subpaquetes. Por lo tanto, la clase de inicio general se colocará en un directorio de paquetes anterior

Supervisión de SpringBoot

Solenoide

concepto

SpringBoot viene con la función de monitoreo Actuador, que puede ayudar a monitorear la operación interna del programa, como el estado de monitoreo, el estado de carga de Bean, las propiedades de configuración, la información de registro, etc.; al mismo tiempo, la aplicación también se puede administrar a través del Actuador, como una función de apagado (no está habilitada de forma predeterminada) a través del Actuador, y el registro también se puede ajustar durante el proceso de ejecución.

puntos finales: puntos finales

Los puntos finales pueden entenderse como un módulo funcional, que puede monitorear aplicaciones Spring Boot e incluso interactuar con Spring Boot (como leer información, cerrar aplicaciones, etc.). Spring Boot tiene muchos puntos finales integrados, el punto final más importante es el estado, que es el módulo de verificación de estado.

Descripción del punto final del actuador

punto final ilustrar habilitado por defecto HTTP predeterminado JMX predeterminado
eventos de auditoría Expone información de eventos de auditoría para la aplicación actual Y norte Y
frijoles Muestra información sobre frijoles del contenedor Spring loC Y norte Y
cachés mostrar caché en la aplicación Y norte Y
condiciones Muestra las condiciones de evaluación y configuración de una clase de configuración automática y muestra por qué coinciden o no. Y norte Y
accesorios de configuración Mostrar la información de configuración de propiedades del proyecto actual (configurado a través de @ConfigurationProperties) Y norte Y
env Mostrar las propiedades de configuración del entorno de la aplicación Spring actual (ConfigurableEnvironment) Y norte Y
ruta migratoria Muestra información sobre las migraciones que se han aplicado a la base de datos de rutas migratorias Y norte Y
salud Mostrar el estado de salud actual de la aplicación Y Y Y
seguimiento http Mostrar la información de seguimiento más reciente (el valor predeterminado es las últimas 100 solicitudes HTTP) Y norte Y
información Mostrar información de la aplicación actual Y Y Y
madereros Mostrar y actualizar la configuración de los registradores en la aplicación Y norte Y
base liquida Muestra información sobre las migraciones que se han aplicado a la base de datos de liquibase Y norte Y
métrica Muestra los diversos indicadores de "métricas" actualmente configurados Y norte Y
asignaciones Muestra la información de la ruta de mapeo configurada por @RequestMapping (@GetMapping y @PostMapping, etc.) Y norte Y
tareas programadas Mostrar el plan de tareas de programación aplicado actualmente Y norte Y
sesiones Permite recuperar y eliminar sesiones de usuario del repositorio de sesiones admitido por Spring Session, pero Spring Session aún no admite aplicaciones web receptivas Y norte Y
cerrar Permite que la aplicación actual se cierre correctamente (este punto final no está habilitado de forma predeterminada) norte norte Y
volcado de subprocesos Mostrar bomba de hilo Y norte Y
volcado de pila Devolver el archivo Heap Dump en formato HPROF Y norte N / A
Prometeo Devuelve información que Prometheus puede rastrear Y norte N / A

Aviso:

  • El punto final de apagado no está habilitado de forma predeterminada
  • Solo se puede acceder a la salud y la información a través de http de forma predeterminada

Inicio rápido

coordenadas dependientes

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

Si desea ver más información, configúrelo en el archivo de configuración:

management:
  endpoint:
    health:
      show-details: always
  endpoints:
    web:
      exposure:
        include: "*"

Interfaz de monitoreo del actuador:

http://localhost:8080/actuador/frijoles

http://localhost:8080/actuador/env

http://localhost:8080/actuador/asignaciones

Explicación específica y detallada:

camino describir
/ frijoles Describir todos los beans en el contexto de la aplicación y sus relaciones.
/env Obtener todas las propiedades del entorno
/env/{nombre} Obtener un valor de propiedad de entorno específico por nombre
/salud Reportar los indicadores de salud de la aplicación, estos valores son proporcionados por la clase de implementación de HealthIndicator
/info Obtenga la información personalizada de la aplicación, que es proporcionada por los atributos que comienzan con info
/asignaciones Describir todas las rutas de URI y su relación de mapeo con los controladores (incluidos los puntos finales del actuador)
/métrica Informe varias métricas de aplicaciones, como el uso de memoria y el recuento de solicitudes HTTP
/métricas/{nombre} Informa la métrica de la aplicación para el nombre especificado
/rastro Proporciona información básica de seguimiento de solicitudes HTTP (marcas de tiempo, encabezados HTTP, etc.)

Configuración detallada del actuador

management:
  server:
    # Actuator的管理端口号，默认跟服务端口号（server.port）一致
    port: 8085
  endpoint:
    health:
      # 是否开启health端点，默认为true
      enabled: true
      # 展示健康检查中所有指标的详细信息
      show-details: always
  endpoints:
    # web：http方式
    web:
      exposure:
        # 暴露可以通过web访问的端点。默认"health,info"，用 * 可以包含全部端点
        include: "*"
        # 不暴露的端点
        exclude: 
      # 自定义监控路径前缀。默认 /actuator
      base-path: /actuator
      # 修改端点的访问路径(映射)，例如将 /beans 更改为 /request_beans
      path-mapping:
        beans: request_beans
    # 所有端点是否默认启动，默认true。若设置为false，则默认情况下所有端点都不启用，此时需要按需启用端点
    enabled-by-default: true

Administrador de Spring Boot

Descripción general e inicio rápido

El contenido de monitoreo de Actuator es lo suficientemente detallado, pero la legibilidad es relativamente pobre, por lo que puede usar Spring Boot Admin para proporcionar una interfaz visual para ver información Spring Boot Admin es un proyecto comunitario de código abierto proporcionado por un tercero para administrar y monitorear aplicaciones SpringBoot.

Biblioteca de código fuente: https://github.com/codecentric/spring-boot-admin

Spring Boot Admin tiene dos roles, cliente (Cliente) y servidor (Servidor):

  • La aplicación se registra con el servidor de administración de Spring Boot como un cliente de administración de Spring Boot

  • La interfaz de Spring Boot Admin Server mostrará la información de monitoreo de Spring Boot Admin Client

Los pasos de desarrollo son los siguientes :

servidor de administración :

  1. Crear el módulo del servidor de administración

  2. Importar coordenadas de dependencia admin-starter-server

        <dependency>
        <groupId>de.codecentric</groupId>
        <artifactId>spring-boot-admin-starter-server</artifactId>
        <version>2.3.0</version>
    </dependency>

  3. Marque la anotación @EnableAdminServer en la clase de inicio para habilitar la supervisión del administrador

  4. Información relacionada con la configuración

    server:
  port: 8888

  5. Inicie el servicio del servidor, visite: http://localhost:8888/#/applications

admin-client : el proyecto creado por usted mismo es el llamado lado del cliente

  1. Crear el módulo de administrador-cliente

  2. Importar coordenadas de dependencia admin-starter-client

    <dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.3.0</version>
</dependency>

  3. Información relacionada con la configuración: dirección del servidor, etc.

    spring:
  boot:
    admin:
      client:
        url: http://localhost:8888
management:
  endpoint:
    health:
      show-details: always
  endpoints:
    web:
      exposure:
        include: "*"

  4. Iniciar el servicio de atención al cliente

Configuración detallada del servidor de administración

Referencia: https://www.jianshu.com/p/b0528b52772c

spring:
  boot:
    admin:
      # server端的访问路径。默认为 /
      context-path: /
      monitor:
        # 更新client端状态的时间间隔，默认为10000，单位是毫秒
        period: 10000
        # client端状态的生命周期，该生命周期内不会更新client状态，默认为100000，单位是毫秒
        status-lifetime: 100000
        # 查询client状态信息时的连接超时时间，默认为2000，单位是毫秒
          # 如果2秒内没有获取到client的状态信息，则认为连接已经断开
        connect-timeout: 2000
        # 查询client状态信息时的读取超时时间，默认为2000，单位是毫秒（如果2秒内没有获取到client的状态信息，则认为读取失败）
        read-timeout: 2000
      # 要被过滤掉的元数据（当与正则表达式相匹配时，这些数据会在输出的json数据中过滤掉）
        # 默认值是".password", ".secret",".∗secret", ".key", ".",".token", ".credentials.", ".*vcap_services", ".credentials.", ".∗vcap services"	
      metadata-keys-to-sanitize:
      # 要获取的client的端点信息
        # 默认是 "health", "env", "metrics", "httptrace:trace", "threaddump:dump", "jolokia", "info", "logfile", "refresh", "flyway", "liquibase", "heapdump", "loggers", "auditevents"	
      probed-endpoints: 
      instance-proxy:
        # 向client发起请求时不会被转发的headers信息。默认值是"Cookie", "Set-Cookie", "Authorization"
        ignored-headers: 
      ui:
        # 在导航栏中显示的brand值
        brand: 
        # 显示的页面标题。默认是"Spring Boot Admin"
        title:

Configuración detallada de Admin Client

Referencia: https://www.jianshu.com/p/b0528b52772c

spring:
  boot:
    admin:
      client:
        # 是否启用spring boot Admin客户端，默认为true
        enabled: true
        # 要注册的Admin Server端的url地址。如果要同时在多个server端口注册，则用逗号分隔各个server端的url地址
        url: http://localhost:8888
        # server端获取client信息的路径，默认情况下server通过访问/instances请求来获取到client端的信息。（client端向server端注册，注册成功后server端会给该client创建一个唯一的clientID值。当server端需要获取client的信息，比如health信息时，server端会发送http://IP:PORT/instances/clientID/actuator/health即可，这里的http://IP:PORT是client所在服务器的IP地址，instances就是该属性的值）
        api-path: instances
        # 如果server端需要进行认证时，该属性用于配置用户名
        username: user
        # 如果server端需要进行认证时，该属性用于配置密码
        password: 123456
        # 注册时间间隔，默认10000，单位是毫秒（client通过持续不断地向server端进行注册来保持client端与server端的连接）
        period: 10000
        # 注册连接超时时间，默认5000，单位是毫秒。当client向server进行注册时，如果5秒钟没有注册完成则认为本次注册失败
        connect-timeout: 5000
        # 注册读取超时，默认5000，单位是毫秒
        read-timeout: 5000
        # 是否开启自动注册，默认为true
        auto-registration: true
        # 是否开启自动注销，如果服务端运行在云平台，默认值是true
        auto-deregistration: null
        # 默认为true，client只会在一个server端进行注册（按照spring.boot.admin.client.url中设置的server的顺序），如果该server端宕机，会自动在下一个server端进行注册。如果该属性值为false，则会在所有的server端进行注册
        egister-once: true
        instance:
          # 注册的management-url，如果可用的url不同的话，可以重写该值。
          	# 默认该属性值与management-base-url 和 management.context-path两个属性值有关
          management-url:
          # 用于计算management-url的基本URL。该路径值在运行时进行获取并赋值给 base url
          	# 默认该属性值与management.port, service-url 以及server.servlet-path有关
          management-base-url:
          # 用于计算service-url的基本URL。该路径值在运行时进行获取并赋值给 base url
          service-base-url:
          # 注册的health-url地址，如果可用的url不同可以重写该值
          health-url:
          # 注册的service-url值
          service-url: http://192.168.0.66:22586
          # 客户端工程的名字。默认值是配置的spring.application.name的值	
          name:
          # 是否使用注册的ip地址来取代上述各个url中hostname的值，默认为false
          prefer-ip: true

Desarrolle su propio lanzador de inicio

Los arrancadores generalmente spring-boot-starter-comienzan con , que generalmente es el método de nomenclatura oficial de Spring.

Los lanzadores desarrollados por otras empresas se nombran así:XXX-boot-starter

El iniciador es generalmente un caparazón vacío sin código y se usa principalmente para administrar dependencias.

Pasos de desarrollo:

  1. Cree un proyecto inicial, ejemplo: test-hello-spring-boot-starter

  2. Cree un proyecto de configuración automática, ejemplo: test-spring-boot-autoconfigure

    • (1) Agregue dependencias básicas de Springboot (porque necesita usar anotaciones como @Bean)

      <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

    • (2) Defina la clase de configuración automática, ejemplo: defina HelloTemplate como Bean en la clase de configuración

      @Configuration
public class HelloAutoConfiguration {
        
        

    @Bean   //实例化HelloTemplate，交给Spring IOC 容器管理
    public HelloTemplate helloTemplate(){
        
        
        return new HelloTemplate();
    }
}

    • (3) Cree un directorio META-INF en recursos, cree un archivo spring.factories en el directorio META-INF y edite la clase de configuración (HelloAutoConfiguration) para escanear en spring.factories, de modo que Spring escanee HelloAutoConfiguration

      # 第一行固定写法，第二行这个是我们写的配置类的类名全路径 这样spring就能扫描到了
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.itheima.hellospringbootdemo.util.HelloAutoConfiguration

  3. Agregue las dependencias del proyecto de configuración automática al archivo pom del proyecto inicial

    <dependencies>
    <dependency>
        <groupId>com.test</groupId>
        <artifactId>test-spring-boot-autoconfigure</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

  4. Agregue las dependencias del proyecto stater en otros proyectos, y puede usar @Autowired para usar el Bean inyectado en el contenedor Spring en el proyecto de configuración automática

Implementar el proyecto SpringBoot

embalaje del proyecto

En el proyecto SpringBoot, todo se hace empaquetando el proyecto en un paquete jar y luego ejecutándolo directamente (porque Tomcat está integrado)

  1. Prepare un proyecto SpringBoot desarrollado, porque es un proyecto SpringBoot, por lo que debe haber una clase de inicio

  2. En el archivo pom del proyecto que se va a empaquetar, agregue el siguiente contenido

    <build>
    <!--finalName 可以不写，写了就是要打包的项目的名称 -->
    <finalName>demo</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

  3. Encuentre el área experta en el lado derecho de la idea, busque el proyecto que desea empaquetar, haga clic en limpiar y borre el caché, como se muestra en la figura

    inserte la descripción de la imagen aquí

    Si hace clic en prueba, todos los casos de prueba bajo prueba/java se ejecutarán aparte, y el siguiente proceso se ejecutará después de que pasen todos los casos de prueba.El proceso aquí es que el siguiente paso incluirá el paso anterior.

    Si no desea ejecutar el caso de prueba al empaquetar, hay dos formas de omitirlo:

    • Método 1: puede agregar las siguientes configuraciones en pom:

      <properties>
    <!--打包时跳过测试用例-->
    <skipTests>true</skipTests>
</properties>

    • Método 2: Configure en IDEA de la siguiente manera

      inserte la descripción de la imagen aquí

  4. Haga clic en el paquete para llevar a cabo la operación de embalaje y, finalmente, la pantalla BUILD SUCCESSsignifica que el embalaje se ha realizado correctamente.

    Nota: si el proyecto tiene dependencias personalizadas, primero debe hacer clic en instalar para instalar el paquete dependiente en el almacén local; de lo contrario, si hace clic en el paquete directamente, se informará un error como clase no encontrada

  5. En el directorio de destino del proyecto en el lado izquierdo de la idea, puede encontrar el paquete jar que acaba de crear

  6. Ingrese cmd en la barra de direcciones de la carpeta del paquete jar, abra la ventana de comando, ingrese en la línea de comando java -jar 项目名.jary presione Entrar para iniciar la aplicación

Conmutación de configuración multientorno de Spring Boot

Generalmente en un proyecto, siempre hay múltiples entornos. Por ejemplo: entorno de desarrollo -> entorno de prueba -> entorno de prelanzamiento -> entorno de producción.

Los archivos de configuración en cada entorno siempre son diferentes, e incluso el entorno de cada desarrollador en el entorno de desarrollo puede ser un poco diferente.

En Spring Boot, el nombre de archivo de la configuración multientorno debe cumplir con el formato de aplicación-{perfil}.yml o aplicación-{perfil}.properties, donde {perfil} corresponde al entorno, por ejemplo:

  • application-dev.yml: entorno de desarrollo
  • application-test.yml: entorno de prueba
  • application-prod.yml: entorno de producción

Formas habituales de configurar el entorno:

  • Forma 1: application.ymlConfigurar directamente en:

    spring:
  profiles:
    active: dev

  • Método 2: Especifique la configuración en IDEA para que surta efecto:

    inserte la descripción de la imagen aquí

  • Método 3: agregue parámetros al inicio para especificar qué configuración usar

    # 使用测试环境配置文件
java -jar xxx.jar --spring.profiles.active=test

Orden de carga de configuración de Spring Boot

Si Spring Boot encuentra la misma configuración en una ubicación de mayor prioridad, ignora la configuración de nivel inferior. Si diferentes configuraciones pueden tener efecto al mismo tiempo.

De acuerdo con la documentación de Spring Boot, la prioridad del uso de la configuración es de mayor a , de la siguiente manera:

  1. parámetros de línea de comando
  2. Parámetros del sistema Java obtenidos por System.getProperties()
  3. variables de entorno del sistema operativo
  4. Propiedades JNDI de java:comp/env
  5. Propiedades "random.*" generadas a través de RandomValuePropertySource
  6. Archivo de propiedades fuera del archivo Jar de la aplicación (aplicación-{perfil}.properties/yml)
  7. Archivo de propiedades dentro del archivo Jar de la aplicación (aplicación-{perfil}.properties/yml)
  8. Archivo de propiedades fuera del archivo Jar de la aplicación (application.properties/yml)
  9. Archivo de propiedades dentro del archivo Jar de la aplicación (application.properties/yml)
  10. Un archivo de propiedades declarado a través de la anotación "@PropertySource" en la clase Java de configuración de la aplicación (una clase Java que contiene la anotación "@Configuration")
  11. Propiedades predeterminadas declaradas a través de "SpringApplication.setDefaultProperties"

Spring Boot carga archivos de configuración externos

  • Método 1: Especificar por variable de entorno spring.config.location

    Nota: Después de usar el parámetro de ubicación para especificar el archivo de configuración, el archivo de configuración predeterminado (application.properties o application.yml) del proyecto se invalidará y Spring Boot solo cargará el archivo de configuración externo especificado.

    java -jar springbootdemo-0.0.1-SNAPSHOT.jar --spring.config.location=./my-application.yml

  • Método 2: Especificar por variable de entorno spring.config.additional-location

    Nota: El uso del parámetro de ubicación adicional no invalidará el archivo de configuración predeterminado del proyecto. El archivo de configuración externo surtirá efecto junto con el archivo de configuración predeterminado del proyecto para formar una configuración complementaria, y su prioridad es mayor que la de todos los archivos de configuración predeterminados.

    java -jar springbootdemo-0.0.1-SNAPSHOT.jar --spring.config.additional-location=./my-application.yml

Supongo que te gusta

Origin blog.csdn.net/footless_bird/article/details/128232709
Recomendado
Clasificación
Diario
Más
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)

Code World

© 2018 codetd.com