掘金手册:https://juejin.cn/book/6844733814560784397

工程热部署

我们在开发中反复修改类、页面等资源,每次修改后都是需要重新启动才生效,这样每次启动都很麻烦,浪费了大的时间,我们可以在修改代码后不重启就能生效,在 pom.xml 中添加如下配置就可以实现这样的功能,我们称之为热部署。

1
2
3
4
5
<!--热部署配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>

IDEA设置自动热部署
seting —> 搜索compiler —> 勾选Build project automatically

然后 Shift+Ctrl+Alt+/,选择Registry回车

勾选compiler.automake.allow.when.app.running

配置文件

SpringBoot是基于约定的,所以很多配置都有默认值,但如果想使用自己的配置替换默认配置的话,就可以使用application.properties或者application.yml(application.yaml)进行配置。(YML文件的扩展名可以使用.yml或者.yaml。)

yml配置文件的语法

(1)配置普通数据

1
2
3
语法: key: value
示例代码:name: haohao
注意:value之前有一个空格

(2) 配置对象数据

1
2
3
4
语法:
key:
key1: value1
key2: value2

示例代码:

1
2
3
4
5
6
7
person:
name: haohao
age: 31
addr: beijing
#或者
person: {name: haohao,age: 31,addr: beijing}
注意:key1前面的空格个数不限定,在yml语法中,相同缩进代表同一个级别

(3) 配置Map数据–同上面的对象写法

1
2
3
4
5
6
person:
name: haohao
age: 31
addr: beijing
#或者
person: {name: haohao,age: 31,addr: beijing}

(4) 配置数组(List、Set)数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 key:
- value1
- value2
或者:key: [value1,value2]
#示例代码:
city:
- Beijing
- Tianjin

city: [Guangzhou, Shenzhen]
#数组对象
person:
- name: accp
age: 20
- name: zhangsan
age: 21
person: [{name:accp, age:20}, {name:zhangsan, age:21}]

多环境配置

为每个环境创建一个配置文件,命名必须以 application-环境 标识.properties|yml

SpringBoot 总配置文件: application.yml application.properties

开发环境配置文件: application-dev.yml application-dev.properties

测试环境配置文件: application-test.yml application-test.properties

生产环境配置文件: application-product.yml application-product.properties

在总配置文件 application.properties /application.ym中进行环境的激活

等号右边的值和配置文件的环境标识名一致, 可以更改总配置 文件的配置, 重新运行 Application,查看启动的端口及上下文根。

在总的配置文件application.properties中激活配置文件

1
2
3
4
5
6
7
#SpringBoot 的总配置文件
#激活开发环境
#spring.profiles.active=dev
#激活测试环境
#spring.profiles.active=test
#激活生产环境
spring.profiles.active=product

配置文件与配置类的属性映射方式

Spring Boot 自定义配置 在 SpringBoot 的核心配置文件中,除了使用内置的配置项之外, 我们还可以在自定义配置,然后采用如下注解去读取配置的属性值

  1. 使用注解@Value映射
    我们可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上例如:
    application.yml配置如下:
1
2
3
person:
name: zhangsan
age: 18

实体Bean代码如下:

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class QuickStartController {
@Value("${person.name}")
private String name;
@Value("${person.age}")
private Integer age;
@RequestMapping("/quick")
@ResponseBody
public String quick(){
return "springboot 访问成功! name="+name+",age="+age; }
}

(2) @ConfigurationProperties 将整个文件映射成一个对象,用于自定义配置项比较多的情况

通过注解@ConfigurationProperties(prefix=”配置文件中的key的前缀”)可以将配置文件中的配置自动与实体进行映射,需要定义get/set方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Controller
@ConfigurationProperties(prefix = "person")
public class QuickStartController {
private String name;
private Integer age;
@RequestMapping("/quick")
@ResponseBody
public String quick(){
return "springboot 访问成功! name="+name+",age="+age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
}

(3)解决警告问题

1
2
3
4
5
6
<!--解决使用@ConfigurationProperties 注解出现警告问题-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>

前端使用 JSP(不推荐)

springboot官方推荐使用Thymeleaf
笔记:https://pengyirui.gitee.io/posts/2d22.html

在pom.xml文件中配置以下依赖项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<!--引入 Spring Boot 内嵌的 Tomcat 对 JSP 的解析包,不加解析不了 jsp 页面-->
<!--如果只是使用 JSP 页面,可以只添加该依赖-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!--如果要使用 servlet 必须添加该以下两个依赖-->
<!-- servlet 依赖的 jar 包-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
</dependency>
<!--如果使用 JSTL 必须添加该依赖-->
<!--jstl 标签依赖的 jar 包 start-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>

在 pom.xml 的 build 标签中要配置编译信息。

SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目 录下才能访问,否则访问不到。因为Spring Boot默认是使用“Thymeleaf”视图模板的,而非“JSP”视图模板,因此JSP的支持并不在刚才加入的starter组件中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--
SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问,否则访问
不到。其它官方已经建议使用模版技术(后面会课程会单独讲解模版技术)
-->
<resources>
<resource>
<!--源文件位置-->
<directory>src/main/webapp</directory>
<!--指定编译到 META-INF/resources,该目录不能随便写-->
<targetPath>META-INF/resources</targetPath>
<!--指定要把哪些文件编译进去, **表示 webapp 目录及子目录, *.*表示所有文件-->
<includes>
<include>**/*.*</include>
</includes>
</resource>
</resources>

配置 Spring MVC 的视图 展示为 jsp

1
2
3
4
5
6
7
#SpringBoot 核心配置文件
#指定内嵌 Tomcat 端口号
server.port=8090
#配置 SpringMVC 视图解析器
#其中: / 表示目录为 src/main/webapp
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

application.yml 格式的配置文件

1
2
3
4
5
spring:
mvc:
view:
prefix: /WEB-INF/jsp/
suffix: .jsp

5.4在 src/main 下创建一个 webapp 目录

然后在该目录 下新建 index.jsp 页面 如果在 webapp 目录下右键,如果没有创建 jsp 的选项,可以在 Project Structure 中指定 webapp 为 Web Resource Directory

5.5添加静态资源

客户端资源的默认路径为resources-static,本项目中添加如下静态资源

集成mybatis

添加起步依赖和驱动包

1
2
3
4
5
6
7
8
9
10
11
<!--MyBatis 整合 SpringBoot 的起步依赖-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<!--MySQL 的驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

添加数据源配置信息

在 Springboot 的核心配置文件 application.properties 中配 置数据源

1
2
3
4
5
6
7
8
9
10
11
12
#数据库连接信息
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/myCinema&useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=
#spring集成Mybatis环境
#实体别名扫描包
mybatis.type-aliases-package=io.peng.model
#加载Mybatis映射文件
mybatis.mapper-locations=classpath:mapper/*Mapper.xml
#配置日志,打印sql
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解 @Mapper

作用: mybatis 自动扫描数据持久层的映射文件及 DAO 接口的关系

在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解 @Mapper 作用: mybatis 自动扫描数据持久层的映射文件及 DAO 接口的关系

在 运 行 的 主 类 上 添 加 注 解 包 扫 描 @MapperScan(“com.abc.springboot.mapper”) 注释掉 Mapper 接口上的@Mapper 注解

1
2
3
4
5
6
7
8
9
10
11
@SpringBootApplication
//Mybatis 提供的注解:扫描数据持久层的 mapper 映谢配置文件,DAO 接口上就不用加@Mapper
//basePackages 通常指定到数据持久层包即可
@SpringBootApplication
@MapperScan("io.peng.mycinema.mapper")//批量设置扫描包
public class MycinemaApplication {

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

在application.properties文件设置mapper文件的路径

1
mybatis.mapper-locations=classpath:/mapper/*Mapper.xml

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// @SpringBootTest(classes = BookUserApplication.class)
// 旧版本需要指定启动类 springframework 2.25
@SpringBootTest
// @RunWith(SpringRunner.class)
// 旧版本需要指定启动方法 springframework 2.25
public class BookUserApplicationTest {

@Autowired
private UsersMapper usersMapper;

@Test
public void aaa(){
usersMapper.selectByCode("sam");
}
}

事务支持

Spring Boot 使用事务非常简单,底层依然采用的是 Spring 本身提 供的事务管理

➢ 在入口类中使用注解 @EnableTransactionManagement 开启 事务支持

➢ 在访问数据库的 Service 方法上添加注解 @Transactional 即可

1
2
3
4
5
6
7
//启动类开启事务支持
@SpringBootApplication
@MapperScan(basePackages = "com.powernode.mapper")
@EnableTransactionManagement //开启事务支持(可选项,但@Transactional 必须添加)
public class Application {

}

Spring MVC 注解

注解 作用
@Controller 控制器
@RestController @Controller 与@ResponseBody 的组合注解 如果一个 Controller 类添加了@RestController,那么该 Controller 类下的所有方法都相当于添加了@ResponseBody 注解 用于返回字符串或 json 数据
@RequestMapping 支持Get请求和Post请求
@GetMapping 支持Get请求,用于查询数据
@PostMapping 只支持Post请求,用于增加数据
@PutMapping 只支持Put请求,用于修改数据
@DeleteMapping 只支持Delete请求,删除数据

RESTful

REST(英文: Representational 表述性State Transfer,简称 REST)一种互联网软件架构设计的风格,但它并不是标准,它只是提出了一组客户端和服务器交互时的架构理念和设计原则,基于这种理念和原则设计的接口可以更简洁,更有层次, REST这个词,是Roy ThomasFielding 在他 2000 年的博士论文中提出的。任何的技术都可以实现这种理念,如果一个架构符合 REST 原则,

Spring Boot 开发 RESTFul Spring boot

开发 RESTFul 主要是几个注解实现

  • @PathVariable 获取 url 中的数据 该注解是实现 RESTFul 最主要的一个注解

  • @PostMapping 接收和处理 Post 方式的请求

  • @DeleteMapping 接收 delete 方式的请求,可以使用 GetMapping 代替

  • @PutMapping 接收 put 方式的请求,可以用 PostMapping 代替

  • @GetMapping 接收 get 方式的请求

RESTful 的优点

➢ 轻量,直接基于 http,不再需要任何别的诸如消息协议 get/post/put/delete 为 CRUD 操作

➢ 面向资源,一目了然,具有自解释性。

➢ 数据描述简单,一般以 xml, json 做数据交换。

➢ 无状态,在调用一个接口(访问、操作资源)的时候,可以不 用考虑上下文,不用考虑当前状态,极大的降低了复杂度。

➢ 简单、低耦合

RESTful 原则

➢ 增 post 请求、删 delete 请求、改 put 请求、查 get 请求

➢ 请求路径不要出现动词

​ 例如:查询订单接口 /boot/order/1021/1(推荐) /boot/queryOrder/1021/1(不推荐)

➢ 分页、排序等操作,不需要使用斜杠传参数

​ 例如:订单列表接口 /boot/orders?page=1&sort=desc 一般传的参数不是数据库表的字段,可以不采用斜杠

拦截器

直接上例子:地址拦截

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Login.java
// 功能类
// 实现HandlerInterceptor接口

@Component
public class Login implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler){

// 如果user不等于空,就不拦截,否则就跳去XXX地址
if (user != null) {
return true;

}else {
response.sendRedirect("XXX");
return false;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 实现方法类
// 实现WebMvcConfigurer接口
// Login功能类交给spring创建
// 重写addInterceptors方法

// 应用功能类XXX
// registry.addInterceptor(XXX)
// 需要拦截的地址
// .addPathPatterns("/loan/loanInfo/**");
// 需要放开的地址
// .excludePathPatterns("/money/loan/page/login");


@Configuration
public class WebConfig implements WebMvcConfigurer {
@Autowired
private Login login;

@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(login)
.addPathPatterns("/");
.excludePathPatterns("/money/");
}
}

定时任务

在日常的项目开发中,往往会涉及到一些需要做到定时执行的代码,例如自动将超过24小时的未付款的单改为取消状态,自动将超过14天客户未签收的订单改为已签收状态等等, Java项目中常使用的定时器有JDK Timer、Quartz、Spring Task等三种。Quartz的功能强大,配置也比较复杂,适合大型、多定时任务的项目使用。Spring Task配置较为简单轻量,需要Spring框架支持。JDK自带的定时器Timer使用灵活,配置简单,适合中小型项目。

Timer

这是java自带的java.util.Timer类,这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行,但不能在指定时间运行。一般用的较少。

1
2
3
4
5
6
7
8
TimerTask task=new TimerTask() {
@Override
public void run() {
System.out.println("hello,world...."+new Date());
}
};
Timer timer=new Timer();
timer.schedule(task,1000,3000);

ScheduledExecutorService

jdk自带的一个类;是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响 。

1
2
3
4
5
ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
// 参数:1、任务体 2、首次执行的延时时间
// 3、任务执行间隔 4、间隔时间单位
service.scheduleAtFixedRate(
()->System.out.println("ScheduledExecutorService定时任务 "+new Date()), 0, 3, TimeUnit.SECONDS);

Spring Task

Spring3.0以后自带的task,可以将它看成一个轻量级的Quartz,而且使用起来比Quartz简单许多 .在SpringBoot中已经内置集成了SpringTask,使用非常的方便快捷。

在类上@EnableScheduling,在方法@Scheduled

1
2
3
4
5
6
7
8
9
<!-- 导包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Component
@EnableScheduling
public class SpringTaskDemo {

@Scheduled(cron = "3/15 * * * * *")
public void start(){
System.out.println("----间隔计划任务----"+new Date());
}

@Scheduled(initialDelay = 2000,fixedDelay = 10000)
public void stop(){
System.out.println("----延迟计划任务----"+new Date());
}

@Scheduled(fixedRate = 10000)
public void delay(){
System.out.println("----固定计划任务----"+new Date());
}
}

@Scheduled有三种定时任务的执行方式,包括fixedDelay、fixedRate、corn表达式,下面就分别讲讲这三种执行方式的不同。

fixedDelay:指定两次任务执行的时间间隔(毫秒),此时间间隔指的是,前一次任务结束与下一个任务开始的间隔。如:@Scheduled(fixedDelay = 5*1000 ),表示第一个任务结束后,过5秒后,开始第二个任务。

fixedRate:指定两次任务执行的时间间隔(毫秒),此时间间隔指的是,前一个任务开始与下一个任务开始的间隔。如:@Scheduled(fixedRate= 5*1000 ),表示第一个任务开始后(第一个任务执行时间小于5秒),第一个任务开始后的第6秒,开始第二个任务。如果第一个任务执行时间大于5秒,第一个任务结束后,直接开始第二个任务。

cron表达式(常用)

使用cron表达式进行任务的执行
cron一般是六个或七个字段,分别是:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
1. Seconds (秒) 
2. Minutes (分)
3. Hours (时)
4. Day (每月的第几天,day-of-month)
5. Month (月)
6. Day (每周的第几天,day-of-week)
7. Year (年 可选字段)


说明
秒 :范围:0-59
分 :范围:0-59
时 :范围:0-23
天(月) :范围:1-31,但要注意一些特别的月份2月份没有只能1-28,有些月份没有31
月 :用0-11 或用字符串 “JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC” 表示
天(周):用1-7表示(1 = 星期日)或用字符口串“SUN, MON, TUE, WED, THU, FRI and SAT”表示
年:范围:1970-2099

“/”:表示为“每”,如“0/10”表示每隔10分钟执行一次,“0”表示为从“0”分开始, “3/20”表示表示每隔20分钟执行一次
“?”:只用于月与周,表示不指定值
“L”:只用于月与周,5L用在月表示为每月的最后第五天;1L用在周表示每周的最后一天;
“W”::表示有效工作日(周一到周五),只能出现在day-of-month,系统将在离指定日期的最近的有效工作日触发事件。例如:在 DayofMonth使用5W,如果5日是星期六,则将在最近的工作日:星期五,即4日触发。如果5日是星期天,则在6日(周一)触发;如果5日在星期一到星期五中的一天,则就在5日触发。另外一点,W的最近寻找不会跨过月份
“#”:用于确定每个月第几个星期几,只能出现在DayofMonth域。例如在4#2,表示某月的第二个星期三。
“*” 代表整个时间段。


例子
0 0 10,14,16 * * ? 每天上午10点,下午2点,4点
0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
0 0 12 ? * WED 表示每个星期三中午12点
0 0 12 * * ? 每天中午12点
0 15 10 ? * * ? 每天上午10:15
0 15 10 * * ? 每天上午10:15
0 15 10 * * ? * 每天上午10:15
0 15 10 * * ? 2005 2005年的每天上午10:15
0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟
0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟
0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟
0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟
0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44
0 15 10 ? * MON-FRI 周一至周五的上午10:15
0 15 10 15 * ? 每月15日上午10:15
0 15 10 L * ? 每月最后一日的上午10:15
0 15 10 ? * 6L 每月的最后一个星期五上午10:15
0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15
0 15 10 ? * 6#3" 每月的第三个星期五上午10:15

@ConfigurationProperties

根据配置文件自动配置属性

1
2
3
4
5
6
@ConfigurationProperties(prefix = "jwt.config")
@Component
public class JwtUtil {
private String signKey;
private int expireMinutes;
}
1
2
jwt.config.signKey=peng
jwt.config.expireMinutes=0

配置类

一般@Configuration注释放在类上,与@Ben搭配使用

表示启动spring立即加载

web注释

路径变量

1
2
3
4
@DeleteMapping("/{id}")
public String delete(@PathVariable ("id") Integer id){
xxxxx
}

入参是json

1
2
3
4
@PostMapping("/login")
public String login(@RequestBody User user){

}

请求参数

1
2
@PostMapping
String check(@RequestParam("userCoed") String userCoed);

返回的是json

ResponseResult
自定义ResponseResult在controller响应信息主体和自定义全局及局部异常中的实现