Spring Boot @ SpringBootApplication，SpringApplication类

最新推荐文章于 2024-04-10 14:44:11 发布

cunchi4221

最新推荐文章于 2024-04-10 14:44:11 发布

阅读量226

点赞数

原文链接：https://www.journaldev.com/21556/springbootapplication-springapplication

版权

Spring Boot @SpringBootApplication注释 (Spring Boot @SpringBootApplication Annotation)

Spring Boot @SpringBootApplication annotation is used to mark a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. It’s same as declaring a class with @Configuration, @EnableAutoConfiguration and @ComponentScan annotations.

Spring Boot @SpringBootApplication批注用于标记一个配置类，该配置类声明一个或多个@Bean方法，并触发auto-configuration和组件扫描。等同于使用@ Configuration，@ EnableAutoConfiguration和@ComponentScan批注声明类。

Spring Boot SpringApplication类 (Spring Boot SpringApplication Class)

Spring Boot SpringApplication class is used to bootstrap and launch a Spring application from a Java main method. This class automatically creates the ApplicationContext from the classpath, scan the configuration classes and launch the application. This class is very helpful in launching Spring MVC or Spring REST application using Spring Boot.

Spring Boot SpringApplication类用于从Java main方法引导和启动Spring应用程序。此类从类路径自动创建ApplicationContext ，扫描配置类并启动应用程序。此类对于使用Spring Boot启动Spring MVC或Spring REST应用程序非常有帮助。

SpringBootApplication和SpringApplication示例 (SpringBootApplication and SpringApplication Example)

In the last tutorial on Spring RestController, we created a Spring RESTful web service and deployed it on Tomcat. We had to create web.xml and spring context file. We also had to manually add Spring MVC dependencies and manage their versions.

在有关Spring RestController的上一教程中，我们创建了一个Spring RESTful Web服务并将其部署在Tomcat上。我们必须创建web.xml和spring上下文文件。我们还必须手动添加Spring MVC依赖关系并管理其版本。

Here we will change the project to run as a Spring Boot Application and get rid of configuration files. This will help in the quick testing of our application logic because we won’t have to manually build and deploy the project to the external Tomcat server.

在这里，我们将更改项目以使其作为Spring Boot Application运行并摆脱配置文件。这将有助于快速测试应用程序逻辑，因为我们不必手动构建项目并将其部署到外部Tomcat服务器。

GitHub Repository, in following sections we will make necessary changes to the project files. GitHub Repository中检出现有项目，在以下各节中，我们将对项目文件进行必要的更改。

Below image shows our final project structure.

下图显示了我们的最终项目结构。

添加Spring Boot Maven依赖项 (Adding Spring Boot Maven Dependencies)

The first step is to clean up pom.xml file and configure it for Spring Boot. Since it’s a REST web service, we only need spring-boot-starter-web dependency. However, we will have to keep JAXB dependencies because we are running on Java 10 and we want to support XML request and responses too.

第一步是清理pom.xml文件并为Spring Boot配置它。由于它是REST Web服务，因此我们只需要spring-boot-starter-web依赖项。但是，由于我们在Java 10上运行，并且我们也要支持XML请求和响应，因此我们必须保留JAXB依赖性。

We will also have to add spring-boot-maven-plugin plugin, this plugin lets us run our simple java application as spring boot application.

我们还必须添加spring-boot-maven-plugin插件，该插件使我们可以将简单的Java应用程序作为spring boot应用程序运行。

Here is our updated pom.xml file.

这是我们更新的pom.xml文件。

<project xmlns="https://maven.apache.org/POM/4.0.0"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>Spring-RestController</groupId>
	<artifactId>Spring-RestController</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.2.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>10</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!-- JAXB for XML Response needed to explicitly define from Java 9 onwards -->

		<dependency>
			<groupId>javax.xml.bind</groupId>
			<artifactId>jaxb-api</artifactId>
		</dependency>
		<dependency>
			<groupId>org.glassfish.jaxb</groupId>
			<artifactId>jaxb-runtime</artifactId>
			<version>2.3.0</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>javax.activation</groupId>
			<artifactId>javax.activation-api</artifactId>
			<version>1.2.0</version>
		</dependency>
	</dependencies>

	<build>
		<!-- added to remove Version from WAR file -->
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

We can delete WebContent directory or leave it as is, it won’t be used by our Spring Boot application.

我们可以删除WebContent目录或将其保留不变，我们的Spring Boot应用程序将不会使用它。

Spring Boot应用程序类 (Spring Boot Application Class)

Now we have to create a java class with main method, mark it with @SpringBootApplication annotation and invoke SpringApplication.run() method.

现在，我们必须使用main方法创建一个Java类，使用@SpringBootApplication批注对其进行标记，然后调用SpringApplication.run()方法。

package com.journaldev.spring;

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

@SpringBootApplication
public class SpringBootRestApplication {

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

Just run the class as Java application and it will produce following output. I have removed some loggers that we don’t care about here. The application will not quit and wait for client requests.

只需将类作为Java应用程序运行，它将产生以下输出。我删除了一些我们不在乎的记录器。该应用程序将不会退出并等待客户端请求。

2018-06-18 14:33:51.276  INFO 3830 --- [           main] c.j.spring.SpringBootRestApplication     : Starting SpringBootRestApplication on pankaj with PID 3830 (/Users/pankaj/Documents/eclipse-jee-workspace/Spring-RestController/target/classes started by pankaj in /Users/pankaj/Documents/eclipse-jee-workspace/Spring-RestController)
2018-06-18 14:33:51.280  INFO 3830 --- [           main] c.j.spring.SpringBootRestApplication     : No active profile set, falling back to default profiles: default
2018-06-18 14:33:51.332  INFO 3830 --- [           main] ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@38467116: startup date [Mon Jun 18 14:33:51 IST 2018]; root of context hierarchy
2018-06-18 14:33:52.311  INFO 3830 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2018-06-18 14:33:52.344  INFO 3830 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2018-06-18 14:33:52.344  INFO 3830 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.31
2018-06-18 14:33:52.453  INFO 3830 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2018-06-18 14:33:52.453  INFO 3830 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1127 ms
2018-06-18 14:33:52.564  INFO 3830 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Servlet dispatcherServlet mapped to [/]
2018-06-18 14:33:52.927  INFO 3830 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/rest/employee/get/{id}],methods=[GET]}" onto public com.journaldev.spring.model.Employee com.journaldev.spring.controller.EmployeeRestController.getEmployeeByID(int)
2018-06-18 14:33:52.928  INFO 3830 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/rest/employee/getAll],methods=[GET]}" onto public java.util.List<com.journaldev.spring.model.Employee> com.journaldev.spring.controller.EmployeeRestController.getAllEmployees()
2018-06-18 14:33:52.929  INFO 3830 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/rest/employee/create],methods=[POST]}" onto public com.journaldev.spring.model.Employee com.journaldev.spring.controller.EmployeeRestController.createEmployee(com.journaldev.spring.model.Employee)
2018-06-18 14:33:52.929  INFO 3830 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/rest/employee/search/{name}],methods=[GET]}" onto public com.journaldev.spring.model.Employee com.journaldev.spring.controller.EmployeeRestController.getEmployeeByName(java.lang.String)
2018-06-18 14:33:52.929  INFO 3830 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/rest/employee/delete/{id}],methods=[DELETE]}" onto public com.journaldev.spring.model.Employee com.journaldev.spring.controller.EmployeeRestController.deleteEmployeeByID(int)
2018-06-18 14:33:53.079  INFO 3830 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2018-06-18 14:33:53.118  INFO 3830 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2018-06-18 14:33:53.124  INFO 3830 --- [           main] c.j.spring.SpringBootRestApplication     : Started SpringBootRestApplication in 2.204 seconds (JVM running for 2.633)

Some important points we can deduce from logs:

我们可以从日志中得出一些重要的观点：

Spring Boot Application Process ID is 3830.
Spring Boot应用程序进程ID是3830。
Spring Boot Application is launching Tomcat on port 8080.
Spring Boot Application正在端口8080上启动Tomcat。
Our application context path is “”. It means when invoking our APIs we don’t need to provide servlet context.
我们的应用程序上下文路径为“”。这意味着在调用我们的API时，我们不需要提供servlet上下文。
The logger prints all the APIs that are configured, see messages Mapped "{[/rest/employee/get/{id}],methods=[GET]}" etc.
记录器将打印所有已配置的API，请参阅消息Mapped "{[/rest/employee/get/{id}],methods=[GET]}" 。

Below image shows an example invocation of the APIs exposed by our Spring Boot Application.

下图显示了我们的Spring Boot应用程序公开的API的示例调用。

SpringBootApplication scanBasePackages (SpringBootApplication scanBasePackages)

By default SpringApplication scans the configuration class package and all it’s sub-pacakges. So if our SpringBootRestApplication class is in com.journaldev.spring.main package, then it won’t scan com.journaldev.spring.controller package. We can fix this situation using SpringBootApplication scanBasePackages property.

默认情况下，SpringApplication会扫描配置类包及其所有子功能。因此，如果我们的SpringBootRestApplication类位于com.journaldev.spring.main包中，则它将不会扫描com.journaldev.spring.controller包。我们可以使用SpringBootApplication scanBasePackages属性来解决这种情况。

@SpringBootApplication(scanBasePackages="com.journaldev.spring")
public class SpringBootRestApplication {
}

Spring Boot自动配置的Bean (Spring Boot Auto-Configured Beans)

Since Spring Boot provides auto-configuration, there are a lot of beans getting configured by it. We can get a list of these beans using below code snippet.

由于Spring Boot提供了自动配置，因此有很多Bean被它配置。我们可以使用下面的代码片段获得这些bean的列表。

ApplicationContext ctx = SpringApplication.run(SpringBootRestApplication.class, args);
String[] beans = ctx.getBeanDefinitionNames();
for(String s : beans) System.out.println(s);

Below is the list of beans configured by our spring boot application.

以下是我们的Spring Boot应用程序配置的bean列表。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
springBootRestApplication
org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
employeeRestController
employeeRepository
org.springframework.boot.autoconfigure.AutoConfigurationPackages
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
org.springframework.boot.autoconfigure.condition.BeanTypeRegistry
propertySourcesPlaceholderConfigurer
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration$TomcatWebSocketConfiguration
websocketContainerCustomizer
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryConfiguration$EmbeddedTomcat
tomcatServletWebServerFactory
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration
servletWebServerFactoryCustomizer
tomcatServletWebServerFactoryCustomizer
server-org.springframework.boot.autoconfigure.web.ServerProperties
org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor
org.springframework.boot.context.properties.ConfigurationBeanFactoryMetadata
webServerFactoryCustomizerBeanPostProcessor
errorPageRegistrarBeanPostProcessor
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration$DispatcherServletConfiguration
dispatcherServlet
mainDispatcherServletPathProvider
spring.mvc-org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration$DispatcherServletRegistrationConfiguration
dispatcherServletRegistration
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration
defaultValidator
methodValidationPostProcessor
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration$WhitelabelErrorViewConfiguration
error
beanNameViewResolver
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration$DefaultErrorViewResolverConfiguration
conventionErrorViewResolver
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration
errorAttributes
basicErrorController
errorPageCustomizer
preserveErrorControllerTargetClassPostProcessor
spring.resources-org.springframework.boot.autoconfigure.web.ResourceProperties
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter$FaviconConfiguration
faviconHandlerMapping
faviconRequestHandler
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$EnableWebMvcConfiguration
requestMappingHandlerAdapter
requestMappingHandlerMapping
mvcConversionService
mvcValidator
mvcContentNegotiationManager
mvcPathMatcher
mvcUrlPathHelper
viewControllerHandlerMapping
beanNameHandlerMapping
resourceHandlerMapping
mvcResourceUrlProvider
defaultServletHandlerMapping
mvcUriComponentsContributor
httpRequestHandlerAdapter
simpleControllerHandlerAdapter
handlerExceptionResolver
mvcViewResolver
mvcHandlerMappingIntrospector
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter
defaultViewResolver
viewResolver
welcomePageHandlerMapping
requestContextFilter
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
hiddenHttpMethodFilter
httpPutFormContentFilter
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
mbeanExporter
objectNamingStrategy
mbeanServer
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration
standardJacksonObjectMapperBuilderCustomizer
spring.jackson-org.springframework.boot.autoconfigure.jackson.JacksonProperties
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperBuilderConfiguration
jacksonObjectMapperBuilder
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$ParameterNamesModuleConfiguration
parameterNamesModule
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperConfiguration
jacksonObjectMapper
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
jsonComponentModule
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration$StringHttpMessageConverterConfiguration
stringHttpMessageConverter
spring.http.encoding-org.springframework.boot.autoconfigure.http.HttpEncodingProperties
org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration$MappingJackson2HttpMessageConverterConfiguration
mappingJackson2HttpMessageConverter
org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration
messageConverters
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration$JacksonCodecConfiguration
jacksonCodecCustomizer
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration
spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration
spring.security-org.springframework.boot.autoconfigure.security.SecurityProperties
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration
restTemplateBuilder
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration$TomcatWebServerFactoryCustomizerConfiguration
tomcatWebServerFactoryCustomizer
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration
characterEncodingFilter
localeCharsetMappingsCustomizer
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration
multipartConfigElement
multipartResolver
spring.servlet.multipart-org.springframework.boot.autoconfigure.web.servlet.MultipartProperties

That’s a huge list, there are many auto-configured beans that we are not using. We can optimize our spring boot application by disabling these using @SpringBootApplication exclude or excludeName property.

那是一个巨大的清单，有许多我们没有使用的自动配置的Bean。我们可以通过使用@SpringBootApplication exclude或excludeName属性禁用它们来优化我们的Spring Boot应用程序。

Below code snippet will disable JMX and Multipart autoconfiguration.

下面的代码段将禁用JMX和Multipart自动配置。

@SpringBootApplication(scanBasePackages = "com.journaldev.spring", exclude = {
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration.class, org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration.class })
public class SpringBootRestApplication {
}

Note that if we try to exclude any non-auto-configuration classes, we will get an error and our application won’t start.

请注意，如果我们尝试排除任何非自动配置类，则会出现错误，并且应用程序将无法启动。

@SpringBootApplication(scanBasePackages = "com.journaldev.spring", exclude = {com.journaldev.spring.controller.EmployeeRestController.class })
public class SpringBootRestApplication {
}

Above code snippet will throw the following error:

上面的代码片段将引发以下错误：

2018-06-18 15:10:43.602 ERROR 3899 --- [main] o.s.boot.SpringApplication: Application run failed

java.lang.IllegalStateException: The following classes could not be excluded because they are not auto-configuration classes:
	- com.journaldev.spring.controller.EmployeeRestController

That’s all for SpringBootApplication annotation and SpringApplication example.

这就是SpringBootApplication注释和SpringApplication示例的全部SpringApplication 。

GitHub Repository. GitHub Repository下载最终项目。

翻译自: https://www.journaldev.com/21556/springbootapplication-springapplication

cunchi4221

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot @ SpringBootApplication，SpringApplication类

Spring Boot @SpringBootApplication注释 (Spring Boot @SpringBootApplication Annotation)Spring Boot @SpringBootApplication annotation is used to mark a configuration class that declares one or more @Bea...
复制链接

扫一扫