English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
A configuração automática do SpringBoot ajusta automaticamente o aplicativo SpringBoot com base nas dependências Jar adicionadas.
Por exemplo, se existir no caminho da classe o H2o Jar do banco de dados, e ainda não configuramos manualmente nenhum bean relacionado ao banco de dados, a função de configuração automática do Spring Boot configurará automaticamente no projeto.
Podemos ativar a configuração automática usando a anotação @EnableAutoConfiguration funções de configuração. No entanto, esta anotação não é usada porque ela está encapsulada @SpringBootApplication dentro da anotação. A anotação @SpringBootApplication é a combinação de três anotações: @ComponentScan, @EnableAutoConfiguration,和 @Configuration No entanto, usamos a anotação @SpringBootApplication em vez de @EnableAutoConfiguration.
@SpringBootApplication = @ComponentScan + @EnableAutoConfiguration + @Configuration
ao adicionar ao usar o spring em projetos-boot-starter-web Quando há dependências, a configuração automática do Spring Boot busca o Spring MVC no caminho da classe. Ele configura automaticamente dispatcherServlet padrão páginas de erro和 tanque de rede.
Da mesma forma, quando adicionamos spring-boot-starter-data-dependências JPA, vemos que a configuração automática do Spring Boot configurará automaticamente provedor de dados和 gerenciador de entidades.
Toda a lógica de configuração automática está em spring-boot-autoconfigure.jar como mostrado na figura a seguir.
Os aplicativos baseados em Spring precisam de muitas configurações. Quando usamos Spring MVC, precisamos configurar servlet de despachador, analisador de visões, Web jars A seguir, é mostrada a configuração típica do servlet de despachador no aplicativo web:
<servlet> <servlet-nome>dispatcher</servlet-nome> <servlet-classe> org.springframework.web.servlet.DispatcherServlet </servlet-classe> <iniciar-parâmetro> <parâmetro-nome>contextConfigLocation</parâmetro-nome> <parâmetro-valor>/WEB-INF/para fazer-servlet.xml</parâmetro-valor> </iniciar-parâmetro> <carregar-em-início>1</carregar-em-início> </servlet> <servlet-mpping> <servlet-nome>dispatcher</servlet-nome> <url-padrão>/</url-padrão> </servlet-mpping>
Da mesma forma, quando usamos Hibernate/Quando usamos JPA, precisamos configurar o provedor de dados, o gerenciador de transações, a fábrica de gerenciadores de entidades etc.
Configurar o provedor de dados
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${db.driver}" />
<property name="jdbcUrl" value="${db.url}" />
<property name="user" value="${db.username}" />
<property name="password" value="${db.password}" />
</bean>
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="classpath:config/schema.sql" />
<jdbc:script location="classpath:config/data.sql" />
</jdbc:initialize-database>
configurar a fábrica de gerenciador de entidades
<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory" <property name="persistenceUnitName" value="hsql_pu" /> <property name="dataSource" ref="dataSource" /> </bean>
configurar o gerenciador de transações
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory" /> <property name="dataSource" ref="dataSource" /> </bean> <tx:annotation-driven transaction-manager="transactionManager"/>
Se não quisermos ser aplicado, também podemos desativar classes de configuração automática específicas. Usamos o comentário @EnableAutoConfiguration exclude propriedade para desativar a classe de configuração automática. Por exemplo:
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":{"path":{"href":"http:
}
Se a classe não estiver na classe de caminho, podemos usar a propriedade do comentário @EnableAutoConfiguration excludeName 并指定类的 qualified 名称。我们可以使用属性 spring.autoconfigure.exclude 排除任何数量的自动配置类。
在以下示例中，我们将看到Spring Boot的自动配置功能如何工作。
passo1: 打开spring Initializr https://start.spring.io/.
第2步: 组名称。我们提供了 com.w3codebox .
passo3: 提供 工件 ID。我们提供了 spring-boot-autoconfiguration-example .
passo4: 添加依赖项: Spring Web，Spring Data JPA，一个 H2数据库.
passo5: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它会将项目包装在 Jar 文件中，并将其下载到本地系统。
第6步: 提取 Jar文件并将其粘贴到STS工作区中。
passo7: 将项目文件夹导入STS。
文件->导入->现有Maven项目->浏览->选择文件夹spring-boot-autoconfiguration-example->完成
导入需要一些时间。
passo8: 在目录中创建名称为 com.w3codebox.controller 的程序包。文件夹 src/main/java .
passo9: 在包中创建名称为 ControllerDemo 的Controller类。3codebox.controller 。
ControllerDemo.java
package com.w3codebox.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ControllerDemo
"},"health":{"path":{"href":"http:
@RequestMapping("/")
public String home()
"},"health":{"path":{"href":"http:
return "home.jsp";
}
}
passo10: na pasta src/main/java 中创建另一个名为 com.w3codebox.model 的包。
User.java
package com.w3codebox.model;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="userdata")
public class User
"},"health":{"path":{"href":"http:
@Id
private int id;
private String username;
public int getId()
"},"health":{"path":{"href":"http:
return id;
}
public void setId(int id)
"},"health":{"path":{"href":"http:
this.id = id;
}
public String getUname()
"},"health":{"path":{"href":"http:
return username;
}
public void setUname(String username)
"},"health":{"path":{"href":"http:
this.username = username;
}
@Override
public String toString()
"},"health":{"path":{"href":"http:
return "User [id=" + id + ", uname=" + username + "]";
}
}
Agora, precisamos configurar o H2banco de dados.
passo12: abrir application.properties abra o arquivo e configure o seguinte conteúdo: porta, ativar H2Console, fonte de dados,和 URL.
application.properties
server.port=8085 spring.h2.console.enabled=true spring.datasource.platform=h2 spring.datasource.url=jdbc:h2:mem:w3codebox
passo13: na pasta src/main/crie um arquivo SQL arquivo.
clique com o botão direito no src/main/pasta resources->Novo->Arquivo->Fornecer nome do arquivo->完成
Fornecemos o nome do arquivo data.sql e insira os seguintes dados.
data.sql
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');
passo14: no src Crie um arquivo com o nome webapp na pasta
passo15: usando ControllerDemo no arquivo JSP criado. No ControllerDemo.java, retornamos home.jsp .
home.jsp
<%@page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <!DOCTYPE html> <html> <head> <meta charset="ISO-8859-1"> <title>Insira título aqui</title> </head> <body> <form action="addUser"> ID <br /> <input type="text" name="t1><br /> Nome de usuário <br /> <input type="text" name="t2><br /> <input type="submit" value="Add"> </form> </body> </html>
passo16: 运行 SpringBootAutoconfigurationExampleApplication.java arquivo. Podemos ver na consola que nosso aplicativo foi executado com sucesso na porta 8085 está rodando.
passo17: 打开浏览器并调用URL http: //localhost: 8085/h2-console/. Ele mostra a tabela definida no application.properties configurado no arquivo classe do driver， JDBC URL e o nome de usuário padrão sa .
Também podemos testar a conexão clicando no teste de conexãobotão. Se a conexão for bem-sucedida, uma mensagem teste bem-sucedido.
passo18: 单击 conexãobotão. Ele mostra a tabela definida no arquivo User.java userdata estrutura.
passo19: Execute a seguinte consulta para ver o que já inserimos data.sql os dados do arquivo
SELECT * FROM USERDATA;
Vamos olhar com atenção para a consola. Vemos TransactionManagement, DispatcherServlet, EntityManagerFactory,和 DataSource será configurado automaticamente, como mostrado na figura a seguir.
Podemos encontrar mais informações sobre a configuração automática das seguintes maneiras: Usando os seguintes dois métodos:
Abra a depuração de logs usando o Spring Boot ExecutorAbra a depuração de logs
Podemos fazer isso através de application.properties Adicione propriedades para depuração de logs no arquivo. Vamos implementar a depuração de logs no exemplo acima. Abra application.properties Adicione o arquivo e as seguintes propriedades:
logging.level.org.springframework: DEBUG
Agora reinicie o aplicativo. Vemos que no log foi impresso um relatório de configuração automática. O relatório inclui todas as classes de configuração automática. Dividido em duas partes: Match positivo和 Match negativocomo mostrado na figura a seguir.
Match positivo
Match negativo
Spring Boot Executor
Podemos ainda usar no projeto Actuator Depuração de configuração automática. Também adicionaremos Navegador HALpara simplificar as operações.
Vamos criar um exemplo de Spring Boot Actuator.
passo1: Abra o Spring Initializr http://start.spring.io 。
passo2: 提供 组名称。我们提供了 com.w3codebox。
passo3: 提供 工件 ID。我们提供了 执行器自动配置示例。
passo4: 添加依赖项: Spring Web 和 Spring Boot Actuator。
<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>
passo5: 单击 Generate (生成)按钮。它将与项目相关的所有规范绑定到一个 jar 文件中，并将其下载到我们的本地系统中。
passo6: 提取下载的jar文件。
passo7: 使用以下步骤导入项目文件夹:
文件->导入->现有Maven项目->下一步->浏览- >选择项目文件夹->完成
导入项目后，我们可以在IDE的 Package Explorer 部分中看到以下目录结构。
passo8: 在包中创建Controller类 com.w3codebox。我们创建了一个名为 DemoRestController的控制器类。
在Controller中，我们定义了一个名为 hello( )，它返回一个字符串。
DemoRestController.java
package com.w3codebox;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DemoRestController
"},"health":{"path":{"href":"http:
@GetMapping("/hello")
public String hello()
"},"health":{"path":{"href":"http:
return "Hello User, have a nice day.";
}
}
passo9: 运行 ActuatorAutoConfigurationExampleApplication.java arquivo.
passo10: 打开浏览器并调用URL http: //localhost: 8080/hello 。它返回我们在控制器中指定的字符串。
现在调用执行器URL http: //localhost: 8080/actuator 。它将启动显示以下三个URL的执行器: self ， "},"templated":false},"health"}}} 和 info ，如下所示。
{"_links":{"self":{"href":"http://localhost:8080/"actuator","templated":false}//localhost:8080/actuator/health","templated":false},"health-path":{"href":"http://localhost:8080/actuator/"},"templated":false},"health"}}}/"},"health":{"path":{"href":"http:*"},"path":{"href":"http://localhost:8080/actuator/{"info":{"href":"http:
passo11: abrir pom.xml arquivo e adicione Navegador HALdependências.
<dependency> <groupId>org.springframework.data</<groupId> <artifactId>spring-data-rest-hal-browser</artifactId> </dependency>
passo12: Novamente, execute ActuatorAutoConfigurationExampleApplication.java arquivo.
Para acessar o navegador HAL, digite http://localhost:8080 No navegador, e pressione a tecla Enter.
Agora podemos acessar o executor através do navegador HAL.
No campo de texto do gerenciador de recursos, digite /actuator , e então clique em Ir >botão.
Mostra com o executor. O mais importante no executor é beans .
Quando clicamos no seta do bean, ele mostra todas as
A figura acima mostra todas as configurações automáticas. beans detalhes.