知识点梳理
课堂讲义
02-SpringBoot自动配置-@Conditional使用
Condition是Spring4.0后引入的条件化配置接口,通过实现Condition接口可以完成有条件的加载相应的Bean。
作用:根据条件,决定类是否加载到Spring IoC容器中
需求: 导入Jedis坐标后创建user对象
编写ClassCondition,实现Condition接口
public class ClassCondition implements Condition {
/**
*
* @param context 上下文对象。用于获取环境,IOC容器,ClassLoader对象
* @param metadata 注解元对象。 可以用于获取注解定义的属性值
* @return
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//1.需求: 导入Jedis坐标后创建Bean
//思路:判断redis.clients.jedis.Jedis.class文件是否存在
boolean flag = true;
try {
Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
} catch (ClassNotFoundException e) {
flag = false;
}
return flag;
}
}
-
引入jedis包依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency> @Conditional要配合Condition的实现类(ClassCondition)进行使用,编写UserConfig
@Configuration
public class UserConfig {
@Bean
@Conditional(ClassCondition.class)
public User user(){
return new User();
}
}
测试:ApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
@SpringBootApplication
public class SpringbootConditionApplication {
public static void main(String[] args) {
//启动SpringBoot的应用,返回Spring的IOC容器
ApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
Object user = context.getBean("user");
System.out.println(user);
}
}
控制打印出user对象的内存地址,证明SpringIoC中有user对象
03-SpringBoot自动配置-自定义@ConditionOnClass
03.1 注解定义(了解)
-
注解类型的声明部分:
注解在Java中,与类、接口、枚举类似,因此其声明语法基本一致,只是所使用的关键字有所不同
@interface
。在底层实现上,所有定义的注解都会自动继承java.lang.annotation.Annotation接口。public @interface MyAnnotation {
} -
注解类型的实现部分:
根据我们在自定义类的经验,在类的实现部分无非就是书写构造、属性或方法。但是在自定义注解中,其实现部分只能定义一个东西:注解类型元素(annotation type element)。
public @interface MyAnnotation {
public String name();
int age();
int[] array();
}定义注解类型元素时需要注意如下几点:
访问修饰符必须为public,不写默认为public;
该元素的类型只能是基本数据类型、String、Class、枚举类型、注解类型(体现了注解的嵌套效果:ComponentScan)以及上述类型的一位数组;
该元素的名称一般定义为名词,如果注解中只有一个元素,请把名字起为value(后面使用会带来便利操作);
()不是定义方法参数的地方,也不能在括号中定义任何参数,仅仅只是一个特殊的语法;
default代表默认值,值必须和第2点定义的类型一致;
如果没有默认值,代表后续使用注解时必须给该类型元素赋值。
-
@Target
@Target注解,是专门用来限定某个自定义注解能够被应用在哪些Java元素上面的
public enum ElementType {
/** 类,接口(包括注解类型)或枚举的声明 */
TYPE,
/** 属性的声明 */
FIELD,
/** 方法的声明 */
METHOD,
/** 方法形式参数声明 */
PARAMETER,
/** 构造方法的声明 */
CONSTRUCTOR,
/** 局部变量声明 */
LOCAL_VARIABLE,
/** 注解类型声明 */
ANNOTATION_TYPE,
/** 包的声明 */
PACKAGE
} //MyAnnotation被限定只能使用在类、接口或方法上面
@Target(value = {ElementType.TYPE,ElementType.METHOD})
public @interface MyAnnotation {
String name();
int age() default 18;
int[] array();
} -
@Retention
@Retention注解,翻译为持久力、保持力。即用来修饰自定义注解的生命力。
常用:@Retention(RetentionPolicy.RUNTIME)
注解的生命周期有三个阶段:1、Java源文件阶段;2、编译到class文件阶段;3、运行期阶段。同样使用了RetentionPolicy枚举类型定义了三个阶段:
public enum RetentionPolicy {
/**
* (注解将被编译器忽略掉)
*/
SOURCE,
/**
* (注解将被编译器记录在class文件中,但在运行时不会被虚拟机保留,这是一个默认的行为)
*/
CLASS,
/**
* (注解将被编译器记录在class文件中,而且在运行时会被虚拟机保留,因此它们能通过反射被读取到)
*/
RUNTIME
} -
@Documented
@Documented注解,是被用来指定自定义注解是否能随着被定义的java文件生成到JavaDoc文档当中。
03.2 自定义@ConditionOnClass
需求:将类的判断定义为动态的,判断哪个字节码文件存在可以动态指定。(了解)
1.自定义条件注解类,注意:此处@ConditionOnClass为自定义注解
import org.springframework.context.annotation.Conditional;
import java.lang.annotation.*;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
String[] value();
}
2.修改ClassCondition,动态获取类名
public class ClassCondition implements Condition {
/**
* @param context 上下文对象。用于获取环境,IOC容器,ClassLoader对象
* @param metadata 注解元对象。 可以用于获取注解定义的属性值
* @return
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//2.需求: 导入通过注解属性值value指定坐标后创建Bean
//获取注解属性值 value
Map<String, Object> map =
metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
System.out.println(map);
String[] value = (String[]) map.get("value");
boolean flag = true;
try {
for (String className : value) {
Class<?> cls = Class.forName(className);
}
} catch (ClassNotFoundException e) {
flag = false;
}
return flag;
}
}
3.修改UserConfig
@Configuration
public class UserConfig {
@Bean
@ConditionOnClass("com.alibaba.fastjson.JSON")
public User user(){
return new User();
}
}
4.测试User对象的创建
@SpringBootApplication
public class SpringbootConditionApplication {
public static void main(String[] args) {
//启动SpringBoot的应用,返回Spring的IOC容器
ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
Object user = context.getBean("user");
System.out.println(user);
}
}
查看条件注解源码
SpringBoot 提供的常用条件注解:
ConditionalOnProperty:判断配置文件中是否有对应属性和值才初始化Bean
-
application.properties
itcast=itheima
-
UserConfig
@Configuration
public class UserConfig2 {
@Bean
@ConditionalOnProperty(name = "itcast",havingValue = "itheima")
public User user2(){
return new User();
}
}
ConditionalOnClass:判断环境中是否有对应字节码文件才初始化Bean
@Configuration
public class UserConfig3 {
@Bean
@ConditionalOnClass(name = "redis.clients.jedis.Jedis")
//@ConditionalOnClass(Jedis.class)
public User user3(){
return new User();
}
}
ConditionalOnMissingBean:判断环境中没有对应Bean才初始化Bean
04-切换SpringBoot项目内置web服务器
查看继承关系图
排除Tomcat
pom文件中的排除依赖效果
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!--排除tomcat依赖-->
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>
Jetty:基于Java语言编写的一个开源servlet容器,为Jsp和servlet提供了运行环境,可以迅速为一些独立运行的Java应用提供网络和web连接。
引入jetty的依赖
<!--引入jetty的依赖-->
<dependency>
<artifactId>spring-boot-starter-jetty</artifactId>
<groupId>org.springframework.boot</groupId>
</dependency>
05-Enable注解原理(理解)
SpringBoot中提供了很多Enable开头的注解,这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import注解导入一些配置类,实现Bean的动态加载。
SpringBoot是否能直接获取在其他工程中定义的Bean?编写代码测试:
新建springboot-enable-other工程
-
UserConfig
@Configuration
public class UserConfig { @Bean
public User user() {
return new User();
}
} -
新建springboot-enable工程,pom中引入springboot-enable-other
<dependency>
<groupId>com.itheima</groupId>
<artifactId>springboot-enable-other</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency> -
SpringbootEnableApplication
@SpringBootApplication
public class SpringbootEnableApplication { public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args); //获取Bean
Object user = context.getBean("user");
System.out.println(user);
}
} 报错信息:
三种解决方案:
1.使用@ComponentScan扫描com.itheima.config包
@ComponentScan("com.itheima.config")
@SpringBootApplication
public class SpringbootEnableApplication { public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args); //获取Bean
Object user = context.getBean("user");
System.out.println(user);
}
}
2.可以使用@Import注解,加载类。这些类都会被Spring创建,并放入IOC容器
@Import(UserConfig.class)
@SpringBootApplication
public class SpringbootEnableApplication { public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args); //获取Bean
Object user = context.getBean("user");
System.out.println(user);
}
}
3.可以对Import注解进行封装:在springboot-enable-other工程中新建 EnableUser注解类
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}
修改springboot-enable工程中的SpringbootEnableApplication类
@EnableUser
@SpringBootApplication
public class SpringbootEnableApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
//获取Bean
Object user = context.getBean("user");
System.out.println(user);
}
}
Enable注解底层原理是使用@Import注解实现Bean的动态加载
06-@Import详解(了解)
@Enable*底层依赖于@Import注解导入一些类,使用@Import导入的类会被Spring加载到IOC容器中。
@Import提供4中用法:
①导入Bean:@Import(User.class)
②导入配置类:@Import(UserConfig.class)
③导入 ImportSelector 实现类。一般用于加载配置文件中的类:@Import(MyImportSelector.class)
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.itheima.domain.User", "com.itheima.domain.Role"};
}
}
④导入 ImportBeanDefinitionRegistrar 实现类。
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
registry.registerBeanDefinition("user", beanDefinition);
}
}
SpringbootEnableApplication测试代码
/**
* Import4中用法:
* 1. 导入Bean
* 2. 导入配置类
* 3. 导入ImportSelector的实现类。
* 4. 导入ImportBeanDefinitionRegistrar实现类
*/ //@Import(User.class)
//@Import(UserConfig.class)
//@Import(MyImportSelector.class)
//@Import({MyImportBeanDefinitionRegistrar.class}) @SpringBootApplication
public class SpringbootEnableApplication { public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args); /*//获取Bean
Object user = context.getBean("user");
System.out.println(user);*/ /*User user = context.getBean(User.class);
System.out.println(user); Role role = context.getBean(Role.class);
System.out.println(role);*/ /* Object user = context.getBean("user");
System.out.println(user);*/
Map<String, User> map = context.getBeansOfType(User.class);
System.out.println(map);
} }
@EnableAutoConfiguration中使用的是第三种方式:@Import(AutoConfigurationImportSelector.class)
07@EnableAutoConfiguration详解(了解)
-
@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)来加载配置类。 AutoConfigurationImportSelector类定义如下:
-
配置文件位置:META-INF/spring.factories,该配置文件中定义了大量的配置类,当 SpringBoot 应用启动时,会自动加载这些配置类,初始化Bean
读取org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的所有值
-
并不是所有的Bean都会被初始化,在配置类中使用Condition来加载满足条件的Bean
08-自定义starter步骤分析
需求:自定义redis-starter,要求当导入redis坐标时,SpringBoot自动创建Jedis的Bean。
步骤:
①创建 redis-spring-boot-autoconfigure 模块
②创建 redis-spring-boot-starter 模块,依赖 redis-spring-boot-autoconfigure的模块
③在 redis-spring-boot-autoconfigure 模块中初始化 Jedis 的 Bean。并定义META-INF/spring.factories 文件
④在测试模块springboot-enable中引入自定义的 redis-spring-boot-starter 依赖,测试获取 Jedis 的Bean,操作 redis。
09-自定义starter实现
创建redis-spring-boot-autoconfigure配置工程:
-
创建RedisProperties配置文件参数绑定类
@ConfigurationProperties(prefix = "redis")
public class RedisProperties { private String host = "localhost";
private int port = 6379; public String getHost() {
return host;
} public void setHost(String host) {
this.host = host;
} public int getPort() {
return port;
} public void setPort(int port) {
this.port = port;
}
} -
创建RedisAutoConfiguration自动配置类
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
@ConditionalOnClass(Jedis.class)
public class RedisAutoConfiguration { /**
* 提供Jedis的bean
*/
@Bean
@ConditionalOnMissingBean(name = "jedis")
public Jedis jedis(RedisProperties redisProperties) {
System.out.println("RedisAutoConfiguration....");
return new Jedis(redisProperties.getHost(), redisProperties.getPort());
}
} -
在resource目录下创建META-INF文件夹并创建spring.factories。注意:”\ “是换行使用的
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.itheima.redis.config.RedisAutoConfiguration
-
创建redis-spring-boot-starter工程:pom文件中引入redis-spring-boot-autoconfigure
<!--引入configure-->
<dependency>
<groupId>com.itheima</groupId>
<artifactId>redis-spring-boot-autoconfigure</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
10-测试自定义starter
-
在springboot-enable工程中引入自定义的redis的starter
<!--自定义的redis的starter-->
<dependency>
<groupId>com.itheima</groupId>
<artifactId>redis-spring-boot-starter</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency> -
在springboot-enable中的application.properties中的配置参数
redis.host=127.0.0.1
redis.port=6379 -
在SpringbootEnableApplication启动类中测试
@SpringBootApplication
public class SpringbootEnableApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
Jedis jedis = context.getBean(Jedis.class);
System.out.println(jedis);
jedis.set("name","itcast");
String name = jedis.get("name");
System.out.println(name);
}
}
11-SpringBoot事件监听(了解)
11.1 事件监听机制
Java中的事件监听机制主要由事件源、事件对象、事件监听器三个部分组成。
-
事件对象(event object)
一般继承自java.util.EventObject类,封装了事件源对象以及与事件相关的信息。它是在事件源和事件监听器
之间传递信息的。
-
事件源(event source):任意对象Object
具体的事件源,比如说,你点击一个button,那么button就是event source,要想使button对某些事件进行
响应,你就需要注册特定的listener。
-
事件监听器(event listener)
实现java.util.EventListener接口,需要注册在事件源上才能被调用。它监听事件,并进行事件处理或者转发。
11.2 SpringBoot 监听机制
SpringBoot 的监听机制,其实是对Java提供的事件监听机制的封装。
SpringBoot在项目启动时会对几个监听器进行回调,我们可以实现这些监听器接口在项目启动时完成一些操作。
-
实现ApplicationContextInitializer接口
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("ApplicationContextInitializer....initialize");
}
}
MyApplicationContextInitializer的使用要在resource文件夹下添加META-INF/spring.factories
org.springframework.context.ApplicationContextInitializer=com.itheima.springbootlistener.listener.MyApplicationContextInitializer
-
实现SpringApplicationRunListener接口:必须添加构造方法
public class MySpringApplicationRunListener implements SpringApplicationRunListener {
public MySpringApplicationRunListener(SpringApplication application, String[] args) {
}
@Override
public void starting() {
System.out.println("starting...项目启动中");
}
@Override
public void environmentPrepared(ConfigurableEnvironment environment) {
System.out.println("environmentPrepared...环境对象开始准备");
}
@Override
public void contextPrepared(ConfigurableApplicationContext context) {
System.out.println("contextPrepared...上下文对象开始准备");
}
@Override
public void contextLoaded(ConfigurableApplicationContext context) {
System.out.println("contextLoaded...上下文对象开始加载");
}
@Override
public void started(ConfigurableApplicationContext context) {
System.out.println("started...上下文对象加载完成");
}
@Override
public void running(ConfigurableApplicationContext context) {
System.out.println("running...项目启动完成,开始运行");
}
@Override
public void failed(ConfigurableApplicationContext context, Throwable exception) {
System.out.println("failed...项目启动失败");
}
}META-INF/spring.factories配置:
org.springframework.boot.SpringApplicationRunListener=\
com.itheima.springbootlistener.listener.MySpringApplicationRunListener -
实现CommandLineRunner接口
@Component
public class MyCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner...run");
System.out.println(Arrays.asList(args));
}
} -
实现ApplicationRunner接口
/**
* 当项目启动后执行run方法。
*/
@Component
public class MyApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner...run");
System.out.println(Arrays.asList(args.getSourceArgs()));
}
}
自定义监听器的启动时机:
MyApplicationRunner和MyCommandLineRunner都是当项目启动后执行,使用@Component放入容器即可使用
12-SpringBoot流程分析-初始化
配置启动引导类(判断是否有启动主类)
判断是否是Web环境
获取初始化类、监听器类
13-SpringBoot流程分析-run
启动计时器
执行监听器
准备环境
打印banner:可以resource下粘贴自定义的banner
-
创建context
refreshContext(context);
执行refreshContext方法后才真正创建Bean
14-SpringBoot监控-actuator基本使用
①导入依赖坐标
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
②访问http://localhost:8080/actuator,显示结果如下:
{
"_links":{
"self":{
"href":"http://localhost:8080/actuator",
"templated":false
},
"health":{
"href":"http://localhost:8080/actuator/health",
"templated":false
},
"health-component-instance":{
"href":"http://localhost:8080/actuator/health/{component}/{instance}",
"templated":true
},
"health-component":{
"href":"http://localhost:8080/actuator/health/{component}",
"templated":true
},
"info":{
"href":"http://localhost:8080/actuator/info",
"templated":false
}
}
}
http://localhost:8080/actuator/info,显示结果如下:
在application.properties中配置
info.name=zhangsan
info.age=23
http://localhost:8080/actuator/health
# 开启健康检查详细信息
management.endpoint.health.show-details=always
显示结果如下:
{
"status":"UP",
"details":{
"diskSpace":{
"status":"UP",
"details":{
"total":159579508736,
"free":13558104064,
"threshold":10485760
}
},
"redis":{
"status":"UP",
"details":{
"version":"2.4.5"
}
}
}
}
15-SpringBoot监控-actuator开启所有endpoint
开启所有endpoint:在application.properties中配置:
management.endpoints.web.exposure.include=*
开启所有endpoint的返回结果如下:
{
"_links":{
"self":{
"href":"http://localhost:8080/actuator",
"templated":false
},
"auditevents":{
"href":"http://localhost:8080/actuator/auditevents",
"templated":false
},
"beans":{
"href":"http://localhost:8080/actuator/beans",
"templated":false
},
"caches-cache":{
"href":"http://localhost:8080/actuator/caches/{cache}",
"templated":true
},
"caches":{
"href":"http://localhost:8080/actuator/caches",
"templated":false
},
"health-component-instance":{
"href":"http://localhost:8080/actuator/health/{component}/{instance}",
"templated":true
},
"health":{
"href":"http://localhost:8080/actuator/health",
"templated":false
},
"health-component":{
"href":"http://localhost:8080/actuator/health/{component}",
"templated":true
},
"conditions":{
"href":"http://localhost:8080/actuator/conditions",
"templated":false
},
"configprops":{
"href":"http://localhost:8080/actuator/configprops",
"templated":false
},
"env":{
"href":"http://localhost:8080/actuator/env",
"templated":false
},
"env-toMatch":{
"href":"http://localhost:8080/actuator/env/{toMatch}",
"templated":true
},
"info":{
"href":"http://localhost:8080/actuator/info",
"templated":false
},
"loggers":{
"href":"http://localhost:8080/actuator/loggers",
"templated":false
},
"loggers-name":{
"href":"http://localhost:8080/actuator/loggers/{name}",
"templated":true
},
"heapdump":{
"href":"http://localhost:8080/actuator/heapdump",
"templated":false
},
"threaddump":{
"href":"http://localhost:8080/actuator/threaddump",
"templated":false
},
"metrics-requiredMetricName":{
"href":"http://localhost:8080/actuator/metrics/{requiredMetricName}",
"templated":true
},
"metrics":{
"href":"http://localhost:8080/actuator/metrics",
"templated":false
},
"scheduledtasks":{
"href":"http://localhost:8080/actuator/scheduledtasks",
"templated":false
},
"httptrace":{
"href":"http://localhost:8080/actuator/httptrace",
"templated":false
},
"mappings":{
"href":"http://localhost:8080/actuator/mappings",
"templated":false
}
}
}
16-Spring Boot Admin
Spring Boot Admin是一个开源社区项目,用于管理和监控SpringBoot应用程序。 应用程序作为Spring Boot Admin Client向为Spring Boot Admin Server注册(通过HTTP)。UI是的AngularJs应用程序,展示Spring Boot Admin Client的Actuator端点上的一些监控。
SpringBoot Admin 有两个角色,客户端(Client)和服务端(Server)。
以下为创建服务端和客户端工程步骤:
16.1-部署服务端
admin-server:
①创建 admin-server 模块
②导入依赖坐标 admin-starter-server
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-server</artifactId>
<version>2.1.5</version>
</dependency>
③在引导类上启用监控功能@EnableAdminServer
@EnableAdminServer
@SpringBootApplication
public class SpringbootAdminServerApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootAdminServerApplication.class, args);
}
}
application.properties
server.port=9000
16.2-启动客户端
admin-client:
①创建 admin-client 模块
②导入依赖坐标 admin-starter-client
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
<version>2.1.5</version>
</dependency>
③配置相关信息:server地址等
# 执行admin.server地址
spring.boot.admin.client.url=http://localhost:9000
management.endpoint.health.show-details=always
management.endpoints.web.exposure.include=*
④启动server和client服务,访问server:http://localhost:9000/
17-SpringBoot项目部署
SpringBoot 项目开发完毕后,支持两种方式部署到服务器:
第一种方式:jar包(官方推荐),mvn package
第二种方式:war包,更改pom文件中的打包方式为war(了解)
<packaging>war</packaging>
修改启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class SpringbootDeployApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(SpringbootDeployApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringbootDeployApplication.class);
}
}
指定打包的名称
<build>
<finalName>springboot</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>