Prólogo: Todo el mundo sabe que los beneficios de springboot son que simplifica la configuración, el inicio con un clic y las entrevistas siempre preguntan sobre el principio de ensamblaje automático. Solo podemos responder a los cambios con una comprensión profunda del principio de ensamblaje.
Tabla de contenido
Pregunta 1: ¿Cómo sabe la configuración automática de Springboot si existe la clase dependiente?
Pregunta 2: El papel de los archivos META-INF en springboot-start-XXXX
Pregunta 1: ¿Cómo sabe la configuración automática de Springboot si existe la clase dependiente?
En Spring Boot, la configuración automática se logra a través de archivos en el classpathMETA-INF/spring.factories . Este archivo enumera los nombres de clase completos de todas las clases de configuración automática. Spring Boot busca estas clases de configuración automática al inicio y las aplica al contexto de la aplicación según sea necesario.
Cuando agrega una nueva dependencia a su proyecto, como pom.xmluna nueva biblioteca en un archivo, Spring Boot escanea el classpath de la biblioteca para encontrar META-INF/spring.factoriesel archivo. Si el archivo existe, se leerá y las clases de configuración automática enumeradas allí se cargarán en el contexto de la aplicación.
Si una clase de configuración automática depende de otras clases o bibliotecas, pero estas clases o bibliotecas no existen o no están configuradas correctamente, Spring Boot generará una excepción al iniciar la aplicación. Por lo tanto, para garantizar que las clases de configuración automática funcionen correctamente, las dependencias deben configurarse correctamente y agregarse al classpath.
En general, el mecanismo de configuración automática de Spring Boot se basa en archivos en classpath META-INF/spring.factories. Este archivo enumera los nombres de clase completos de todas las clases de configuración automática. Cuando agrega una nueva dependencia, Spring Boot escanea automáticamente la ruta de clase de esa dependencia en busca de este archivo y aplica las clases de configuración automática enumeradas allí al contexto de la aplicación.
Extensión: por lo tanto, también aprendimos que si se encuentra que la clase en el paquete jar es un error, como:
Entonces este ensamblaje automático definitivamente no es un ensamblaje automático.
Pregunta 2: El papel de los archivos META-INF en springboot-start-XXXX
spring-autoconfigure-metadata.propertiesEl archivo es un archivo de metadatos de configuración automática de Spring Boot, que se utiliza para describir la información de metadatos de la clase de configuración automática de Spring Boot. Este archivo contiene un conjunto de pares clave-valor, y cada par clave-valor representa la información de metadatos de un elemento de configuración automática, como el nombre del atributo, el tipo de atributo, el valor predeterminado, la descripción, etc.
Spring Boot usa este archivo para ayudar a los IDE (como Eclipse, IntelliJ IDEA, etc.) y otras herramientas (como Spring Boot Actuator) a comprender la información de las clases de configuración automática.
como:
org.springframework.boot.autoconfigure.condition.ConditionalOnProperty=\
name,spring.datasource.url,\
matchIfMissing=false
prefix=spring.datasource
spring-configuration-metadata.jsonEl archivo es un archivo de metadatos de configuración de Spring Boot, que se utiliza para describir la información de metadatos de las propiedades de configuración de la aplicación. Este archivo contiene un conjunto de pares clave-valor en formato JSON, y cada par clave-valor representa la información de metadatos de una propiedad de configuración, como el nombre de la propiedad, el tipo de propiedad, el valor predeterminado, la descripción, etc.
Spring Boot usa este archivo para ayudar a los IDE (como Eclipse, IntelliJ IDEA, etc.) y otras herramientas (como Spring Boot Actuator) a comprender la información de las clases de configuración automática.
como:
{
"name": "spring.datasource.url",
"type": "java.lang.String",
"description": "URL of the database.",
"defaultValue": "jdbc:h2:mem:testdb"
}spring.factoriesEl archivo es un archivo de configuración estándar del marco Spring, que permite a los desarrolladores de terceros registrar sus propias clases de implementación o clases de fábrica con el marco Spring para ampliar o reemplazar el comportamiento predeterminado del marco Spring. Este archivo se encuentra en el directorio del class path META-INF, es un archivo de propiedades estándar de Java, donde cada línea contiene un par clave-valor, la clave indica el tipo o interfaz a registrar, y el valor indica la clase o fábrica de implementación. clase del tipo o interfaz.
como:
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
El principio de partida de SpringBoot:
Código fuente de SpringBoot escrito a mano:
Clase de inicio:
@ZhouyuSpringBootApplication
public class MyApplication {
public static void main(String[] args) {
ZhouyuSpringApplication.run(MyApplication.class);
}
}
------------以下是启动类注解--------
/*
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan //只能扫描当前注解标注类的 兄弟及下属目录 扫描到的且标注注解的 才放入容器
@Import(ZhouyuImportSelect.class) // @import的作用是将ZhouyuImportSelect.class作为一个bean放入容器
public @interface ZhouyuSpringBootApplication {
}
*/1. Cree un contenedor (cree un contenedor springBoot e inicie un servidor Tomcat)
public class ZhouyuSpringApplication {
public static void run(Class clazz){
//创建一个spring容器 创建的方式有很多种，如果是加载xml的话，就是ClassPathXmlApplicationContext，如果是加载注解的话，就是AnnotationConfigApplicationContext
AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
applicationContext.register(clazz);//向容器中注册一个启动类
applicationContext.refresh();
//从sspring容器中开启TomcatService容器
WebServer webServer = getWebServer(applicationContext);
webServer.start();
}
public static WebServer getWebServer(ApplicationContext applicationContext){
Map<String, WebServer> beansOfType = applicationContext.getBeansOfType(WebServer.class);
if (beansOfType.isEmpty()) {
throw new NullPointerException();
}
if (beansOfType.size() > 1) {//如果拿到多个同类型的Bean就抛异常
throw new IllegalStateException();
}
return beansOfType.values().stream().findFirst().get();
}
}
2. Ponga el Bean requerido en el contenedor
//这个类需要注意 有没有被 SpringBoot扫描到？这时候就需要在 启动类头上只扫描了其兄弟目录
@Configuration
public class WebServerAutoConfiguration implements AutoConfiguration {
@Bean
@ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")
//如果maven中排除Tomcat依赖 这个就为false 此刻该bean就注入不成功了，其实现是通过类加载器获取，获取不到表示系统中没有这个类
public TomcatWebServer tomcatWebServer(){
return new TomcatWebServer();
}
@Bean
@ConditionalOnClass(name = "org.eclipse.jetty.server.Server")
public JettyWebServer jettyWebServer(){
return new JettyWebServer();
}
}Inyectamos TomcatService y JettyService en el contenedor a través de la clase de configuración, pero el código escrito arriba arroja una excepción cuando se encuentran dos servidores web, por lo que agregamos @Conditional (XX.class) (dentro) a la inyección de Bean para juzgar si hay algún No Clases cargadas. La siguiente figura es el principio de darse cuenta de si la clase existe:
Expansión del conocimiento de Maven:
<opción>verdadero<opción>标签：