spring-boot 快速构建热部署自动配置原理配置文件整合SpringMVCredisjunitmybatis打包部署

Posted 2022-12-14 halulu.me

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了spring-boot 快速构建热部署自动配置原理配置文件整合SpringMVCredisjunitmybatis打包部署相关的知识，希望对你有一定的参考价值。

文章目录

spring-boot

spring-boot的好处：

自动配置（想要使用哪个功能，需要的配置帮你完成了）
起步依赖（想要使用哪个功能，添加一个依赖就搞定了）
辅助功能（例如嵌入式服务器）

快速构建spring-boot

pom-maven

<?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>

    <!--1、指定父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

    <groupId>cn.itcast</groupId>
    <artifactId>springboot-demo1</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <!--web启动器，将项目变成web项目，集成了springMVC、tomcat、json-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

启动类（spring-boot内置了服务器）

启动类SpringBootApplication默认扫描当前类的包及其子包。（只要在当前类的包下，都会再服务器内运行，不在这个包就无法运行）

@SpringBootApplication
public class DemoApplication 
    public static void main(String[] args) 
        // 参数1-启动类的class，参数2-jvm运行参数
        SpringApplication.run(DemoApplication.class, args);

@RestController
public class HelloController 

    @RequestMapping("/hello")
    public String test()
        return "hello";

SpringBoot 热部署

SpringBoot热部署的作用

作用：当项目在运行过程中，修改了代码无需手动重启服务，它能够监听class文件的改动，自动重启服务（适用于开发环境）

<!-- 热部署配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

SpringBoot 自动配置原理分析

springboot项目在启动过程中，会加载项目中所有的META-INF/Spring.factories文件，文件中包含了很多提前写好的自动配置类，自动配置类不一定全部生效，因为上面还存在一个条件注解，必须满足相关的条件，才能生效，我们只需要加入一个相关的启动器依赖，就可以使得条件注解生效，配置类也就生效了。

spring.factories，该文件下列举了非常多的类的全路径，都是SpringBoot为已经集成的各个框架/组件（比如Reids、ElasticSearch）提供的配置类

打开RedisAutoConfiguration

若想要让Redis相关的配置生效，我们就需要添加Redis的启动器依赖（可插拔思想）。

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

SpringBoot 配置文件

1、配置文件分类：

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。

在同一级目录下优先级为：properties > yml > yaml，
相同的属性取优先级高的文件中的值，不同的属性取并集（项目中一般只用一种文件）。

2、YAML

YAML全称是 YAML Ain’t Markup Language 。

YAML 基本语法

大小写敏感
数据值前边必须有空格，作为分隔符
使用缩进表示层级关系
缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab 对应的空格数目可能不同，导致层次混乱）。
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
# 表示注释，从这个字符一直到行尾，都会被解析器忽略。

YAML 数据格式

纯量：

注意：springboot中$user.name和$username指的是当前系统的用户名（无法被覆盖，即使在yaml中重写数值，也依旧是当前系统用户名）

map：

数组|list:

参数引用:

3、读取配置文件内容

application.yml

name: 张三
age: 18

(1)@Value

@RestController
public class YmalController 
    @Value("$name")
    private String name;

    @Value("$age")
    private int age;

    @RequestMapping("/yml")
    public String test()
        System.out.println("name = " + name);
        System.out.println("age = " + age);

        return "yml";

注意事项：1、必须在Bean中使用；2、只能读取纯量类型

(2)Environment

@RestController
public class YmalController2 
    @Autowired
    private Environment environment;

    @RequestMapping("/ymal2")
    public String test()
        String name = environment.getProperty("name");
        System.out.println(name);
        String age = environment.getProperty("age");
        System.out.println(age);
        return "ymal2";

注意事项：1、必须在Bean中使用；2、只能读取纯量类型

(3)@ConfigurationProperties

person:
  name: 张三
  age: 18

@RestController
@ConfigurationProperties(prefix = "person")
public class PersonController 

    private String name;
    private int age;

    public void setName(String name) 
        this.name = name;
    

    public void setAge(int age) 
        this.age = age;
    

    @RequestMapping("/person")
    public String test()
        System.out.println("name = " + name);
        System.out.println("age = " + age);

        return "person";

1、必须在Bean中使用；2、必须为属性提供set方法

（4）@ConfigurationProperties + @EnableConfigurationProperties

@ConfigurationProperties(prefix = "person")
public class PersonProperties 
    private String name;
    private int age;

    public PersonProperties() 
    

    public PersonProperties(String name, int age) 
        this.name = name;
        this.age = age;
    

    /**
     * 获取
     * @return name
     */
    public String getName() 
        return name;
    

    /**
     * 设置
     * @param name
     */
    public void setName(String name) 
        this.name = name;
    

    /**
     * 获取
     * @return age
     */
    public int getAge() 
        return age;
    

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) 
        this.age = age;
    

    public String toString() 
        return "Personname = " + name + ", age = " + age + "";

@RestController
@EnableConfigurationProperties(PersonProperties.class)
public class PersonController2 

    @Autowired
    private PersonProperties personProperties;

    @RequestMapping("/person2")
    public String test()
        int age = personProperties.getAge();
        String name = personProperties.getName();
        System.out.println("age = " + age);
        System.out.println("name = " + name);
        return "person2";

4、配置文件的使用

多配置文件方式

application-dev.yml（开发环境）、application-test.yml（测试环境）、application-test.yml（生产环境），设置不同的端口号在不同的运行环境下运行

配置文件激活：

第一种方式：（不常用，因为需要重写打包）

第二种方式：虚拟机参数（常用）

虚拟机参数（-Dspring.profiles.active=XXX）

第三种方式：命令行参数

命令行参数（–spring.profiles.active=XXX）

SpringBoot 整合SpringMVC

默认的静态资源访问路径有四个:

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/（常用）
classpath:/public （常用）

拦截器

自定义拦截器类，实现HandlerInterceptor接口
创建配置类，实现WebMvcConfigurer接口，将拦截器添加到已有的SpringMVC配置上

public class LoginInterceptor implements HandlerInterceptor 

    @Override
    // 前置处理，返回true代表放行，false代表拦截
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
        System.out.println("前置处理");
        return true;
    

    @Override
    // 后置处理
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception 
        System.out.println("后置处理");
    

    @Override
    // 渲染后处理
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception 
        System.out.println("渲染后处理");

@Configuration
public class MvcConfiguration implements WebMvcConfigurer 

    /**
     * 重写接口中的addInterceptors方法，添加自定义拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) 
        // 添加拦截器，通过addPathPatterns来添加拦截路径
        // **代表拦截多层，*代表只拦截一层
        registry.addInterceptor(new LoginInterceptor()).addPathPatterns("/**");

**代表拦截多层，*代表只拦截一层

SpringBoot 整合Mybatis

        <!--mybatis启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

        <!--mysql驱动包，在父工程已经指定版本号了，但是是8.0.16，我们安装的是5.7的数据库，因此需要覆盖版本号-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

application.yml

spring:
  # 指定数据库连接池信息
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_db
    username: root
    password: 123456
    
mybatis:
  # 配置类型别名包扫描
  type-aliases-package: cn.itcast.pojo
  # sql语句映射文件路径，注意冒号后面没有空格，代表是一个整体
  mapper-locations:
    - classpath:mappers/*.xml
  # 字段返回值使用驼峰映射
  configuration:
    map-underscore-to-camel-case: true

# SpringBoot配置控制，指定日志输出级别，可以打印mybatis的sql语句
logging:
  level:
    cn.itcast: debug # 键值对，key一般使用最外层的包名

基包扫描dao层

@SpringBootApplication
@MapperScan(basePackages = "com.halulu.dao")
public class DemoApplication 
    public static void main(String[] args) 
        SpringApplication.run(DemoApplication.class,args);

Springboot整合Junit

<!-- 配置test启动器(自动整合spring-test、junit) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

// 指定运行环境是Spring环境
@RunWith(SpringRunner.class)
// 如果测试类所在目录是启动类所在目录的同级子级下可以省略启动类
// @SpringBootTest(classes = DemoApplication.class)
@SpringBootTest
public class SickerServiceTest 

    @Autowired
    private SickerService sickerService;
    @Test
    public void test()
        List<Sicker> sickerList = sickerService.findAll();
        System.out.println(sickerList);

SpringBoot 整合Redis

<!-- 配置redis启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

# 配置Redis
spring:
  redis:
    host: localhost # 主机
    port: 6379      # 端口在这里插入代码片


@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTemplateTest 
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Test
    public void redisTest()
        // 设置值
        redisTemplate.opsForValue().set("name", "admin");
        
        // 获取值
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
        
        // 删除值
        redisTemplate.delete("name");

SpringBoot 打包部署

1、打成Jar包

<build>
    <plugins>
        <!-- 配置spring-boot的maven插件
                1. 用它可以运行spring-boot项目
                2. 需要用它构建打jar、war资料
             -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

# 清理、打包
mvn clean package
# 清理、打包 跳过测试
mvn clean package -Dmaven.test.skip=true

命令行执行jar包

java -jar xxx.jar

2、打成war包

<!-- 打包方式(默认为jar) -->
<packaging>war</packaging>


<!-- 指定scope为provided: 代表打包时，不需要它的依赖jar包(我们有自己的tomcat) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

自定义Web应用入口类，继承SpringBootServletInitializer(相当于web.xml)

// web.xml
public class WebServletInitializer extends SpringBootServletInitializer 
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) 
        builder.sources(DemoApplication.class);
        return builder;

执行打包命令

# 清理、打包
mvn clean package

# 清理、打包 跳过测试
mvn clean package -Dmaven.test.skip=true

部署项目xxx.war，将其放置tomcat的webapps下，启动tomcat即可
以上是关于spring-boot 快速构建热部署自动配置原理配置文件整合SpringMVCredisjunitmybatis打包部署的主要内容，如果未能解决你的问题，请参考以下文章

Intellij IDEA 使用jrebel运行spring-boot并实现自动编译进行热部署

SpringBoot配置文件（热部署Properties和YAML自定义属性对象集合）

spring-boot简介

spring-boot学习

Spring Boot Devtools热部署

Intellij idea 配置热部署