SpringBoot入门

一.快速入门

1.1 传统方式搭建

• 创建maven工程,导入坐标
• 编写controller
• 编写引导程序

实现

• 创建maven工程，导入坐标

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

<!--依赖-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

• 编写业务代码

@RestController
public class HelloController {
    /**
     * 
     * @return
     */
    @RequestMapping("/hello")
    public String sayHello(){
        return "hello, Spring Boot";
    }
}

• 编写引导程序

该程序是发布springboot应用的入口（只需要run一下）

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

• 测试

在DemoApplication里运行主方法

访问：http://localhost:8080/hello

1.2 Spring initializr方式

• 创建Spring initializr工程，勾选坐标
• 编写controller

实现

• 创建spring initializr工程

通过idea工具创建工程时，不要选择maven而是要选择spring initializr。然后去勾选相关依赖。

• 编写controller

@RestController
public class HelloController {


    /***
     * 请求 /hello  输出hello springboot!
     * @return
     */
    @RequestMapping(value = "/hello")
    public String hello(){
        return "hello springboot! demo2!";
    }

}

• 测试
  
  访问：http://locahost:8080/hello

二.SpringBoot原理分析

• SpringBoot-起步依赖 pom.xml
• SpringBoot-自动配置 配置文件

2.1 SpringBoot-起步依赖

我们可以打开pom.xml中的parent,并查看spring-boot-starter-parent信息。

从上面的spring-boot-dependencies的pom.xml中可以看出，坐标的版本，依赖管理，插件管理已经预先定义好了。SpringBoot工程继承Spring-boot-starter-parent（父工程）后，已经锁定了版本等配置。起步依赖的作用是进行依赖传递 。用啥取啥，随用随取即可。我们开发中彻底不用关心：jar包的版本、依赖等问题了，大大降低版本冲突，版本过期，更新一个jar一下就需要升级一个tree的jar包。

相当于我们之前学习的过程中创建的父工程，在之前创建的父工程中，其中一个功能是用来统一管理jar包。这里的父工程其实作用是一样的。

1.parent的版本和jar包管理,2.以及坐标引入利用maven的依赖传递的性质,共同实现了起步依赖

3.2 SpringBoot-自动配置

(1)@SpringBootApplication

该注解是一个组合注解，包括如下注解

• @SpringBootConfiguration：与之前@Configuration注解一样，声明为一个配置类
• @ComponentScan：spring IoC容器的扫描包，默认扫描引导程序下的包以及子包，如果我们写的程序不在该包范围内，可以通过该注解指定。
• @EnableAutoConfiguration：springboot实现自动化配置的核心注解。

(2)@SpringBootConfiguration

通过这段我们可以看出，在这个注解上面，又有一个@Configuration注解。通过上面的注释阅读我们知道：这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了@Configuration的类，并且读取其中的配置信息。而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

(3)@EnableAutoConfiguration

@EnableAutoConfiguration告诉Spring Boot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

自动配置：自己一般不用修改配置，默认的配置都给配好了。

小结

• 工程继承了spring-boot-starter-parent工程，spring-boot-starter-parent继承了spring-boot-dependencies,spring-boot-dependencies实现了jar包管理和版本锁定。工程引入spring-boot-starter-web依赖，该工程又依赖了其他web所需的jar包，maven依赖有传递性。
• 通过@SpringBootApplication注解完成自动配置，会将当前类作为一个配置类，并且会根据我们所引入的依赖猜测我们的配置，并实现自动配置。

三. SpringBoot配置文件使用

3.1 application.properties

(1) 语法

• 格式：key=value

• 如果是修改SpringBoot中的默认配置，那么key则不能任意编写，必须参考SpringBoot官方文档。

• application.properties官方文档：

  https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/

(2)案例

在resources目录下新建application.properties

#tomcat port
server.port=18081
#app context
server.servlet.context-path=/demo

此时运行，tomcat端口发生了变化，每次请求，需要加上/demo。

3.2 application.yml(application.yaml)

(1)语法

普通数据：

说明：
key: value（注意：冒号有一个空格）

示例：
name: tom

对象数据或map

#说明：
key:
  key1: value1
  key2: value2
#示例：
user:
  xiaobai:
    name: tom
	age: 23
	addr: beijing

集合数据1：存储简单类型

说明：
key:
	value1
	value2
或：
key: value1,value2

示例：
city:
	beijing
	anhui
	jiangxi
	shenzhen
或：
city: [beijing,anhui,jiangxi,shenzhen]

集合数据2：存储对象类型

说明：
key:
	key1: vlaue1
	key2: value2
	
示例：
student:
	- name: zhangsan
	  age: 23
	  addr: BJ
	- name: lisi
	  age: 25
	  addr: SZ
	

(2)案例

将springboot-demo1中的application.properties换成application.yml，代码如下：

server:
  port: 18081
  servlet:
    context-path: /demo

如图：

3.3 配置文件与配置类的属性映射方式(了解)

(1)使用注解@Value映射

@value注解将配置文件的值映射到Spring管理的Bean属性值

(2)使用注解@ConfigurationProperties映射

通过注解@ConfigurationProperties(prefix=’'配置文件中的key的前缀")可以将配置文件中的配置自动与实体进行映射。

使用@ConfigurationProperties @Compment方式必须提供Setter方法，使用@Value注解不需要Setter方法。

注意使用该注解需要引入如下依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

3.4 热部署

dev–开发环境

test–测试环境

pro–生产环境

(1)配置pom

针对每次修改代码都需要重新发布程序，在springboot中提供了热部署插件。只需要在pom文件中添加热部署依赖即可，如下所示

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

同时需要给工程添加一个插件

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork> <!-- 如果没有该配置，devtools不会生效 -->
            </configuration>
        </plugin>
    </plugins>
</build>

(2)开启自动构建工程

1、在idea的settings中勾选自动构建工程选项即可。如图所示：

2、Shift + Ctrl + Alt + /：选择registry，弹出框选择== compiler.automake.allow.when.app.running== 勾选上即可。

测试访问<http://localhost:18081/demo/hello> 后台更改数据，无需重启服务，直接刷新页面就可以看到最新数据。

小结

• application.properties
• application.yml：2个空格表示当前对象的子属性，赋值 方式 属性名+：+空格+值
• @value直接将配置文件中指定key的数据注入，@ConfigurationProperties可以根据key将属性注入到指定对象中。
• 热部署插件开启步骤：
  • 添加热部署依赖，添加插件包
  • IDEA开启自动编译

四. SpringBoot与其他框架集成

• 集成mybatis
• 集成Spring Data Redis
• 集成Spring Data JPA

3.1 集成mybatis

3.1.1 需求

​ 使用MyBatis实现查询所有用户信息

3.1.2 步骤

• 0.数据库表准备
• 1.搭建springboot工程勾选依赖坐标
• 2.编写pojo
• 3.创建Dao接口以及Dao映射文件
• 4.编写Service调用Dao
• 7.编写Controller调用Service
• 8.编写配置文件
• 8.编写SpringBoot引导类
• 9.发布测试

3.1.3 实现

​ 1 数据库表

-- ----------------------------
-- Table structure for `t_user`
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(50) DEFAULT NULL,
`password` varchar(50) DEFAULT NULL,
`address` varchar(50) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `t_user` VALUES ('1', 'zhangsan', '123', '北京');
INSERT INTO `t_user` VALUES ('2', 'lisi', '123', '上海');

​ 2 创建工程，勾选依赖坐标

pom.xml

<?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>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.6.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.itheima</groupId>
	<artifactId>springboot-mybatis-redis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot-mybatis-redis</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.1</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
            <!--<version>5.1.34</version>-->
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

3 编写pojo

public class User implements Serializable{

    private Integer id;
    private String username;
    private String password;
    private String address;
    // TODO getters、setters
}

​ 4 编写mapper接口以及映射文件

• 在接口中添加@Mapper注解（标记该类是一个Mapper接口，可以被SpringBoot自动扫描）

@Mapper
public interface UserMapper {

    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();
}

• 编写映射文件：在工程的resources/mapper目录下创建UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.itheima.mapper.UserMapper">

    <!--查询所有用户-->
    <select id="findAll" resultType="user">
        SELECT * FROM t_user
    </select>

</mapper>

• 编写service接口以及实现类

public interface UserService {
    /***
     * 查询所有
     * @return
     */
    List<User> findAll();
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 查询所有
     * @return
     */
    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }
}

5 编写controller

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    /***
     * 查询所有用户
     * @return
     */
    @RequestMapping("/findAll")
    public List<User> findAll(){
        return userService.findAll();
    }
}

6 配置application.properties

#连接数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#mysql 5.6
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost/springboot?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=itcast
#mybatis别名
mybatis.type-aliases-package=com.itheima.domain
#加载映射文件
mybatis.mapper-locations=classpath:mapper/*.xml
#设置日志，com.itheima.mapper：只查看该包下程序的日志
logging.level.com.itheima.mapper=debug

7 发布程序并访问

访问地址：http://localhost:8080/user/find

小结

• SpringBoot集成MyBatis
  • 引入相关依赖
  • 编写Dao接口，接口上需要添加@Mapper注解
  • 配置文件中配置数据源、指定别名包、映射文件路径
• SpringBoot集成MyBatis实现查询所有用户信息
  • 编写Dao接口和接口对应的XML映射文件
  • 编写对应的Service，注入Dao，并调用Dao
  • 编写Controller，调用Service

3.2 集成Spring Data Redis

3.2.1 需求

查询用户，先去Redis中查询，如果有数据直接返回数据，没数据，则查询数据库，并存入到Redis缓存，再返回数据

springdata redis,一套模板,redisTemplate模板,提供对redis进行增删查操作的所有模板操作内容;

3.2.2 步骤

• 搭建环境
• 添加坐标
• 配置application.properties
• 修改service接口实现类
• 测试

3.2.3 实现

• 安装redis

• 添加坐标

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

• 配置application

#redis，端口可以不填，默认就是6379
spring.redis.host=192.168.211.132
spring.redis.port=6379

• 修改service接口实现类

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisTemplate redisTemplate;
    redis setnx分布式事务

    /**
     * 查询所有
     * @return
     */
    @Override
    public List<User> findAll() {
        String key = "UserList";
        //先看缓存中是否有数据
        List<User> users = (List<User>) redisTemplate.boundValueOps(key).get();

        //如果有，直接取缓存数据
        if(users!=null){
            return users;
        }

        //如果没有，则查询数据
        users = userMapper.findAll();

        //再将数据存入到缓存
        redisTemplate.boundValueOps(key).set(users);
        return  users;
    }
}

• 测试

请求http://localhost:8080/user/findAll 如果发生如下异常，说明javabean没有序列化,修改User对象,实现Serializable即可。

小结

• 引入SpringDataRedis依赖

• application.properties中配置Redis链接信息

• 注入RedisTemplate，RedisTemplate实现了对Redis的增删查询操作

3.3 集成Spring Data JPA

3.3.1 Spring Data JPA简介

​ Spring Data是一个用于简化数据访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。 Spring Data可以极大的简化JPA( Java Persistence API )的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能。
Spring Data的官网：http://projects.spring.io/spring-data

1.简化了基本sql语句(基本的sql不用写)

2.可以连接各种类型的数据源,本地数据库,云数据库,关系型数据(mysql oralce),非关系型数据(mongoDB)

3.3.2 需求

使用完成Spring Data JPA对user表的CRUD操作。

3.3.3 步骤

1.创建工程勾选依赖
2.编写Pojo，添加注解
3.编写Dao(需要继承JpaRepository<T,ID>)
4.编写Service
5.编写Controller
6.测试

3.3.4 实现

• 创建工程勾选依赖

pom.xml

<?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>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.6.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.itheima</groupId>
	<artifactId>springboot-jpa</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot-jpa</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

• 编写pojo

/**
* @Entity：表明为一个实体对象
* @Table：指定映射的表
* @Id：指定为主键
* @GeneratedValue：指定注解的生成策略
*    TABLE：使用一个特定的数据库表格来保存主键。 
*    SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。 
*   IDENTITY：主键由数据库自动生成（主要是自动增长型） 
*    AUTO：主键由程序控制
* @Column：指定表的列明
*/    
@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column(name = "username")
    private String username;
    private String password;
    private String address;
    
     private String phone;
    // TODO getters/setters
}

• 编写dao接口

public interface UserDao extends JpaRepository<User,Integer> {
}

• 编写service接口以及实现类

public interface UserService {

    List<User> findUsers();

    User findUserById(Integer id);

    void saveUser(User user);

    void updateUser(User user);

    void deleteUserById(Integer id);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public List<User> findUsers() {
        return userDao.findAll();
    }

    @Override
    public User findUserById(Integer id) {
        Optional<User> optional = userDao.findById(id);
        return optional.get();
    }

    @Override
    public void saveUser(User user) {
        userDao.save(user);
    }

    @Override
    public void updateUser(User user) {
        // 并没有update方法，如果id存在则执行更新操作
        userDao.save(user);
    }

    @Override
    public void deleteUserById(Integer id) {
        userDao.deleteById(id);
    }
}

• 编写controller

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/findUsers")
    public List<User> findUsers(){
        return userService.findUsers();
    }

    @RequestMapping("/findUserById/{id}")
    public User findUserById(@PathVariable Integer id){
        return userService.findUserById(id);
    }

    @RequestMapping("/saveUser")
    public void saveUser(User user){
        userService.saveUser(user);
    }

    @RequestMapping("/updateUser")
    public void updateUser(User user){
        userService.updateUser(user);
    }

    @RequestMapping("/deleteUserById/{id}")
    public void deleteUserById(@PathVariable Integer id){
        userService.deleteUserById(id);
    }
}

• 配置application

#连接数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost/springboot?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=itcast
#jpa 相关配置
spring.jpa.database=mysql
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.generate-ddl=true
#hibernate.ddl-auto，建 表策略：
#update：每次运行程序，没有表会新建表，表内有数据不会清空，只会更新
#create：每次运行程序，没有表会新建表，表内有数据会清空
#create-drop：每次程序结束的时候会清空表
#validate：运行程序会校验数据与数据库的字段类型是否相同，不同会报错

• 测试

小结

• 集成SpringDataJPA
  • Dao需要继承JpaRepository<T,ID>
  • JpaRepository<T,ID>中已经实现了增删改查,可以拿着直接使用

3.4 集成定时器

会使用SpringBoot集成定时器

• 开启注解支持
• 编写定时任务

实现

• 开启定时任务注解：@EnableScheduling

• 编写定时任务程序

@Component
public class TimeProgarm {

    /**
     * 掌握：cron表达式是一个字符串，字符串以5或6个空格隔开，分开共6或7个域，每一个域代表一个含义
     *  [秒] [分] [小时] [日] [月] [周] [年]
     *  [年]不是必须的域，可以省略[年]，则一共6个域
     *
     * 了解：
     *  fixedDelay：上一次执行完毕时间点之后多长时间再执行（单位：毫秒）
     *  fixedDelayString：同等，唯一不同的是支持占位符，在配置文件中必须有time.fixedDelay=5000
     *  fixedRate：上一次开始执行时间点之后多长时间再执行
     *  fixedRateString：同等，唯一不同的是支持占位符
     *  initialDelay：第一次延迟多长时间后再执行
     *  initialDelayString：同等，唯一不同的是支持占位符
     */
//    @Scheduled(fixedDelay = 5000)
//    @Scheduled(fixedDelayString = "5000")
//    @Scheduled(fixedDelayString = "${time.fixedDelay}")
//    @Scheduled(fixedRate = 5000)
//    // 第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次
//    @Scheduled(initialDelay=1000, fixedRate=5000)
    @Scheduled(cron = "30 45 15 08 07 *")
    public void myTask(){
        System.out.println("程序执行了");
    }
}

备注：可以通过资料中提供的cron表达式工具去生成。

CronTrigger配置完整格式为： [秒][分] [小时][日] [月][周] [年]

序号	说明	是否必填	允许填写的值	允许的通配符
1	秒	是	0-59	, - * /
2	分	是	0-59	, - * /
3	小时	是	0-23	, - * /
4	日	是	1-31	, - * ? / L W
5	月	是	1-12或JAN-DEC	, - * /
6	周	是	1-7或SUN-SAT	, - * ? / L W
7	年	否	empty 或1970-2099	, - * /

使用说明：

通配符说明:
* 表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。

? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。

例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?

- 表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。

, 表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发

/ 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。 在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。

L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"

W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-").

# 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了) ；

五.SpringBoot程序打包

• 修改pom.xml(设置包类型<jar、war>)
• 修改pom.xml（设置跳过测试代码）
• 打包
• 测试

实现

• 在pom文件中指定包类型（可以不指定，默认就是jar）

• 跳过测试代码(不设置时会执行所有的测试代码)

  • 方式一

   <build>
          <plugins>
              <plugin>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-maven-plugin</artifactId>
                  <skipTests>true</skipTests>
              </plugin>
          </plugins>
      </build>
  

  • 方式二

    <properties>
            <java.version>1.8</java.version>
            <skipTests>true</skipTests>
        </properties>
    

• 打包

  • 方式一：直接在idea中执行如下操作

• 方式二：通过命令执行

  1、通过cmd进入到工程的目录中，与pom.xml同级
  2、然后执行命令：mvn clean package [-Dmaven.test.skip=true] --->[]内为可选操作，排除测试代码，也就是说打包时跳过测试代码
  如下命令打包：mvn clean package -Dmaven.test.skip=true
  

• 启动项目：
  

  java -jar springboot_demo4_jpa-0.0.1-SNAPSHOT.jar
  -Xmx：最大堆内存
  -Xms：初始堆内存
  java -Xmx80m -Xms20m -jar springboot_demo4_jpa-0.0.1-SNAPSHOT.jar