Spring Boot常用注解和配置

chenzeyu110

于 2020-10-18 19:31:34 发布

阅读量271

点赞数

分类专栏： Java 文章标签： spring boot java

本文链接：https://blog.csdn.net/chenzeyu110/article/details/109148019

版权

Java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

常用注解和配置

为什么需要学习Spring Boot？

复杂的配置
- 项目各种配置耗费大量的时间，因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间
一个是混乱的依赖管理
- 项目的依赖管理也是吃力不讨好的事情，决定项目里要用哪些库并且知道哪些版本和其它库是否有冲突，这些问题非常棘手。依赖管理也是一种损耗，添加依赖不是写应用程序代码，一旦选错依赖的版本，带来的兼容性问题也是生产力杀手。
Spring Boot简化了基于Spring的应用开发，只需要"run"就能创建一个独立地、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。
我们可以使用Spring Boot创建java应用，并使用java -jar启动它，就能够得到一个生产级别的web工程。

Spring Boot的特点

创建独立地Spring应用，为所有Spring的开发者提供一个非常快速的、广泛接受的入门体验
直接嵌入应用服务器，如tomcat、jetty、undertow等；不需要去部署war包
提供固定的启动器依赖去简化组件配置；实现开箱即用（启动器starter，其实就是Spring Boot 提供的一个jar包），通过自己设置参数（.properties或者.yml的配置文件），即可以快速使用。
自动地配置Spring和其它有需要的第三方依赖
提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标、健康监测、外部化配置等
绝对没有代码生成，也无需XML配置。

Spring Boot入门

目标：能够使用Spring Boot搭建项目
实现步骤

创建工程
（Maven工程）
添加依赖（启动器依赖，spring-boot-starter-web）；

   <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
     <!--添加父依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <version>2.1.6.RELEASE</version>
        <artifactId>spring-boot-starter-parent</artifactId>
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>heima-springboot</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
            <java.version>1.8</java.version>
    </properties>
    <dependencies>
       <!--启动器依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

创建启动类

package com.itheima;

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

/**
 * @author chenzeyu
 */
@SpringBootApplication
public class Application {
    public static void main(String [] args){
        SpringApplication.run(Application.class, args);
    }
}

创建处理器Controller

package com.itheima.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author chenzeyu
 */
@RestController
public class HelloController {
    @GetMapping("hello")
    public String hello(){
        return "hello,Spring Boot";
    }
}

测试

小结
Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。

spring-boot-starter-web默认的应用服务器端口是8080

Java代码方式配置

目标：可以使用@Value获取配置文件配置项并结合@Bean注册组件到Spring

如果没有任何的xml，那么我们如果要配置一个Bean怎么办？比如我们要配置一个数据库连接池，以前会这么配置：

<!-- 配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

尝试java配置

java配置主要靠java类和一些注解，比较常用的注解有：

@Configuration:声明一个类作为配置类，代替xml文件
@Bean:声明在方法上，将方法的返回值加入Bean容器，代替<bean>标签
@Value:属性注入
@propertySource:指定外部属性文件

步骤：

添加依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

创建数据库
创建数据库连接参数的配置文件jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.224.120:3306/heima_leadnews
jdbc.username=root
jdbc.password=123456

创建配置类

package com.itheima.config;


import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;

/**
 * @author chenzeyu
 */
@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("{jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

解读

@Configuration：声明JdbcConfig是一个配置类
@PropertySource：指定属性文件的路径是:classpath:jdbc.properties
通过@Value为属性注入值
通过@Bean将dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。

然后就可以在任意位置通过@Autowired注入DataSource。

改造处理器类注入数据源并使用

Spring Boot属性注入方式

目标：能够使用@ConfigurationProperties实现Spring Boot配置文件配置项读取和应用
分析：
需求：将配置文件中的配置项读取到一个对象中；
实现：可以使用Spring Boot提供的注解@ConfigurationProperties，该注解可以将Spring Boot的配置文件（默认必须为application.properties或者application.yml）中的配置项读取到一个对象中。
实现步骤：
1、创建配置项类JdbcProperties类，在该类名上面添加@ConfigurationProperties；
2、将jdbc.properties修改名称为application.properties；
3、将JdbcProperties对象注入到JdbcConfig；
4、测试

属性文件

属性文件的名称有变化，默认的文件名必须是：application.properties或者application.yml

Spring Boot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

package com.itheima.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author chenzeyu
 * ConfigurationProperties:从application配置文件中读取配置项
 * prefix:表示配置项的前缀
 * 配置项类中的类变量名必须要与前缀之后的配置项名称保持松散绑定(相同)
 */
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    //省略getters和setters
}

在类上通过@ConfigurationProperties注解声明当前类为属性读取类
prefix="jdbc"读取属性文件中，前缀为jdbc的值
在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致
需要注意的是，这里我们并没有指定属性文件的地址，所以我们需要把jdbc.properties名称改为application.properties，这是Spring Boot默认读取的属性文件名。

在这里插入图片描述
如果需要上述的提示，则可以在pom.xml文件中添加如下依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <!--不传递依赖-->
            <optional>true</optional>
        </dependency>

JdbcConfig

package com.itheima.config;


import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 * @author chenzeyu
 */
@Configuration
/**@PropertySource("classpath:application.properties")*/
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
        dataSource.setUrl(jdbcProperties.getUrl());
        dataSource.setUsername(jdbcProperties.getUsername());
        dataSource.setPassword(jdbcProperties.getPassword());
        return dataSource;
    }
}

通过@EnableConfigurationProperties(JdbcProperties.class)来声明要使用JdbcProperties这个类的对象
要使用配置的话，可以通过以下方式注入jdbcProperties
- @Autowired注入

@Autowired
private JdbcProperties prop;

构造函数注入

private JdbcProperties prop;
public JdbcConfig(JdbcProperties prop){
    this.prop = prop;
}

声明有@Bean的方法参数注入

@EnableConfigurationProperties(JdbcProperties.class)
@Bean
public DataSource dataSource(JdbcProperties prop){
    //...
}

@ConfigurationProperties和@Value

优势：

Relaxed binding：松散绑定
- 不严格要求属性文件中的属性名与成员变量名一致。支持驼峰、中划线、下划线等转换，甚至支持对象引导。比如：user.friend.name:代表的是user对象中的friend属性中的name属性，显然friend也是对象。@Value注解就难以完成这样的注入方式
meta-data support：元数据支持，帮助IDE生成属性提示（写开源框架会用到）。

小结

使用@ConfigurationProperties编写配置项类将配置文件中的配置项设置到对象中

package com.itheima.config;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author chenzeyu
 * ConfigurationProperties:从application配置文件中读取配置项
 * prefix:表示配置项的前缀
 * 配置项类中的类变量名必须要与前缀之后的配置项名称保持松散绑定(相同)
 */
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    //getters和setters方法省略

使用@ConfigurationProperties在方法上使用

@Configuration
public class JdbcConfig {
    @Bean
    @ConfigurationProperties(prefix="jdbc")
    public DataSource dataSource(){
        return new DruidDataSource();
    }
}

我们直接把@ConfigurationProperties(prefix="jdbc")声明在需要使用的@Bean方法上，然后Spring Boot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：该类必须有对应属性的set方法。

Yaml配置文件

格式如下:

jdbc:
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springboot_test
    username: root
    password: root

把application.properties修改为application.yaml进行测试。

如果两个配置文件都有，会把两个文件的配置合并，如果有重复性，以properties中的为准。
如果是配置数组、list、set等结构的内容，那么在yml文件中格式为:
key:

value1
value2

yml配置文件的特征：

树状层级结构展示配置项；
配置项之间如果有关系的话需要分行空两格；
配置项如果有值的话，那么需要在":"之后空一格再写配置项值

多个yml配置文件

Spring Boot中允许多个yml配置文件，这些配置文件的名称必须为application-***.yml，并且这些配置文件必须在application.yml配置文件中激活之后才可以使用。

如果proerpties和yaml配置文件同时存在在Spring Boot项目中；那么这两类配置文件都有效。两个配置文件中如果存在同名的配置项的话会以properties文件的为主。

自动配置原理

使用Spring Boot之后，开发任务变的简单了，如何做到的呢？

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

特别的地方有两个：

注解：@SpringBootApplication
run方法：SpringBootApplication.run()

总结

Spring Boot为我们提供了默认配置，而默认配置生效的步骤：

@EnableAutoConfiguration注解会去寻找META-INF/spring.factories文件，读取其中以EnableAutoConfiguration为key的所有类的名称，这些类就是提前写好的自动配置类
这些类都声明了@Configuration注解，并且通过@Bean注解提前配置了我们所需要的一切实例
但是，这些配置不一定生效，因为有@ConditionalOn注解，满足一定条件才会生效。比如条件之一：是一些相关的类要存在
类要存在，我们只需要引入了相关依赖（启动器），依赖有了条件成立，自动配置生效。
如果我们自己配置了相关的Bean，那么会覆盖默认的自动配置的Bean。
我们还可以通过配置application.yml文件，来覆盖自动配置中的属性。

（1）启动器

所以，我们如果不想配置，只需要引入依赖即可，而依赖版本也无需操心，因为只要引入了Spring Boot提供的starter（启动器），就会自动管理依赖及版本了。

因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器

（2）全局配置

Spring Boot的默认配置都会读取默认属性，这些属性可以通过自定义的application.properties文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。

因此，玩Spring Boot的第二件事情，就是通过application.properties来覆盖默认属性值，形成自定义配置。

如果properties和yml文件都存在，如果有重叠属性，默认以Properties优先。遇到需要修改的组件的配置项流程为：

在这里插入图片描述

lombok应用

目的：使用lombok的注解实现pojo类的简化
分析：使用Spring Boot整合SSM工程：需要使用到数据库数据。

将数据库表导入到数据库中（Springboot_test）；
编写数据库表对应的实体类；一般情况下需要编写get/set/toString等这些方法会耗时，且实体类会较为臃肿。可以使用lombok插件进行简化。lombok是一个插件工具类包，提供了一些注解@Data、@Getter等注解去简化实体类中的构造方法、get/set等方法的编写。

小结
在Bean上使用：

@Data：自动提供getter和setter、hashCode、equals、toString等方法
@Getter：自动提供getter方法
@Setter：自动提供setter方法
@Slf4j：自动在bean中提供log变量，其实用的是slf4j的日志功能。

Spring Boot整合-Spring MVC端口和静态资源

目标：修改tomcat的端口和访问项目中的静态资源
分析：

修改tomcat端口
查询**Properties，设置配置项（前缀+类变量名）到application配置文件中
访问项目中的静态资源
静态资源放置的位置；放置静态资源并访问这些资源

修改端口

修改application.yml配置文件，添加如下的配置：

# 映射端口
server:
    port: 80

访问静态资源

现在我们的项目是一个jar工程，没有webapp，我们的静态资源应该放在哪里？

在ResourceProperties类下面，定义了静态资源的默认查找路径：

private static final String[] CLASSPATH_RESOURCE_LOCATIONS = 
new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};

静态资源路径为：

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public

只要静态资源放在这些目录中的任何一个，SpringMVC都会进行处理。
习惯会把静态资源放在classpath:/static/目录下。

Spring Boot整合-SpringMVC拦截器

目标
可以在Spring Boot项目中配置自定义SpringMVC拦截器
分析
1.编写拦截器（实现HandlerInterceptor）
2.编写配置类实现WebMvcConfigurer，在该类中添加各种组件；
3.测试

拦截器不是一个普通的属性，而是一个类，所以需要用到java配置方式了。

如果想要保持SpringBoot的一些默认MVC特征，同时又想自定义一些MVC配置（包括：拦截器、格式化器、视图控制器、消息转换器等），你应该让一个类实现WebMvcConfigurer，并且添加@Configuration注解，但是千万不要加@EnableWebMvc注解，如果你想要自定义HandlerMapping、HandlerAdapter、ExceptionResolver等组件，可以创建一个WebMvcRegistrationsAdaptor实例来提供以上组件。
如果你想要完全自定义SpringMVC，不保留SpringBoot提供的一切特征，你可以自定义类并且添加@Configuration注解和@EnableWebMvc注解。

package com.itheima.interceptor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author chenzeyu
 * 拦截器类
 */

@Slf4j
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("这是prehandler方法");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("这是postHandle方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("这是afterCompletion方法");
    }
}

package com.itheima.config;

import com.itheima.interceptor.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author chenzeyu
 * 拦截器配置类
 */
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    /**
     *注册拦截器
     */
    @Bean
    public MyInterceptor myInterceptor(){
        return new MyInterceptor();
    }
    /**添加拦截器到Spring Mvc拦截器链
     *
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor()).addPathPatterns("/*");
    }
}

Spring Boot整合-事务和连接池

目标
配置Spring Boot自带默认的hikari数据库连接池和使用@Transactional注解进行事务配置

分析

事务配置
- 添加事务相关的启动器依赖，mysql相关依赖
- 编写业务类UserService使用事务注解@Transactional
数据库连接池hikari配置
- 只需要在application配置文件中指定数据库相关参数

Spring中的jdbc连接和事务是配置中的重要一环，在SpringBoot中如何处理呢？
无需进行任何处理，只要找到Spring Boot提供的启动器即可，在pom.xml文件中添加如下依赖：

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

当然不要忘了数据库驱动，SpringBoot不知道我们用的什么数据库，这里选择MySQL；同样在pom.xml文件中添加如下依赖：

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>

至于事务，SpringBoot中通过注解来控制，在使用的时候将@Transactional设置在对应的类或者方法上即可。

Spring Boot整合-Mybatis

目标
配置Mybatis在Spring Boot工程中的整合包，设置mybatis的实体类别名，输出执行sql语句配置项
分析

添加启动器依赖

<!--mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.1</version>
</dependency>

配置Mybatis：实体类别名包，日志、映射文件等；

# mybatis配置
mybatis:
    # 实体类别名包路径
    type-aliases-package: com.itheima.pojo
    # 映射文件路径
    # mapper-locations: classpath:mappers/*.xml
    configuration:
        # 控制台输出执行sql
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

配置MapperScan

这里没有配置mapper接口扫描包，因此，我们需要给每一个Mapper接口添加@Mapper注解，才能被识别。

@Mapper
public interface UserMapper {
}

或者，也可以不加注解，而是在启动类上添加扫描包注解（推荐）：

@SpringBootApplication
@MapperScan("com.itheima.mapper")
public class Application {
public static void main(String[] args) {
// 启动代码
SpringApplication.run(Application.class, args);
}
}

Spring Boot 整合-通用Mapper

通用Mapper编写了启动器，直接引入即可。

<!-- 通用mapper -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.1.5</version>
</dependency>

一旦引入了通用Mapper的启动器，会覆盖Mybatis官方启动器的功能，需要移除对官方Mybatis启动器的依赖。

编写UserMapper

package com.itheima.mapper;
import com.itheima.pojo.User;
import tk.mybatis.mapper.common.Mapper;
public interface UserMapper extends Mapper<User> {
}

把启动类上的@MapperScan修改为通用mapper中自带的

在这里插入图片描述

在User实体类上架JPA注解

@Data
@Table(name = "tb_user")
public class User{
    // id
    @Id
    //开启主键自动回填
    @KeySql(useGeneratedKeys = true)
    private Long id;
    // 用户名
    private String userName;
    // 密码
    private String password;
    // 姓名
    private String name;
    // 年龄
    private Integer age;
    // 性别，1男性，2女性
    private Integer sex;
    // 出生日期
    private Date birthday;
    // 创建时间
    private Date created;
    // 更新时间
    private Date updated;
    // 备注
    private String note;
}

对UserService代码进行改造

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    public User queryById(Long id){
        //根据id查询
        return userMapper.selectByPrimaryKey(id);
    } 
    @Transactional
    public void saveUser(User user){
        System.out.println("新增用户...");
        userMapper.insertSelective(user);
    }
}

启动测试，对HelloController进行改造：

@RestController
public class HelloController {
    @Autowired
    private UserService userService;
    /**
    * 根据id获取用户
    * @param id 用户id
    * @return 用户
    */
    @GetMapping("/user/{id}")
    public User queryById(@PathVariable Long id){
        return userService.queryById(id);
    }
}

Junit测试

在SpringBoot项目中如果要使用Junit进行单元测试，则需要添加如下的依赖：

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

在测试包下面编写测试类

package com.itheima.service;
import com.itheima.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Date;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;
    @Test
    public void queryById() {
        User user = userService.queryById(1L);
        System.out.println("user = " + user);
    } 
    @Test
    public void saveUser() {
        User user = new User();
        user.setUserName("test");
        user.setName("test");
        user.setPassword("123456");
        user.setSex(1);
        user.setAge(20);
        user.setCreated(new Date());
        userService.saveUser(user);
}
}

整合Redis

在pom.xml文件中添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置application.xml:

在这里插入图片描述

Spring Boot项目部署

项目打包

添加项目的pom.xml插件，在pom.xml中显示的加入插件spring-boot-maven-plugin，否则无法产生jar清单文件，导致打出来的jar无法使用命令运行。

<build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

使用maven的命令package打包

在这里插入图片描述
之后在项目下的target目录下将有如下jar包：

在这里插入图片描述

运行

打出来的包，使用命令:java -jar 包全名 。

java -jar heima-springboot-1.0-SNAPSHOT.jar

SpringBootServletInitializer

Spring Boot提供了内置的tomcat、undertow、jetty三种Servlet Web容器。让我们开箱即用，可以以JAR启动一个Web应用。但是在某些场景中我们可能还需要将我们的Spring Boot容器以War的形式进行传统的部署。这时我们就需要通过借助于SpringBootServletInitializer来实现。

SpringBootServletInitializer是WebApplicationInitializer的实现，它从部署在Web容器上的传统WAR包运行Spring Boot应用。该类将Servlet、Filter、ServletContextInitializer Bean从应用程序上下文绑定到服务器。SpringBootServletInitializer类还允许我们通过覆盖SpringApplicationBuilder configure(SpringApplicationBuilder application)方法来配置由Servlet容器运行的应用程序。

Spring Boot War部署

默认打jar包<packaging>jar</packaging>我们改为打war包<packaging>war</packaging>

方法一

Spring Boot内嵌的Tomcat默认已经集成在spring-boot-starter-web包里，所以我们要排除它。

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-tomcat</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

此方式排除了Servlet Api依赖，SpringBootServletInitializer需要依赖Servlet Api，因此需要加上。
务必要注意versionNumber版本要跟你外置的Tomcat版本兼容。

            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${versionNumber}</version>
                <scope>provided</scope>
            </dependency>

方法二

通过引入``

chenzeyu110

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot常用注解和配置

常用注解和配置**为什么需要学习Spring Boot？****Spring Boot的特点**为什么需要学习Spring Boot？复杂的配置项目各种配置耗费大量的时间，因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间一个是混乱的依赖管理项目的依赖管理也是吃力不讨好的事情，决定项目里要用哪些库并且知道哪些版本和其它库是否有冲突，这些问题非常棘手。依赖管理也是一种损耗，添加依赖不是写应用程序代码，一旦选错依赖的版本，带来的兼容性问
复制链接

扫一扫

专栏目录