Despliegue de Tomcat de SpringBoot Empaquetado de SpringBoot

Autowiring de SpringBoot

la configuración automática de SpringBoot se realiza automáticamente en la aplicación SpringBoot según las dependencias JAR adicionadas.

por ejemplo, si hay un H en la ruta de clase2el paquete JAR de la base de datos, y aún no hemos configurado manualmente ningún bean relacionado con la base de datos, la función de configuración automática de Spring Boot lo configurará automáticamente en el proyecto.

podemos activar la configuración automática mediante la anotación @EnableAutoConfiguration funcionalidades de configuración. Pero esta anotación no se utiliza porque está encapsulada en @SpringBootApplication dentro de la anotación. La anotación @SpringBootApplication es una combinación de tres anotaciones: @ComponentScan, @EnableAutoConfiguration,和 @Configuration pero, usamos la anotación @SpringBootApplication en lugar de @EnableAutoConfiguration.

@SpringBootApplication = @ComponentScan + @EnableAutoConfiguration + @Configuration

cuando se agrega al usar spring en el proyecto-boot-starter-web Cuando se utilizan dependencias, la configuración automática de Spring Boot busca Spring MVC en la ruta de clase. Se configura automáticamente dispatcherServlet por defecto páginas de error和 bolsa de red.

Del mismo modo, cuando agregamos spring-boot-starter-data-dependencias de JPA, vemos que la configuración automática de Spring Boot configurará automáticamente fuente de datos和 administrador de entidades.

Toda la lógica de configuración automática se encuentra en spring-boot-autoconfigure.jar se implementa como se muestra en la siguiente imagen.

requiere configuración automática

Las aplicaciones basadas en Spring requieren muchas configuraciones. Al usar Spring MVC, necesitamos configurar servlet de programador de dispatcher, analizador de vistas, Web jars A continuación, se muestra un ejemplo típico de la configuración del servlet de programador web en la aplicación web:

ejemplo

<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-clase>
org.springframework.web.servlet.DispatcherServlet
</servlet-clase>
<iniciar-parámetro>
<parámetro-name>ubicaciónConfiguraciónContexto</parámetro-name>
<parámetro-valor>/WEB-INF/por hacer-servlet.xml</parámetro-valor>
</iniciar-parámetro>
<cargar-en-inicio>1</cargar-en-inicio>
</servlet>
<servlet-mappings>
<servlet-name>dispatcher</servlet-name>
<url-patrón>/</url-patrón>
</servlet-mappings>

Del mismo modo, cuando usamos Hibernate/Al usar JPA, necesitamos configurar la fuente de datos, el gestor de transacciones, la fábrica de administradores de entidades, etc.

Configurar la fuente de datos

ejemplo

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${db.driver}"　/><br
<property name="jdbcUrl" value="${db.url}"　/><br
<property name="user" value="${db.username}"　/><br
<property name="password" value="${db.password}"　/><br
</bean>
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="classpath:config/schema.sql"　/><br
<jdbc:script location="classpath:config/data.sql"　/><br
</jdbc:initialize-database>

configurar la fábrica de administrador de entidades

ejemplo

<bean
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
id="entityManagerFactory"
<property name="persistenceUnitName" value="hsql_pu"　/><br
<property name="dataSource" ref="dataSource"　/><br
</bean>

configurar el administrador de transacciones

ejemplo

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"　/><br
<property name="dataSource" ref="dataSource"　/><br
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/><br

deshabilitar clases de configuración automática

Si no queremos que se aplique la aplicación, también podemos deshabilitar clases de configuración automática específicas. Usamos el comentario @EnableAutoConfiguration exclude propiedades para deshabilitar clases de configuración automática. Por ejemplo:

ejemplo

import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration(proxyBeanMethods = false)
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration　
health","templated":false},"health"}}
}

Si la clase no está en la ruta de clase, podemos usar la propiedad del comentario @EnableAutoConfiguration excludeName 并指定类的 qualified 名称。我们可以使用属性 spring.autoconfigure.exclude 排除任何数量的自动配置类。

Spring Boot自动配置示例

在以下示例中，我们将看到Spring Boot的自动配置功能如何工作。

paso1: 打开spring Initializr https://start.spring.io/.

第2步: 组名称。我们提供了 com.w3codebox .

paso3: 提供工件 ID。我们提供了 spring-boot-autoconfiguration-example .

paso4: 添加依赖项: Spring Web，Spring Data JPA，一个 H2数据库.

paso5: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它会将项目包装在 Jar 文件中，并将其下载到本地系统。

第6步: 提取 Jar文件并将其粘贴到STS工作区中。

paso7: 将项目文件夹导入STS。

文件->导入->现有Maven项目->浏览->选择文件夹spring-boot-autoconfiguration-example->完成

导入需要一些时间。

paso8: 在目录中创建名称为 com.w3codebox.controller 的程序包。文件夹 src/main/java .

paso9: 在包中创建名称为 ControllerDemo 的Controller类。 strong> com.w3codebox.controller 。

ControllerDemo.java

ejemplo

package　com.w3codebox.controller;
import　org.springframework.stereotype.Controller;
import　org.springframework.web.bind.annotation.RequestMapping;
@Controller
public　class　ControllerDemo　
health","templated":false},"health"}}
　　　　@RequestMapping("/")
　　　　public　String　home()
　　　　health","templated":false},"health"}}
　　　　　　　　return　"home.jsp";
　　　　}
}

paso10: en la carpeta src/main/java 中创建另一个名为 com.w3codebox.model 的包。 p>

paso11: 在包　 com.w3codebox.model 中创建一个名称为　 User 的类。

User.java

ejemplo

package　com.w3codebox.model;
import　javax.persistence.Entity;
import　javax.persistence.Id;
import　javax.persistence.Table;
@Entity
@Table(name="userdata")
public class User　
health","templated":false},"health"}}
　　　　@Id
　　　　private int id;
　　　　private String username;
　　　　public int getId()　
　　　　health","templated":false},"health"}}
　　　　　　　　return id;
　　　　}
　　　　public void setId(int id)　
　　　　health","templated":false},"health"}}
　　　　　　　　this.id = id;
　　　　}
　　　　public String getUname()　
　　　　health","templated":false},"health"}}
　　　　　　　　return username;
　　　　}
　　　　public void setUname(String username)　
　　　　health","templated":false},"health"}}
　　　　　　　　this.username = username;
　　　　}
　　　　@Override
　　　　public String toString()　
　　　　health","templated":false},"health"}}
　　　　　　　　return "User [id="　+　id　+　", uname="　+　username　+　"]";
　　　　}
}

Ahora, necesitamos configurar H2base de datos.

paso12: abrir 　 application.properties archivo y configure el siguiente contenido: 　puerto, activar H2Consola, fuente de datos,和　 URL.

application.properties

ejemplo

server.port=8085
spring.h2.console.enabled=true
spring.datasource.platform=h2
spring.datasource.url=jdbc:h2:mem:w3codebox

paso13: en la carpeta 　 src/main/Crear uno en resources SQL archivo.

Haga clic derecho en src/main/carpeta resources->Nuevo->Archivo->Proporcionar nombre de archivo->完成

Hemos proporcionado el nombre del archivo 　 data.sql e insertar los siguientes datos.

data.sql

ejemplo

insert into userdata values(101Tom');
insert into userdata values(102Andrew');
insert into userdata values(103Tony');
insert into userdata values(104Bob');
insert into userdata values(105Sam');

paso14: en 　 src Crear un archivo con el nombre 　 webapp en la carpeta.

paso15: usando 　 ControllerDemo en el nombre devuelto por el archivo. En ControllerDemo.java, devolvimos 　 home.jsp .

home.jsp

ejemplo

<%@page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insertar título aquí</title>
</title>
<head>
<body>
<form action="addUser">　/><br
Nombre de usuario <br1<input type="text" name="t　/><br
ID <br　/><br
Nombre de usuario <br2<input type="text" name="t　/><br
>
</<input type="submit" value="Add">
</form>
</body>

paso16: 运行　 html> SpringBootAutoconfigurationExampleApplication.java 　 8085 se ejecuta. El archivo. Podemos ver en la consola que nuestra aplicación se ha ejecutado con éxito en el puerto

paso17: 打开浏览器并调用URL 　 http: //localhost: 8085/h2-console/. Muestra lo que hemos definido en 　 application.properties configurado en el archivo 　clase del driver，　 JDBC URL y el nombre de usuario predeterminado 　 sa .

También podemos probar la conexión haciendo clic en 　Probar conexiónbotón. Si la conexión es exitosa, se muestra el mensaje 　prueba exitosa.

paso18: 单击　conexiónbotón. Muestra la tabla definida en el archivo User.java 　 userdata la estructura.

paso19: Ejecutar la siguiente consulta para ver lo que hemos insertado 　 data.sql los datos del archivo

ejemplo

SELECT　*　FROM USERDATA;

Vamos a mirar de cerca la consola. Vemos que 　 TransactionManagement, DispatcherServlet, EntityManagerFactory,和　 DataSource Se configurará automáticamente, como se muestra en la siguiente imagen.

Depurar la configuración automática

Podemos encontrar más información sobre la configuración automática de las siguientes maneras: Usando los siguientes dos métodos:

Abrir el registro de depuración Usando Spring Boot ejecutor

Abrir el registro de depuración

Podemos hacerlo a través de 　 application.properties Agregar propiedades para depurar los archivos de registro de log. Vamos a implementar la depuración de registros en el ejemplo anterior. Abre 　 application.properties Agregar las siguientes propiedades al archivo

ejemplo

logging.level.org.springframework: DEBUG

Ahora reinicia la aplicación. Vemos que en el registro se imprime un informe de configuración automática. Este informe incluye todas las clases de configuración automática. Se divide en dos partes: 　Coincidencia positiva和　Coincidencia negativacomo se muestra en la siguiente imagen.

Coincidencia positiva

Coincidencia negativa

Spring Boot ejecutor

También podemos usar en el proyecto 　 Actuator Depurar la configuración automática. También agregaremos 　 Navegador HALpara simplificar las operaciones.

Vamos a crear un ejemplo de Spring Boot Actuator.

paso1: Abre Spring Initializr http://start.spring.io 。

paso2: 提供　组名称。我们提供了　 com.w3codebox。

paso3: 提供　工件 ID。我们提供了　执行器自动配置示例。

paso4: 添加依赖项: 　 Spring Web 和　 Spring Boot Actuator。

ejemplo

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

paso5: 单击　 Generate (生成)按钮。它将与项目相关的所有规范绑定到一个　 jar 文件中，并将其下载到我们的本地系统中。

paso6: 提取下载的jar文件。

paso7: 使用以下步骤导入项目文件夹:

文件->导入->现有Maven项目->下一步->浏览- >选择项目文件夹->完成

导入项目后，我们可以在IDE的　 Package Explorer 部分中看到以下目录结构。

paso8: 在包中创建Controller类　 com.w3codebox。我们创建了一个名为　 DemoRestController的控制器类。

在Controller中，我们定义了一个名为　 hello( )，它返回一个字符串。

DemoRestController.java

ejemplo

package　com.w3codebox;
import　org.springframework.web.bind.annotation.GetMapping;
import　org.springframework.web.bind.annotation.RestController;
@RestController
public　class　DemoRestController　
health","templated":false},"health"}}
　　　　@GetMapping("/hello")
　　　　public　String　hello()　
　　　　health","templated":false},"health"}}
　　　　　　　　return　"Hello　User,　have　a　nice　day.";
　　　　}
}

paso9: 运行　 ActuatorAutoConfigurationExampleApplication.java archivo.

paso10: 打开浏览器并调用URL 　 http: //localhost: 8080/hello 。它返回我们在控制器中指定的字符串。

现在调用执行器URL 　 http: //localhost: 8080/actuator 。它将启动显示以下三个URL的执行器: 　 self ，　和　 info ，如下所示。

ejemplo

{"_links":{"self":{"href":"http://localhost:8080/"actuator","templated":false}//localhost:8080/actuator/health","templated":false},"health-path":{"href":"http://localhost:8080/actuator//health","templated":false},"health"}}*","templated":true},"info":{"href":"http://localhost:8080/actuator/{"info":{"href":"http:

paso11: abrir 　 pom.xml archivo y agregue 　 Navegador HALdependencias.

ejemplo

<dependency>
<groupId>org.springframework.data</<groupId>
<artifactId>spring-data-rest-hal-browser</artifactId>
</dependency>

paso12: Ejecute nuevamente 　 ActuatorAutoConfigurationExampleApplication.java archivo.

Para acceder al navegador HAL, escriba 　 http://localhost:8080 En el navegador, luego presione Enter.

Ahora podemos acceder al ejecutor a través del navegador HAL.

En el cuadro de texto del administrador de recursos, escriba 　/actuator , luego haga clic 　 Ir >botón.

Muestra la relación con el ejecutor. Lo más importante en el ejecutor es 　 beans .

Al hacer clic en la flecha del bean, se mostrarán todas

La imagen siguiente muestra todas las configuraciones automáticas 　 beans detalles.

Despliegue de Tomcat de SpringBoot Empaquetado de SpringBoot

Tutoriales de SpringBoot

Autowiring de SpringBoot

requiere configuración automática

deshabilitar clases de configuración automática

Spring Boot自动配置示例

Depurar la configuración automática