Tlias管理系统

项目需求

部门管理：查询、新增、修改、删除
员工管理：
- 查询、新增、修改、删除
- 文件上传
报表统计
登录认证
日志管理
班级管理（自己实战内容）
学员管理（自己实战内容）

基于REST风格URL如下：

http://localhost:8080/users/1 GET：查询id为1的用户
http://localhost:8080/users POST：新增用户
http://localhost:8080/users PUT：修改用户
http://localhost:8080/users/1 DELETE：删除id为1的用户

其中总结起来，就一句话：通过URL定位要操作的资源，通过HTTP动词(请求方式)来描述具体的操作。

工程搭建

创建SpringBoot工程并引入web开发起步依赖、mybatis、mysql驱动、lombok

1
spring:
2
  application:
3
    name: tlias-web-management
4
  datasource:
5
    url: jdbc:mysql://localhost:3306/tlias
6
    driver-class-name: com.mysql.cj.jdbc.Driver
7
    username: root
8
    password: 123456
9
mybatis:
10
  configuration:
11
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

部门管理

统一响应结果

1
package com.itheima.pojo;
2

3
import lombok.Data;
4
import java.io.Serializable;
5

6
/**
7
 * 后端统一返回结果
8
 */
9
@Data
10
public class Result {
11

12
    private Integer code; //编码：1成功，0为失败
13
    private String msg; //错误信息
14
    private Object data; //数据
15

16
    public static Result success() {
17
        Result result = new Result();
18
        result.code = 1;
19
        result.msg = "success";
20
        return result;
21
    }
22

23
    public static Result success(Object object) {
24
        Result result = new Result();
25
        result.data = object;
26
        result.code = 1;
27
        result.msg = "success";
28
        return result;
29
    }
30

31
    public static Result error(String msg) {
32
        Result result = new Result();
33
        result.msg = msg;
34
        result.code = 0;
35
        return result;
36
    }
37

38
}

部门表查询

前置数据

创建部门数据库表

1
CREATE TABLE dept (
2
  id int unsigned PRIMARY KEY AUTO_INCREMENT COMMENT 'ID, 主键',
3
  name varchar(10) NOT NULL UNIQUE COMMENT '部门名称',
4
  create_time datetime DEFAULT NULL COMMENT '创建时间',
5
  update_time datetime DEFAULT NULL COMMENT '修改时间'
6
) COMMENT '部门表';
7

8
INSERT INTO dept VALUES (1,'学工部','2023-09-25 09:47:40','2024-07-25 09:47:40'),
9
                      (2,'教研部','2023-09-25 09:47:40','2024-08-09 15:17:04'),
10
                      (3,'咨询部','2023-09-25 09:47:40','2024-07-30 21:26:24'),
11
                      (4,'就业部','2023-09-25 09:47:40','2024-07-25 09:47:40'),
12
                      (5,'人事部','2023-09-25 09:47:40','2024-07-25 09:47:40'),
13
                      (6,'行政部','2023-11-30 20:56:37','2024-07-30 20:56:37');

在 application.yml 配置文件中配置数据库的连接信息。

1
spring:
2
  application:
3
    name: tlias-web-management
4
  datasource:
5
    url: jdbc:mysql://localhost:3306/tlias
6
    driver-class-name: com.mysql.cj.jdbc.Driver
7
    username: root
8
    password: 123456
9
mybatis:
10
  configuration:
11
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

部门实体类

1
package com.itheima.pojo;
2

3
import lombok.AllArgsConstructor;
4
import lombok.Data;
5
import lombok.NoArgsConstructor;
6

7
import java.time.LocalDateTime;
8

9
@Data
10
@NoArgsConstructor
11
@AllArgsConstructor
12
public class Dept {
13
    private Integer id;
14
    private String name;
15
    private LocalDateTime createTime;
16
    private LocalDateTime updateTime;
17
}

Controller层，负责接收前端发起的请求，并调用service查询部门数据，然后响应结果。
Service层，负责调用Mapper接口方法，查询所有部门数据。
Mapper层，执行查询所有部门数据的操作。

mybatis属性封装

部门的数据中，id、name两个属性是有值的，但是createTime、updateTime两个字段值并未成功封装，而数据库中是有对应的字段值的，这是为什么呢？

实体类属性名和数据库表查询返回的字段名一致，mybatis会自动封装。
如果实体类属性名和数据库表查询返回的字段名不一致，不能自动封装。

手动映射

在DeptMapper接口方法上，通过 @Results及@Result 进行手动结果映射。

1
@Results({@Result(column = "create_time", property = "createTime"),
2
          @Result(column = "update_time", property = "updateTime")})
3
@Select("select id, name, create_time, update_time from dept")
4
public List<Dept> findAll();

起别名

1
@Select("select id, name, create_time createTime, update_time updateTime from dept")
2
public List<Dept> findAll();

驼峰命名（推荐）

如果字段名与属性名符合驼峰命名规则，mybatis会自动通过驼峰命名规则映射。驼峰命名规则： abc_xyz => abcXyz

表中字段名：abc_xyz
类中属性名：abcXyz

在application.yml中做如下配置，开启开关。

1
mybatis:
2
  configuration:
3
    map-underscore-to-camel-case: true

请求路径/depts 请求方式：GET 接口描述：该接口用于部门列表数据查询

Controller

1
@RestController   //RestController=Controller+RestBody
2
public class DeptController {
3

4
    @Autowired
5
    private DeptService deptService;
6

7
    /**
8
     * 查询部门列表
9
     */
10
    @GetMapping("/depts")
11
    public Result list(){
12
        List<Dept> deptList = deptService.findAll();
13
        return Result.success(deptList);
14
    }
15
}

GET方式：@GetMapping
POST方式：@PostMapping
PUT方式：@PutMapping
DELETE方式：@DeleteMapping

Service

1
public interface DeptService {
2
    /**
3
     * 查询所有部门
4
     */
5
    public List<Dept> findAll();
6
}

1
@Service
2
public class DeptServiceImpl implements DeptService {
3

4
    @Autowired
5
    private DeptMapper deptMapper;
6

7
    public List<Dept> findAll() {
8
        return deptMapper.findAll();
9
    }
10
}

Mapper

1
@Mapper
2
public interface DeptMapper {
3
    /**
4
     * 查询所有部门
5
     */
6
    @Select("select * from dept")
7
    public List<Dept> findAll();
8

9
}

前后端联调

1.浏览器发起请求，请求的是localhost:90 ，那其实请求的是nginx服务器。

2.在nginx服务器中呢，并没有对请求直接进行处理，而是将请求转发给了后端的tomcat服务器，最终由tomcat服务器来处理该请求。

通过nginx的反向代理实现的。那为什么浏览器不直接请求后端的tomcat服务器，而是直接请求nginx服务器呢

安全：由于后端的tomcat服务器一般都会搭建集群，会有很多的服务器，把所有的tomcat暴露给前端，让前端直接请求tomcat，对于后端服务器是比较危险的。

灵活：基于nginx的反向代理实现，更加灵活，后端想增加、减少服务器，对于前端来说是无感知的，只需要在nginx中配置即可。

负载均衡：基于nginx的反向代理，可以很方便的实现后端tomcat的负载均衡操作。

部门删除

`@RequestParam`

1
@DeleteMapping("/depts")
2
public Result delete(@RequestParam("id") Integer deptId){
3
    System.out.println("根据ID删除部门: " + deptId);
4
    return Result.success();
5
}

1
@DeleteMapping("/depts")
2
public Result delete(Integer id){
3
    System.out.println("根据ID删除部门: " + deptId);
4
    return Result.success();
5
}
6
//如果请求参数名与形参变量名相同，直接定义方法形参即可接收。（省略@RequestParam）

Controller

1
/**
2
 * 根据id删除部门 - delete http://localhost:8080/depts?id=1
3
 */
4
@DeleteMapping("/depts")
5
public Result delete(Integer id){
6
    System.out.println("根据id删除部门, id=" + id);
7
    deptService.delete(id);
8
    return Result.success();
9
}

Service

1
/**
2
 * 根据id删除部门
3
 */
4
package com.itheima.service;
5

6
import com.itheima.pojo.Dept;
7

8
import java.util.List;
9

10
public interface DeptService {
11
    List<Dept> findAll();
12
    void delete(Integer id);

1
package com.itheima.service.impl;
2

3
import com.itheima.mapper.DeptMapper;
4
import com.itheima.pojo.Dept;
5
import com.itheima.service.DeptService;
6
import org.springframework.beans.factory.annotation.Autowired;
7
import org.springframework.stereotype.Service;
8

9

10
import java.time.LocalDateTime;
11
import java.util.List;
12

13
@Service
14
public class DeptServiceimpl implements DeptService {
15
    @Autowired
16
    private DeptMapper deptMapper;
17
    @Override
18
    public List<Dept> findAll() {
19
        return deptMapper.findAll();
20
    }
21

22
    @Override
23
    public void delete(Integer id) {
24
       deptMapper.delete(id);
25
    }

Mapper

1
package com.itheima.mapper;
2
import com.itheima.pojo.Dept;
3
import org.apache.ibatis.annotations.*;
4
import java.util.List;
5
//操作增删改功能
6
@Mapper
7
public interface DeptMapper {
8
    @Select("select id, name, create_time createTime, update_time updateTime from dept")
9
    public List<Dept> findAll();
10
    @Delete("delete from dept where id = #{id}")
11
    public void delete(Integer id);

新增部门

@RequestBody

在controller中，需要接收前端传递的请求参数。那接下来，我们就先来看看在服务器端的Controller程序中，如何获取json格式的参数。

JSON格式的参数，通常会使用一个实体对象进行接收。
规则：JSON数据的键名与方法形参对象的属性名相同，并需要使用@RequestBody注解标识。

前端传递的请求参数格式为json，内容如下：{"name":"研发部"}。这里，我们可以通过一个对象来接收，只需要保证对象中有name属性即可。

Controller

1
@RequestMapping("/depts")
2
@RestController   //交由io容器管理
3
public class DeptController {
4

5
//新增部门 - POST http://localhost:8080/depts   请求参数：{"name":"研发部"}
6
@PostMapping
7
    public Result add(@RequestBody Dept dept)
8
    {
9
        log.info("保存的部门数据为：{}" ,dept);
10
        deptService.add(dept);
11
        return Result.success();
12
    }
13
    }

Service

1
 @Override
2
    public void add(Dept dept) {
3
        LocalDateTime now = LocalDateTime.now();
4
        dept.setCreateTime(now);
5
        dept.setUpdateTime(now);
6
        deptMapper.add(dept);
7
    }

1
@Data
2
@NoArgsConstructor
3
@AllArgsConstructor
4
public class Dept {
5
    private Integer id;
6
    private String name;
7

8
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
9
    private LocalDateTime createTime;
10

11
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
12
    private LocalDateTime updateTime;
13
}

Mapper

1
/**
2
 * 保存部门
3
 */
4
@Insert("insert into dept(name,create_time,update_time) values(#{name},#{createTime},#{updateTime})")
5
void insert(Dept dept);

在mapper接口中，需要传递多个参数，可以把多个参数封装到一个对象中。在SQL语句中获取参数的时候，#{...} 里面写的是对象的属性名【注意是属性名，不是表的字段名】

修改部门

根据id查询部门

@PathVariable

/depts/1，/depts/2 这种在url中传递的参数，我们称之为路径参数。那么如何接收这样的路径参数呢？

路径参数：通过请求URL直接传递参数，使用{…}来标识该路径参数，需要使用 **@PathVariable**获取路径参数

Controller

1
 @GetMapping("/{id}")
2
    public Result getinfo(@PathVariable ("id") Integer deptsid){
3
       log.info("根据id查询的部门id为：{}" ,deptsid);
4
        Dept dept = deptService.findinfo(deptsid);
5
        return Result.success(dept);
6
    }

Service

1
package com.itheima.service;
2

3
import com.itheima.pojo.Dept;
4

5
import java.util.List;
6

7
public interface DeptService {
8
    List<Dept> findAll();
9
    void delete(Integer id);
10
    void add(Dept dept);
11
    Dept findinfo(Integer id);

1
  @Override
2
    public Dept findinfo(Integer id) {
3
        return deptMapper.findinfo(id);
4
    }

Mapper

1
  @Select("select id, name, create_time createTime, update_time updateTime from dept where id = #{id}")
2
    public Dept findinfo(Integer id);

修改部门

@RequestBody

Controller

1
 @PutMapping
2
    public Result update(@RequestBody Dept dept) {
3
       log.info("修改的部门数据为：{}" , dept);
4
        deptService.update(dept);
5
        return Result.success();
6
    }

Service

1
  package com.itheima.service;
2

3
import com.itheima.pojo.Dept;
4

5
import java.util.List;
6

7
public interface DeptService {
8
    List<Dept> findAll();
9
    void delete(Integer id);
10
    void add(Dept dept);
11
    Dept findinfo(Integer id);
12

13
    void getinfo(Dept dept);
14
    void update(Dept dept);
15
}

1
@Override
2
    public void update(Dept dept) {
3
        LocalDateTime now = LocalDateTime.now();
4
        dept.setUpdateTime(now);
5
        deptMapper.update(dept);
6
    }

Mapper

1
package com.itheima.mapper;
2
import com.itheima.pojo.Dept;
3
import org.apache.ibatis.annotations.*;
4
import java.util.List;
5
//操作增删改功能
6
@Mapper
7
public interface DeptMapper {
8
    @Select("select id, name, create_time createTime, update_time updateTime from dept")
9
    public List<Dept> findAll();
10
    @Delete("delete from dept where id = #{id}")
11
    public void delete(Integer id);
12
    @Insert("insert into dept(name, create_time, update_time) values(#{name}, #{createTime}, #{updateTime})")
13
    public void add(Dept dept);
14

15
    //根据id查询回显并修改部门
16
    @Select("select id, name, create_time createTime, update_time updateTime from dept where id = #{id}")
17
    public Dept findinfo(Integer id);
18
    @Update("update dept set name = #{name}, update_time = #{updateTime} where id = #{id}")
19
    public void update(Dept dept)

@RequstMapping

1
package com.itheima.controller;
2

3
import com.itheima.anno.LogOperation;
4
import com.itheima.pojo.Dept;
5
import com.itheima.pojo.Result;
6
import com.itheima.service.DeptService;
7
import jakarta.servlet.http.HttpServletRequest;
8
import lombok.extern.slf4j.Slf4j;
9
import org.springframework.beans.factory.annotation.Autowired;
10
import org.springframework.web.bind.annotation.*;
11
import org.springframework.web.multipart.MultipartFile;
12
import org.springframework.web.servlet.ModelAndView;
13
import java.io.File;
14
import java.util.List;
15
import java.util.logging.Logger;
16
@Slf4j
17
@RequestMapping("/depts")
18
@RestController   //交由io容器管理
19
public class DeptController {
20

21
    @Autowired
22
    private DeptService deptService;
23
    @LogOperation
24
    // 查询所有部门信息
25
    @GetMapping
26
    public Result list() {
27
        List<Dept> deptList = deptService.findAll();
28
        return Result.success(deptList);
29
    }
30

31
    // 删除部门
32
//    @DeleteMapping("/depts")
33
//    public Result delete(HttpServletRequest request) {
34
//        String id = request.getParameter("id");
35
//        int deptId = Integer.parseInt(id);
36
//        System.out.println("删除的部门id为：" + deptId);
37
//        return Result.success();
38
//    }
39
    @LogOperation
40
    @DeleteMapping
41
    public Result delete( Integer id) {
42
        log.info("删除的部门id为：{}", id);
43
        deptService.delete(id);
44
        return Result.success();
45
    }
46
    @LogOperation
47
    @PostMapping
48
    public Result add(@RequestBody Dept dept)
49
    {
50
        log.info("保存的部门数据为：{}" ,dept);
51
        deptService.add(dept);
52
        return Result.success();
53
    }
54
    @LogOperation
55
    @GetMapping("/{id}")
56
    public Result getinfo(@PathVariable ("id") Integer deptsid){
57
       log.info("根据id查询的部门id为：{}" ,deptsid);
58
        Dept dept = deptService.findinfo(deptsid);
59
        return Result.success(dept);
60
    }
61
    @LogOperation
62
    @PutMapping
63
    public Result update(@RequestBody Dept dept) {
64
       log.info("修改的部门数据为：{}" , dept);
65
        deptService.update(dept);
66
        return Result.success();
67
    }
68
}

日志技术

定义

日志用于记录应用程序的运行信息、状态信息和错误信息。专业的日志框架（如 Logback）替代 System.out.println，提供灵活的日志级别控制、多种输出目标（控制台/文件）和格式化能力。

日志框架

使用 System.out.println(...) 记录日志的缺陷：

硬编码：无法灵活控制输出与否，只能删除代码
输出受限：只能输出到控制台
不便于扩展维护：无法按级别过滤、按格式输出

对比

框架	特点
JUL	JavaSE 官方日志框架，配置简单但不够灵活，性能较差
Log4j	流行的日志框架，灵活的配置选项，支持多种输出目标
Logback	基于 Log4j 升级，更多功能和配置选项，性能优于 Log4j
Slf4j	简单日志门面，提供标准接口，允许切换底层日志框架

Logback 依赖引入

SpringBoot 已内置传递 Logback 依赖，无需额外引入。若单独使用：

1
<dependency>
2
    <groupId>ch.qos.logback</groupId>
3
    <artifactId>logback-classic</artifactId>
4
    <version>1.4.11</version>
5
</dependency>

配置文件 logback.xml

放置在 src/main/resources 目录下：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<configuration>
3
    <!-- 控制台输出 -->
4
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
5
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
6
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}-%msg%n</pattern>
7
        </encoder>
8
    </appender>
9

10
<!-- 系统文件输出 -->
11
  <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
12
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
13
      <!-- 日志文件输出的文件名, %i表示序号 -->
14
      <FileNamePattern>/usr/local/tlias-app/tlias-%d{yyyy-MM-dd}-%i.log</FileNamePattern>
15
      <!-- 最多保留的历史日志文件数量 -->
16
      <MaxHistory>30</MaxHistory>
17
      <!-- 最大文件大小，超过这个大小会触发滚动到新文件，默认为 10MB -->
18
      <maxFileSize>10MB</maxFileSize>
19
    </rollingPolicy>
20

21
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
22
      <!--格式化输出：%d 表示日期，%thread 表示线程名，%-5level表示级别从左显示5个字符宽度，%msg表示日志消息，%n表示换行符 -->
23
      <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}-%msg%n</pattern>
24
    </encoder>
25
  </appender>
26

27

28
    <!-- 日志输出级别 -->
29
    <root level="ALL">
30
        <appender-ref ref="STDOUT" />
31
    </root>
32
</configuration>

Pattern 格式化占位符说明：

占位符	含义
`%d`	日期
`%thread`	线程名
`%-5level`	日志级别，左对齐 5 字符宽度
`%logger{50}`	Logger 名称，最长 50 字符
`%msg`	日志消息
`%n`	换行符

日志级别

级别由低到高：TRACE → DEBUG → INFO → WARN → ERROR

<root level="info"> 表示仅输出大于等于 INFO 级别的日志（INFO / WARN / ERROR），DEBUG 和 TRACE 不会输出。

配置值	效果
ALL	输出所有级别日志
OFF	关闭所有日志
INFO	仅输出 INFO、WARN、ERROR（生产环境推荐）
DEBUG	输出 DEBUG 及以上（开发调试推荐）

常见场景

1
package com.itheima.controller;
2

3
import com.itheima.anno.LogOperation;
4
import com.itheima.pojo.Dept;
5
import com.itheima.pojo.Result;
6
import com.itheima.service.DeptService;
7
import jakarta.servlet.http.HttpServletRequest;
8
import lombok.extern.slf4j.Slf4j;
9
import org.springframework.beans.factory.annotation.Autowired;
10
import org.springframework.web.bind.annotation.*;
11
import org.springframework.web.multipart.MultipartFile;
12
import org.springframework.web.servlet.ModelAndView;
13
import java.io.File;
14
import java.util.List;
15
import java.util.logging.Logger;
16
@Slf4j
17
@RequestMapping("/depts")
18
@RestController   //交由io容器管理
19
public class DeptController {
20

21
    @Autowired
22
    private DeptService deptService;
23
    @LogOperation
24
    // 查询所有部门信息
25
    @GetMapping
26
    public Result list() {
27
        List<Dept> deptList = deptService.findAll();
28
        return Result.success(deptList);
29
    }
30

31
    // 删除部门
32
//    @DeleteMapping("/depts")
33
//    public Result delete(HttpServletRequest request) {
34
//        String id = request.getParameter("id");
35
//        int deptId = Integer.parseInt(id);
36
//        System.out.println("删除的部门id为：" + deptId);
37
//        return Result.success();
38
//    }
39
    @LogOperation
40
    @DeleteMapping
41
    public Result delete( Integer id) {
42
        log.info("删除的部门id为：{}", id);
43
        deptService.delete(id);
44
        return Result.success();
45
    }
46
    @LogOperation
47
    @PostMapping
48
    public Result add(@RequestBody Dept dept)
49
    {
50
        log.info("保存的部门数据为：{}" ,dept);
51
        deptService.add(dept);
52
        return Result.success();
53
    }
54
    @LogOperation
55
    @GetMapping("/{id}")
56
    public Result getinfo(@PathVariable ("id") Integer deptsid){
57
       log.info("根据id查询的部门id为：{}" ,deptsid);
58
        Dept dept = deptService.findinfo(deptsid);
59
        return Result.success(dept);
60
    }
61
    @LogOperation
62
    @PutMapping
63
    public Result update(@RequestBody Dept dept) {
64
       log.info("修改的部门数据为：{}" , dept);
65
        deptService.update(dept);
66
        return Result.success();
67
    }
68
}

生产环境设为 INFO 级别记录关键业务操作
开发调试时设为 DEBUG 级别查看详细执行过程
将日志输出到文件并按日期/大小滚动，便于持久化追踪

注意事项

SpringBoot 已内置 Logback，无需额外引入依赖
logback.xml 需放在 src/main/resources 下
使用 @Slf4j 注解可省略手动定义 Logger
日志消息推荐使用 {} 占位符而非字符串拼接
生产环境不建议使用 System.out.println，应统一使用日志框架

员工管理

前置数据

1
-- 员工表
2
create table emp(
3
    id int unsigned primary key auto_increment comment 'ID,主键',
4
    username varchar(20) not null unique comment '用户名',
5
    password varchar(50) default '123456' comment '密码',
6
    name varchar(10) not null comment '姓名',
7
    gender tinyint unsigned not null comment '性别, 1:男, 2:女',
8
    phone char(11) not null unique comment '手机号',
9
    job tinyint unsigned comment '职位, 1 班主任, 2 讲师 , 3 学工主管, 4 教研主管, 5 咨询师',
10
    salary int unsigned comment '薪资',
11
    image varchar(300) comment '头像',
12
    entry_date date comment '入职日期',
13
    dept_id int unsigned comment '部门ID',
14
    create_time datetime comment '创建时间',
15
    update_time datetime comment '修改时间'
16
) comment '员工表';
17

18

19
INSERT INTO emp VALUES
20
    (1,'shinaian','123456','施耐庵',1,'13309090001',4,15000,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2000-01-01',2,'2023-10-20 16:35:33','2023-11-16 16:11:26'),
21
    (2,'songjiang','123456','宋江',1,'13309090002',2,8600,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2015-01-01',2,'2023-10-20 16:35:33','2023-10-20 16:35:37'),
22
    (3,'lujunyi','123456','卢俊义',1,'13309090003',2,8900,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2008-05-01',2,'2023-10-20 16:35:33','2023-10-20 16:35:39'),
23
    (4,'wuyong','123456','吴用',1,'13309090004',2,9200,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2007-01-01',2,'2023-10-20 16:35:33','2023-10-20 16:35:41'),
24
    (5,'gongsunsheng','123456','公孙胜',1,'13309090005',2,9500,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2012-12-05',2,'2023-10-20 16:35:33','2023-10-20 16:35:43'),
25
    (6,'huosanniang','123456','扈三娘',2,'13309090006',3,6500,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2013-09-05',1,'2023-10-20 16:35:33','2023-10-20 16:35:45'),
26
    (7,'chaijin','123456','柴进',1,'13309090007',1,4700,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2005-08-01',1,'2023-10-20 16:35:33','2023-10-20 16:35:47'),
27
    (8,'likui','123456','李逵',1,'13309090008',1,4800,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2014-11-09',1,'2023-10-20 16:35:33','2023-10-20 16:35:49'),
28
    (9,'wusong','123456','武松',1,'13309090009',1,4900,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2011-03-11',1,'2023-10-20 16:35:33','2023-10-20 16:35:51'),
29
    (10,'linchong','123456','林冲',1,'13309090010',1,5000,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2013-09-05',1,'2023-10-20 16:35:33','2023-10-20 16:35:53'),
30
    (11,'huyanzhuo','123456','呼延灼',1,'13309090011',2,9700,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2007-02-01',2,'2023-10-20 16:35:33','2023-10-20 16:35:55'),
31
    (12,'xiaoliguang','123456','小李广',1,'13309090012',2,10000,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2008-08-18',2,'2023-10-20 16:35:33','2023-10-20 16:35:57'),
32
    (13,'yangzhi','123456','杨志',1,'13309090013',1,5300,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2012-11-01',1,'2023-10-20 16:35:33','2023-10-20 16:35:59'),
33
    (14,'shijin','123456','史进',1,'13309090014',2,10600,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2002-08-01',2,'2023-10-20 16:35:33','2023-10-20 16:36:01'),
34
    (15,'sunerniang','123456','孙二娘',2,'13309090015',2,10900,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2011-05-01',2,'2023-10-20 16:35:33','2023-10-20 16:36:03'),
35
    (16,'luzhishen','123456','鲁智深',1,'13309090016',2,9600,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2010-01-01',2,'2023-10-20 16:35:33','2023-10-20 16:36:05'),
36
    (17,'liying','12345678','李应',1,'13309090017',1,5800,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2015-03-21',1,'2023-10-20 16:35:33','2023-10-20 16:36:07'),
37
    (18,'shiqian','123456','时迁',1,'13309090018',2,10200,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2015-01-01',2,'2023-10-20 16:35:33','2023-10-20 16:36:09'),
38
    (19,'gudasao','123456','顾大嫂',2,'13309090019',2,10500,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2008-01-01',2,'2023-10-20 16:35:33','2023-10-20 16:36:11'),
39
    (20,'ruanxiaoer','123456','阮小二',1,'13309090020',2,10800,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2018-01-01',2,'2023-10-20 16:35:33','2023-10-20 16:36:13'),
40
    (21,'ruanxiaowu','123456','阮小五',1,'13309090021',5,5200,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2015-01-01',3,'2023-10-20 16:35:33','2023-10-20 16:36:15'),
41
    (22,'ruanxiaoqi','123456','阮小七',1,'13309090022',5,5500,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2016-01-01',3,'2023-10-20 16:35:33','2023-10-20 16:36:17'),
42
    (23,'ruanji','123456','阮籍',1,'13309090023',5,5800,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2012-01-01',3,'2023-10-20 16:35:33','2023-10-20 16:36:19'),
43
    (24,'tongwei','123456','童威',1,'13309090024',5,5000,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2006-01-01',3,'2023-10-20 16:35:33','2023-10-20 16:36:21'),
44
    (25,'tongmeng','123456','童猛',1,'13309090025',5,4800,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2002-01-01',3,'2023-10-20 16:35:33','2023-10-20 16:36:23'),
45
    (26,'yanshun','123456','燕顺',1,'13309090026',5,5400,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2011-01-01',3,'2023-10-20 16:35:33','2023-11-08 22:12:46'),
46
    (27,'lijun','123456','李俊',1,'13309090027',2,6600,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2004-01-01',2,'2023-10-20 16:35:33','2023-11-16 17:56:59'),
47
    (28,'lizhong','123456','李忠',1,'13309090028',5,5000,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2007-01-01',3,'2023-10-20 16:35:33','2023-11-17 16:34:22'),
48
    (30,'liyun','123456','李云',1,'13309090030',NULL,NULL,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2020-03-01',NULL,'2023-10-20 16:35:33','2023-10-20 16:36:31'),
49
    (36,'linghuchong','123456','令狐冲',1,'18809091212',2,6800,'https://web-framework.oss-cn-hangzhou.aliyuncs.com/2023/1.jpg','2023-10-19',2,'2023-10-20 20:44:54','2023-11-09 09:41:04');
50

51

52
-- 员工工作经历信息
53
create table emp_expr(
54
    id int unsigned primary key auto_increment comment 'ID, 主键',
55
    emp_id int unsigned comment '员工ID',
56
    begin date comment '开始时间',
57
    end  date comment '结束时间',
58
    company varchar(50) comment '公司名称',
59
    job varchar(50) comment '职位'
60
)comment '工作经历';

实体类

1
package com.itheima.pojo;
2

3
import lombok.Data;
4

5
import java.time.LocalDate;
6

7
/**
8
 * 工作经历
9
 */
10
@Data
11
public class EmpExpr {
12
    private Integer id; //ID
13
    private Integer empId; //员工ID
14
    private LocalDate begin; //开始时间
15
    private LocalDate end; //结束时间
16
    private String company; //公司名称
17
    private String job; //职位
18
}

1
package com.itheima.pojo;
2

3
import lombok.Data;
4

5
import java.time.LocalDate;
6
import java.time.LocalDateTime;
7
import java.util.List;
8

9
@Data
10
public class Emp {
11
    private Integer id; //ID,主键
12
    private String username; //用户名
13
    private String password; //密码
14
    private String name; //姓名
15
    private Integer gender; //性别, 1:男, 2:女
16
    private String phone; //手机号
17
    private Integer job; //职位, 1:班主任,2:讲师,3:学工主管,4:教研主管,5:咨询师
18
    private Integer salary; //薪资
19
    private String image; //头像
20
    private LocalDate entryDate; //入职日期
21
    private Integer deptId; //关联的部门ID
22
    private LocalDateTime createTime; //创建时间
23
    private LocalDateTime updateTime; //修改时间
24

25
    //封装部门名称数
26
    private String deptName; //部门名称
27
}

分页查询

1
package com.itheima.pojo;
2

3
import lombok.Data;
4

5
import java.util.List;
6
@Data
7
public class PageResult< T> {
8
    //定义格式进行封装
9
    private Long total;
10
    private List<T> rows;
11
    // 添加带参数的构造函数
12
    public PageResult(Long total, List<T> rows) {
13
        this.total = total;
14
        this.rows = rows;
15
    }
16
    // 无参构造函数
17
    public PageResult() {
18
    }
19
}

请求路径：/emps

请求方式：GET

请求参数：跟随在请求路径后的参数字符串。例：/emps?page=1&pageSize=10

响应数据：json格式

引入依赖

1
<!--分页插件PageHelper-->
2
<dependency>
3
    <groupId>com.github.pagehelper</groupId>
4
    <artifactId>pagehelper-spring-boot-starter</artifactId>
5
    <version>1.4.7</version>
6
</dependency>

Mapper

1
package com.itheima.mapper;
2
import com.itheima.pojo.Emp;
3
import com.itheima.pojo.EmpQueryParam;
4
import com.itheima.pojo.JobOption;
5
import com.itheima.pojo.Result;
6
import org.apache.ibatis.annotations.*;
7
import org.springframework.web.bind.annotation.GetMapping;
8

9
import java.time.LocalDate;
10
import java.util.List;
11
import java.util.Map;
12

13
//mybatis操作数据库员工基本信息
14
//查询总记录数
15
@Mapper
16
public interface EmpMapper {
17
    //原始方法
18
//    @Select("select count(*) from emp e left join dept d on e.dept_id =d.id ")
19
//    public Long count();
20
//    //分页查询 记录起始索引，每页记录数
21
//    @Select("select e.*,d.name from emp e left join dept d " +
22
//            "on e.dept_id =d.id limit #{start},#{pageSize}  ")
23
//    public List<Emp> list(Integer start, Integer pageSize);
24

25
   //利用pagehelper分页插件简化书写
26
@Select("select e.*,d.name from emp e left join dept d "+"on e.dept_id =d.id  ")

Controller

1
@Slf4j
2
@RequestMapping("/emps")
3
@RestController
4
public class EmpController {
5
    @Autowired
6
    private EmpService empService;
7

8
*分页查询
9
@GetMapping
10
public Result page(Integer page, Integer pageSize){
11
log.info("分页查询：{},{}"，page，pagesize)；
12
PageResult<Emp> pageResult = empService.page(page, pagesize);
13
return Result.success(pageResult);

Service

1
@Slf4j
2
@Service
3
public class EmpServiceImpl implements EmpService {
4
    @Autowired
5
    private EmpMapper empMapper;
6
    @Autowired
7
    private EmpExprMapper empExprMapper;
8
    @Autowired
9
    private EmpLogService empLogService;
10

11

12
    //    @Override
13
//    public PageResult<Emp> page(Integer page, Integer pageSize) {
14
//        //查询总记录数
15
//        Long total = empMapper.count();
16
//        //计算起始索引
17
//        Integer start = (page - 1) * pageSize;
18
//        List<Emp> rows = empMapper.list(start, pageSize);
19
//        return new PageResult<Emp>(total, rows);
20
//    }
21
    // 利用pagehelper分页插件简化书写
22
    @Override
23
    public PageResult<Emp> page(page,pageSize) {
24
        //设置分页参数
25
     PageHelper.startPage(page,pageSize);
26
     //存入ThreadLocal线程局部变量绑定当前线程
27

28
        //执行查询
29
        List<Emp> list = empMapper.list();
30
        //自定义拦截器Mybatis的Executor.query执行点
31
        //拼接分页语句limit ?,?
32
        //同时执行count(*)语句
33

34
        //page是arraylist 的子类，自带参数
35
        //将普通的list包装成Mybatis的page对象
36
        //ThreadLocal清理分页参数,避免下次查询污染
37
        Page<Emp> p = (Page<Emp>) list;//与pagehelper一起使用
38

39

40

41
        return new PageResult<>(p.getTotal(), p.getResult());
42
    }

PageHelper实现分页查询时，SQL语句的结尾一定不要加分号(;).。
PageHelper只会对紧跟在其后的第一条SQL语句进行分页处理。
pagehelper是对原有的sql语句进行拦截改造拼接多态编译page类，执行右边查询进行封装强转

PageHelper在进行分页查询时，会执行上述两条SQL语句，并将查询到的总记录数，与数据列表封装到了 Page<Emp> 对象中，我们再获取查询结果时，只需要调用Page对象的方法就可以获取。

条件查询

需求

员工查询 1.1输入员工名称进行搜索，支持模糊查询。 1.2选择员工性别进行精确查询 1.3选择入职时间的开始时间和结束时间，可以进行范围查询。 1.4 对查询结果根据修改时间倒序排序，并对查询结果进行分页展示。

初始

1
@GetMapping
2
public Result list(@RequestParam(defaultValue = "1")Integer page, @RequestParam(defaultValue = "1e") Integer pageSize, String name, Integer gender,
3
//注解保证请求头中日期格式转换
4
@DataTimeFormat(pattern = "yyyy-MM-dd"） LocalDate begin,@DataTimeFormat(pattern = "yyyy-MM-dd")LocalDate end） {

sql语句太长要用xml文件映射，在resouces创建目录名同包名创建xml文件在mybatis中文网找映射代码cv

利用mybatisx插件进行sql语句alt+enter

优化

实体类

1
package com.itheima.pojo;
2

3
import lombok.Data;
4
import org.springframework.format.annotation.DateTimeFormat;
5

6
import java.time.LocalDate;
7
@Data
8
public class EmpQueryParam {
9
    private Integer page=1;
10
    private Integer pageSize=10;
11
    private String name;
12
    private Integer gender;
13
    @DateTimeFormat(pattern = "yyyy-MM-dd")
14
    private LocalDate begin;
15
    @DateTimeFormat(pattern = "yyyy-MM-dd")
16
    private LocalDate end;
17
}

1
package com.itheima.pojo;
2

3
import lombok.Data;
4

5
import java.util.List;
6
@Data
7
public class PageResult< T> {
8
    //定义格式进行封装
9
    private Long total;
10
    private List<T> rows;
11
    // 添加带参数的构造函数
12
    public PageResult(Long total, List<T> rows) {
13
        this.total = total;
14
        this.rows = rows;
15
    }
16
    // 无参构造函数
17
    public PageResult() {
18
    }
19
}

Controller

1
    @GetMapping
2
    public Result list(EmpQueryParam param) {
3
        log.info("分页查询{}，{},{},{}",param);
4
        //返回前端封装的实体类的属性，封装在PageResult类中
5
        PageResult<Emp> pageResult= empService.page( param);
6
        return Result.success(pageResult);
7
    }

Service

1
   @Override
2
    public PageResult<Emp> page(EmpQueryParam param) {
3
        //设置分页参数
4
        PageHelper.startPage(param.getPage(), param.getPageSize());
5
        //执行查询
6
        List<Emp> list = empMapper.list(param);
7
        //page是arraylist 的子类
8
        Page<Emp> p = (Page<Emp>) list;//与pagehelper一起使用
9
        return new PageResult<>(p.getTotal(), p.getResult());
10
    }

动态sql

1
  //分页查询
2
   public List<Emp> list(EmpQueryParam param);

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
<mapper namespace="com.itheima.mapper.EmpMapper">
6
<!--namespace必须和mapper接口全类名一致-->
7

8
    <!--分页查询员工信息-->
9
    <!--id对应着mapper接口的方法名list()-->
10
    <!--ResultType查询结果自动封装成Emp对象-->
11
    <!--SQL字段别名必须严格等于实体类属性名，才能自动映射；-->
12
     <!--返回对象为emp实体类，在emp实体类加入deptName别名属性实现自动映射-->
13
     <!--封装部门名称private String deptName;-->
14

15
     <select id="list" resultType="com.itheima.pojo.Emp">
16
        select e.*,d.name deptName from emp e left join dept d on e.dept_id =d.id
17
        <!--test字段是EmpQueryParam param 里的字段，后面的字段为数据库字段-->
18
        <where>
19
            <if test="name != null and name != ''">
20
                and e.name like concat('%',#{name},'%')
21
            </if>
22

23
            <if test="gender != null">
24
                and e.gender = #{gender}
25
            </if>
26

27
            <if test="begin != null">
28
                and e.entry_date= #{begin}
29
            </if>
30

31
            <if test="end != null">
32
                and e.entry_date= #{end}
33
            </if>
34
        </where>
35
        order by e.create_time desc
36
    </select>

1.Mybatis中动态SQL的使用场景？如果SQL语句是不固定的，是随着用户的输入或外部条件的变化而变化的 2。MyBatis中动态SQL的及标签的作用？标签：条件判断，如果条件成立，则拼接对应的sql片段：根据查询条件，来生成where关键字，并会自动去除条件前面多余的and或or。

新增员工

新增字段

1
//员工基本信息表
2
@Data
3
public class Emp {
4
    private Integer id; //ID,主键
5
    private String username; //用户名
6
    private String password; //密码
7
    private String name; //姓名
8
    private Integer gender; //性别, 1:男, 2:女
9
    private String phone; //手机号
10
    private Integer job; //职位, 1:班主任,2:讲师,3:学工主管,4:教研主管,5:咨询师
11
    private Integer salary; //薪资
12
    private String image; //头像
13
    private LocalDate entryDate; //入职日期
14
    private Integer deptId; //关联的部门ID
15
    private LocalDateTime createTime; //创建时间
16
    private LocalDateTime updateTime; //修改时间
17

18

19

20
    //封装部门名称
21
    private String deptName;
22
    //封装员工工作经历信息
23
    private List<EmpExpr> exprList;
24

25
}

返回对象都是emp员工实体类

Controller

1
   //新增员工
2
    @PostMapping
3
    //@RequestBody需要传入一段json数据
4
    public Result add(@RequestBody Emp emp) {
5
     {
6
            log.info("请求参数emp: {}", emp);
7
            empService.save(emp);
8
            return Result.success();
9
        }}

Service

1
@Override
2
public voidsave(Emp emp）{
3
//1.保存员工基本信息
4
emp.setCreateTime(LocalDateTime.now());
5
emp.setUpdateTime(LocalDateTime.now());
6
empMapper.insert(emp);
7
//2.保存员工工作经历信息
8
List<EmpExpr> exprList = emp.getExprList();
9
if(!CollectionUtils.isEmpty(exprList)){//遍历集合，为empId赋值
10
//Landom表达式list.forEach(形参->{方法体})
11
exprList.forEach(empExpr->{
12
empExpr.setEmpId(emp.getId( )});
13
empExprMapper.insertBatch(exprList);
14
}

Mapper

1
/**
2
    * 新增员工数据
3
    */
4
   //新增员工基本信息并且用@Options(useGeneratedKeys = true, keyProperty = "id")获取id属性
5
   @Options(useGeneratedKeys = true, keyProperty = "id")
6

7
   @Insert("insert into emp(username, name, gender, phone, job, salary, image, entry_date, dept_id, create_time, update_time) " +
8
  "values (#{username},#{name},#{gender},#{phone},#{job},#{salary},#{image},{entryDate},#{deptId},#{createTime},#{updateTime})")
9
   void insert(Emp emp);

1
package com.itheima.mapper;
2
import com.itheima.pojo.EmpExpr;
3
import org.apache.ibatis.annotations.Mapper;
4

5
import java.util.List;
6

7
//操作员工经历
8
    @Mapper
9
    public interface EmpExprMapper {
10

11
        /**
12
         * 批量插入员工工作经历信息
13
         */
14
        void insertBatch(List<EmpExpr> exprList);

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
<mapper namespace="com.itheima.mapper.EmpExprMapper">
6
<!--    批量插入员工工作经历信息-->
7
    <！--批量保存员工工作经历信息
8
    foreach标签：
9
collection：遍历的集合item：遍历出来的元素
10
separator：每次循环之间的分隔符-->
11

12
    <insert id="insertBatch">
13
    insert into emp_expr(emp_id,begin,end,company,job) values
14
    <foreach collection="exprList" item="item" separator=",">
15
     (#{item.empId},#{item.begin},#{item.end},#{item.company},#{item.job})
16
    </foreach>
17

18
    </insert>

Spring事务

初识

事务是一组操作的集合，它是一个不可分割的工作单位。事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

1
//开启事务
2
start transaction; / begin;
3
//提交事务（全部成功）/回滚事务（有一个失败）
4
commit;/ rollback;

1
注解：@Transactional
2
作用：将当前方法交给spring进行事务管理，方法执行前，开启事务；成功执行完毕，提交事务；出现异常，回滚事务
3
位置：业务（service）层的方法上、类上、接口上
4

5
默认出现运行时异常RuntimeException才会回滚

进阶

事务传播

1
//新增员工信息
2
//事务传播行为：指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。
3
//常见的传播行为及应用场景？REQUIRED：大部分场景 需要事务，有则加入，无则创建新事务
4
REQUIRES_NEW：希望两个方法在独立的事务中运行，互不影响   需要新事务，无论有，总是创建新事务
5
     @Transactional(rollbackFor = Exception.class)//事务注解
6
     //所有异常都回滚
7
    @Override
8
    public void save(Emp emp) {
9
        try {
10
            //1.补全基础属性
11
            emp.setCreateTime(LocalDateTime.now());
12
            emp.setUpdateTime(LocalDateTime.now());
13

14
            //2.保存员工基本信息
15
            empMapper.insert(emp);
16
            //3. 保存员工的工作经历信息 - 批量
17
            Integer empId = emp.getId();
18
            //获取员工工作经历信息
19
            List<EmpExpr> exprList = emp.getExprList();
20
//            判断是否为空遍历赋值员工id批量插入员工经历信息<foreach
21
            if(!CollectionUtils.isEmpty(exprList)){
22
                exprList.forEach(empExpr -> empExpr.setEmpId(empId));
23
                empExprMapper.insertBatch(exprList);
24
            }
25
        } finally {
26
            //记录操作日志
27
            EmpLog empLog = new EmpLog(null, LocalDateTime.now(), emp.toString());
28
            empLogService.insertLog(empLog);
29
        }
30
    }

文件上传

Controller

1
public class UploadController {
2

3
    @Autowired
4
    private AliyunOSSOperator aliyunOSSOperator;
5

6
    @PostMapping("/upload")
7
    public Result upload(MultipartFile file) throws Exception {
8
        log.info("上传文件：{}", file);
9
        if (!file.isEmpty()) {
10
            // 生成唯一文件名
11
            String originalFilename = file.getOriginalFilename();
12
            String extName=originalFilename.substring(originalFilename.lastIndexOf("."));
13
            String uniqueFileName = UUID.randomUUID().toString().replace("-", "") + extName;
14
            // 上传文件
15
            String url = aliyunOSSOperator.upload(file.getBytes(), uniqueFileName);
16
            return Result.success(url);
17
        }
18
        return Result.error("上传失败");
19
    }
20

21
}

yml文件

1
#配置oss存储
2
aliyun:
3
    oss:
4
        endpoint: http://oss-cn-beijing.aliyuncs.com
5
        bucketName: java-ai-tlias2026
6
        region: cn-beijing

工具类

1
package com.itheima.Utils;
2

3
import lombok.Data;
4
import org.springframework.boot.context.properties.ConfigurationProperties;
5
import org.springframework.stereotype.Component;
6
@Data
7
@Component
8
@ConfigurationProperties(prefix = "aliyun.oss")
9
public class AliyunOSSProperties {
10
    private String endpoint;
11
    private String bucketName;
12
    private String region;
13
}

1
package com.itheima.Utils;
2

3
import com.aliyun.oss.*;
4
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
5
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
6
import com.aliyun.oss.common.comm.SignVersion;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.stereotype.Component;
9
import java.io.ByteArrayInputStream;
10
import java.time.LocalDate;
11
import java.time.format.DateTimeFormatter;
12
import java.util.UUID;
13

14
@Component
15
public class AliyunOSSOperator {
16

17
    @Autowired
18
    private AliyunOSSProperties aliyunOSSProperties;
19
    public String upload(byte[] content, String originalFilename) throws Exception {
20

21
        String endpoint = aliyunOSSProperties.getEndpoint();
22
        String bucketName = aliyunOSSProperties.getBucketName();
23
        String region = aliyunOSSProperties.getRegion();
24
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量 OSS_ACCESS_KEY_ID 和 OSS_ACCESS_KEY_SECRET。
25
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
26

27
        // 填写 Object 完整路径，例如 202406/1.png。Object 完整路径中不能包含 Bucket 名称。
28
        //获取当前系统日期的字符串，格式为 yyyy/MM
29
        String dir = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM"));
30
        //生成一个新的不重复的文件名
31
        String newFileName = UUID.randomUUID() + originalFilename.substring(originalFilename.lastIndexOf("."));
32
        String objectName = dir + "/" + newFileName;
33

34
        // 创建 OSSClient 实例。
35
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
36
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
37
        OSS ossClient = OSSClientBuilder.create()
38
                .endpoint(endpoint)
39
                .credentialsProvider(credentialsProvider)
40
                .clientConfiguration(clientBuilderConfiguration)
41
                .region(region)
42
                .build();
43

44
        try {
45
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content));
46
        } finally {
47
            ossClient.shutdown();
48
        }
49

50
        return endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + objectName;
51
    }
52

53
}

1
@Component
2
public class'Aliyunossoperator {
3
@Value("${aliyun.oss.endpoint} ")
4
private String endpoint;
5
Value("${aliyun.oss . bucketName} ")
6
private String bucketName;
7
@value("${aliyun.oss.region} ")
8
private String region;

注入外部配置文件中的配置项的两种方式？

@Value：一个属性一个属性的注入
@ConfigurationProperties：批量将多个属性注入到bean对象中
两种方式各自的使用场景？
如果属性较少，建议@Value注入即可
如果属性较多,考虑复用，建议使用@ConfigurationProperties

删除员工

Controller

1
    //删除员工信息
2
    @DeleteMapping
3
    public Result delete(@RequestParam("ids") List<Integer> ids)
4
    {
5
        log.info("删除员工信息{}",ids);
6
        empService.delete(ids);
7
        return Result.success();
8
    }

Service

1
//批量删除员工信息
2
    @Transactional(rollbackFor = Exception.class)//事务注解 任何错误都回滚
3
    @Override
4
    public void delete(List<Integer> ids) {
5
        //1.删除员工基本信息
6
        empMapper.deleteByIds(ids);
7
        //2.删除员工的工作经历信息
8
        empExprMapper.deleteByEmpIds(ids);
9
    }

Mapper

1
   //批量删除员工的基本信息
2
   void deleteByIds(List<Integer> ids);

1
    <!--    //批量删除员工的基本信息-->
2
    <delete id="deleteByIds">
3
        delete from emp where id in
4
        <foreach collection="ids" item="id" separator="," open="(" close=")">
5
            #{id}
6
        </foreach>
7
    </delete>

1
//操作员工经历
2
    @Mapper
3
    public interface EmpExprMapper {
4

5
   /**
6
         * 批量插入员工工作经历信息
7
         */
8
        void insertBatch(List<EmpExpr> exprList);
9
//批量删除员工工作经历信息
10
    void deleteByEmpIds(List<Integer> empIds);
11
}

1
<!--    //批量删除员工经历信息（1，2，3，）-->
2
    <delete id="deleteByEmpIds">
3
        delete from emp_expr where emp_id in
4
         <foreach collection="empIds" item="empId" separator="," open="(" close=")">
5
            #{empId}
6
        </foreach>
7
    </delete>

多个id的接收可采用数组和集合进行接收，集合方法多推荐使用但是需要@RequestParam注解

修改员工

回显数据

Controller

1
    //员工信息回显
2
   @GetMapping("/{id}")
3
    public Result getInfo(@PathVariable Integer id)
4
   {
5
       log.info("查询员工信息{}",id);
6
       //放入单个对象里封装
7
       Emp emp = empService.getinfo(id);
8
       return Result.success(emp);
9
   }

Service

1
    //查询回显
2
    @Override
3
    public Emp getinfo(Integer id) {
4
        return empMapper.getById(id);
5
    }

Mapper

1
//查询回显员工数据认识到了resultmap和resulttype的区别
2
   Emp getById(Integer id);

1
    <!--    //编辑员工信息 查询回显-->
2
    <select id="getById" resultMap="empResultMap">
3
        select e.*,
4
               ee.id ee_id,
5
               ee.company ee_company,
6
               ee.job ee_job,
7
               ee.begin ee_begin,
8
               ee.end ee_end,
9
               ee.emp_id ee_empid
10
        from emp e left join emp_expr ee on e.id = ee.emp_id
11
        where e.id = #{id}
12
    </select>

1
    <!--    查询回显-->
2
    <!--    定义resultMap类-->
3
    <resultMap id="empResultMap" type="com.itheima.pojo.Emp">
4
        <id column="id" property="id"/>
5
        <result column ="username" property="username"/>
6
        <result column ="password" property="password"/>
7
        <result column ="name" property="name"/>
8
        <result column ="gender" property="gender"/>
9
        <result column ="phone" property="phone"/>
10
        <result column ="job" property="job"/>
11
        <result column ="salary" property="salary"/>
12
        <result column ="image" property="image"/>
13
        <result column ="entry_date" property="entryDate"/>
14
        <result column ="dept_id" property="deptId"/>
15
        <result column ="create_time" property="createTime"/>
16
        <result column ="update_time" property="updateTime"/>
17
        <!--封装exprList-->
18
        <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">
19
            <id column="ee_id" property="id"/>
20
            <result column ="ee_empid" property="empId"/>
21
            <result column ="ee_company" property="company"/>
22
            <result column ="ee_job" property="job"/>
23
            <result column ="ee_begin" property="begin"/>
24
            <result column ="ee_end" property="end"/>
25
        </collection>
26
    </resultMap>
27
 <!--一个员工有两段经历封装成一个对象但mybatis会封装成两个需要手动封装resultMap, 首先要定义每个属性property为实体类,自动封装用resultype, 外连接字段重复需要取别名-->

Mybatis中封装查询结果，什么时候用resultType，什么时候用resultMap?

如果查询返回的字段名与实体的属性名可以直接对应上，用resultType。
如果查询返回的字段名与实体的属性名对应不上，或实体属性比较复杂，可以通过resultMap手动封装。

修改数据

Controller

1
  //更改员工信息
2
    @PutMapping  //@RequestBody需要传入一段json数据
3
    public Result update(@RequestBody Emp emp){
4
        log.info("更新员工信息{}",emp);
5
        empService.update(emp);
6
        return Result.success();
7
    }

Service

1
  //编辑员工信息
2
    @Transactional(rollbackFor = Exception.class)
3
    @Override
4
    public void update(Emp emp) {
5
        emp.setUpdateTime(LocalDateTime.now());
6
        empMapper.updateById(emp);
7
       //根据ID修改需要先删除后增加
8
        //1.批量删除  根据 ID删除原有的工作经历信息m
9
        empExprMapper.deleteByEmpIds(Arrays.asList(emp.getId()));
10
        //asList()将数组转换成List可变参数
11
        //2.批量插入  根据员工ID插入新的工作经历信息
12
        List<EmpExpr> exprList = emp.getExprList();
13
        if (!CollectionUtils.isEmpty(exprList)) {
14
            exprList.forEach(empExpr -> empExpr.setEmpId(emp.getId()));
15
            empExprMapper.insertBatch(exprList);
16
        }
17
    }

Mapper

1
    <!--    动态sql防止输入一个信息报错-->
2
    <!--    更新员工的基本信息-->
3
    <update id="updateById">
4
        update emp
5
        <set>
6
            <if test="username != null and username != ''">
7
                username=#{username},
8
            </if>
9
            <if test="password != null and password != ''">
10
                password=#{password},
11
            </if>
12
            <if test="name != null and name != ''">
13
                name=#{name},
14
            </if>
15
            <if test="gender != null">
16
                gender=#{gender},
17
            </if>
18
            <if test="phone != null and phone != ''">
19
                phone=#{phone},
20
            </if>
21
            <if test="job != null and job != ''">
22
                job=#{job},
23
            </if>
24
            <if test="salary != null">
25
                salary=#{salary},
26
            </if>
27
            <if test="image != null and image != ''">
28
                image=#{image},
29
            </if>
30
            <if test="entryDate != null">
31
                entry_date=#{entryDate},
32
            </if>
33
            <if test="deptId != null">
34
                dept_id=#{deptId},
35
            </if>
36
            <if test="updateTime != null">
37
                update_time=#{updateTime},
38
            </if>
39
        </set>
40
        where id=#{id}
41
    </update>
42
    <--set标签：会自动生成set关键字；会自动的删除掉更新字段后多余,->

全局异常处理

@RestControllerAdvice = @ControllerAdvice + @ResponseBody
处理异常的方法返回值会转换为json后再响应给前端
@RestControllerAdvice //表示当前类为全局异常处理器
@ExceptionHandler //指定可以捕获哪种类型的异常进行处理

1
package com.itheima.exception;
2

3
import com.itheima.pojo.Result;
4
import org.springframework.web.bind.MissingServletRequestParameterException;
5
import org.springframework.web.bind.annotation.ExceptionHandler;
6
import org.springframework.web.bind.annotation.RestControllerAdvice;
7
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
8

9
@RestControllerAdvice
10
public class GlobalExceptionHandler {
11

12
    //处理通用异常
13
    @ExceptionHandler(Exception.class)
14
    public Result handleException(Exception e){
15
        e.printStackTrace();
16
        return Result.error("对不起，操作失败，请联系管理员");
17
    }
18

19
    //处理参数类型转换异常
20
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
21
    public Result handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e){
22
        e.printStackTrace();
23
        return Result.error("参数类型错误，请检查请求参数");
24
    }
25

26
    //处理缺少请求参数异常
27
    @ExceptionHandler(MissingServletRequestParameterException.class)
28
    public Result handleMissingServletRequestParameterException(MissingServletRequestParameterException e){
29
        e.printStackTrace();
30
        return Result.error("缺少必要的请求参数");
31
    }
32

33
    //处理手机号重复异常
34
    @ExceptionHandler(PhoneRepeatException.class)
35
    public Result handlePhoneRepeatException(PhoneRepeatException e){
36
        e.printStackTrace();
37
        return Result.error("手机号重复，请重新输入");
38
    }
39

40
}

1
package com.itheima.exception;
2

3
public class PhoneRepeatException extends RuntimeException {
4
    public PhoneRepeatException() {
5
        super();
6
    }
7

8
    public PhoneRepeatException(String message) {
9
        super(message);
10
    }
11

12
    public PhoneRepeatException(String message, Throwable cause) {
13
        super(message, cause);
14
    }
15
}

数据可视化

返回实体类

1
package com.itheima.pojo;
2

3
import lombok.AllArgsConstructor;
4
import lombok.Data;
5
import lombok.NoArgsConstructor;
6
import java.util.List;
7
//数据传入参数的实体类
8
@Data
9
@NoArgsConstructor
10
@AllArgsConstructor
11
public class JobOption {
12
    private List jobList;
13
    private List dataList;
14

15
}

Controller

1
package com.itheima.controller;
2

3
import com.itheima.pojo.JobOption;
4
import com.itheima.pojo.Result;
5
import com.itheima.service.ReportService;
6
import lombok.extern.slf4j.Slf4j;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.web.bind.annotation.GetMapping;
9
import org.springframework.web.bind.annotation.RequestMapping;
10
import org.springframework.web.bind.annotation.RestController;
11

12
import java.util.List;
13
import java.util.Map;
14

15
@Slf4j
16
@RequestMapping("/report")
17
@RestController
18
public class ReportController {
19

20
    @Autowired
21
    private ReportService reportService;
22

23
    /**
24
     * 统计各个职位的员工人数
25
     */
26
    @GetMapping("/empJobData")
27
    public Result getEmpJobData(){
28
        log.info("统计各个职位的员工人数");
29
        JobOption jobOption = reportService.getEmpJobData();
30
        return Result.success(jobOption);
31
    }
32
    /**
33
     * 统计员工性别信息
34
     */
35
    @GetMapping("/empGenderData")
36
    public Result getEmpGenderData(){
37
        log.info("统计员工性别信息");
38
        List<Map> genderList = reportService.getEmpGenderData();
39
        return Result.success(genderList);
40
    }
41
}

Service

1
package com.itheima.service.impl;
2

3
import com.itheima.mapper.EmpMapper;
4
import com.itheima.pojo.JobOption;
5
import com.itheima.service.ReportService;
6
import org.springframework.beans.factory.annotation.Autowired;
7
import org.springframework.stereotype.Service;
8

9
import java.util.List;
10
import java.util.Map;
11
    // ... existing code ...
12
    @Service
13
    public class ReportServiceImpl implements ReportService {
14

15
        @Autowired
16
        private EmpMapper empMapper;
17
     //统计各个职工的人数
18
        @Override
19
        public JobOption getEmpJobData() {
20
            List<Map<String,Object>> list = empMapper.countEmpJobData();
21
            List<Object> jobList = list.stream().map(dataMap ->
22
            dataMap.get("pos")).toList();
23
            List<Object> dataList = list.stream().map(dataMap ->         dataMap.get("num")).toList();
24
            return new JobOption(jobList, dataList);
25
        }
26
      //统计员工性别
27
        @Override
28
        public List<Map> getEmpGenderData() {
29
            return empMapper.countEmpGenderData();
30
        }
31
    }

Mapper

1
   //统计员工人数
2
   List<Map<String,Object>> countEmpJobData();
3
   // 统计男女员工人数
4
   /**
5
    * 统计员工性别信息
6
    */
7
   @MapKey("name")
8
   List<Map> countEmpGenderData();
9

10
  // 如果查询的记录往Map中封装，可以通过@MapKey注解指定返回的map中的唯一标识是那个字段。

1
 <!--    统计员工人数-->
2
    <select id="countEmpJobData" resultType="java.util.Map">
3
select (case when job=1 then '班主任'
4
    when job=2 then '讲师'
5
    when job=3 then '学工主管'
6
    when job=4 then '教研主管'
7
    when job=5 then '咨询师'
8
    else '其他' end) pos,count(*) num
9
from emp
10
group by job order by num
11

12
    </select>
13
    <!-- 统计员工的性别信息 -->
14
    <select id="countEmpGenderData" resultType="java.util.Map">
15
        select
16
            if(gender = 1, '男', '女') as name,
17
            count(*) as value
18
        from emp group by gender ;
19
    </select>

case流程控制函数：

语法一：case when cond1 then res1 [ when cond2 then res2 ] else res end ;
含义：如果 cond1 成立，取 res1。如果 cond2 成立，取 res2。如果前面的条件都不成立，则取 res。
语法二（仅适用于等值匹配）：case expr when val1 then res1 [ when val2 then res2 ] else res end ;
含义：如果 expr 的值为 val1 ，取 res1。如果 expr 的值为 val2 ，取 res2。如果前面的条件都不成立，则取 res。

if函数语法：if(条件, 条件为true取值, 条件为false取值)

if null函数语法：ifnull(expr, val1) 如果expr不为null，取自身，否则取val1

登录认证

前置数据

1
package com.itheima.pojo;
2

3
import lombok.AllArgsConstructor;
4
import lombok.Data;
5
import lombok.NoArgsConstructor;
6

7
@Data
8
@NoArgsConstructor
9
@   AllArgsConstructor
10
public class LoginInfo {
11
    private Integer id;
12
    private String username;
13
    private String name;
14
    private String token;
15
}

Controller

1
package com.itheima.controller;
2

3
import com.itheima.pojo.Emp;
4
import com.itheima.pojo.LoginInfo;
5
import com.itheima.pojo.Result;
6
import com.itheima.service.EmpService;
7
import lombok.extern.slf4j.Slf4j;
8
import org.springframework.beans.factory.annotation.Autowired;
9
import org.springframework.web.bind.annotation.PostMapping;
10
import org.springframework.web.bind.annotation.RequestBody;
11
import org.springframework.web.bind.annotation.RequestMapping;
12
import org.springframework.web.bind.annotation.RestController;
13

14
@Slf4j
15
@RestController
16
@RequestMapping("/login")
17
public class LoginController {
18
    @Autowired
19
    private EmpService empService;
20
    //登录服务
21
    //emp实体类中有username和password属性
22
    @PostMapping
23
    public Result login(@RequestBody Emp emp){
24
        log.info("员工登录，参数：{}",emp);
25
        LoginInfo info =empService.login(emp);
26
        if(info != null){
27
            return Result.success(info);
28
        }else{
29
            return Result.error("用户名或密码错误");
30
        }
31
    }
32
}

Mapper

1
    //根据用户名和密码查询员工信息
2
   @Select("select id,username, name from emp where username=#{username} and password=#{password} ")
3
    Emp selectByUsernameAndPassword(Emp emp);
4
}

登录校验

会话：用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应
会话跟踪：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。
会话跟踪方案：
客户端会话跟踪技术：Cookie
服务端会话跟踪技术：Session
令牌技术
HTTP协议是无状态协议无状态，指的是每一次请求都是独立的

服务器端在给客户端在响应数据的时候，会自动的将 cookie 响应给浏览器，浏览器接收到响应回来的 cookie 之后，会自动的将 cookie 的值存储在浏览器本地。接下来在后续的每一次请求当中，都会将浏览器本地所存储的 cookie 自动地携带到服务端

1
@Slf4j
2
@RestController
3
public class SessionController {
4

5
    //设置Cookie
6
    @GetMapping("/c1")
7
    public Result cookie1(HttpServletResponse response){
8
        response.addCookie(new Cookie("login_username","itheima")); //设置Cookie/响应Cookie
9
        return Result.success();
10
    }
11

12
    //获取Cookie
13
    @GetMapping("/c2")
14
    public Result cookie2(HttpServletRequest request){
15
        Cookie[] cookies = request.getCookies();
16
        for (Cookie cookie : cookies) {
17
            if(cookie.getName().equals("login_username")){
18
                System.out.println("login_username: "+cookie.getValue()); //输出name为login_username的cookie
19
            }
20
        }
21
        return Result.success();
22
    }
23
}

优点：HTTP协议中支持的技术（像Set-Cookie 响应头的解析以及 Cookie 请求头数据的携带，都是浏览器自动进行的，是无需我们手动操作的）
缺点：
- 移动端APP(Android、IOS)中无法使用Cookie
- 不安全，用户可以自己禁用Cookie
- Cookie不能跨域
- 区分跨域的维度（三个维度有任何一个维度不同，那就是跨域操作）：
  - 协议
  - IP/协议
  - 端口
  举例：
  - http://192.168.150.200/login.html ----------> https://192.168.150.200/login [协议不同，跨域]
  - http://192.168.150.200/login.html ----------> http://192.168.150.100/login [IP不同，跨域]
  - http://192.168.150.200/login.html ----------> http://192.168.150.200:8080/login [端口不同，跨域]
  - http://192.168.150.200/login.html ----------> http://192.168.150.200/login [不跨域]

session

jwt令牌

初识

JWT的组成：（JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

第一部分：Header(头），记录令牌类型、签名算法等。例如：{“alg”:“HS256”,“type”:“JWT”}
第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。例如：{“id”:“1”,“username”:“Tom”}
第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。
签名的目的就是为了防jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，
所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。

初识令牌

1
//生成令牌
2
@Test
3
public void genJwt(){
4
    Map<String, Object> claims = new HashMap<>();
5
    claims.put("id", 10);
6
    claims.put("username", "itheima");
7

8
    String jwt = Jwts.builder().signWith(SignatureAlgorithm.HS256, "aXRjYXN0")//指定加密
9
        .addClaims(claims) //添加自定义信息
10
        .setExpiration(new Date(System.currentTimeMillis() + 60 * 1000)) //有效期60s
11
        .compact(); //生成令牌
12
    System.out.println(jwt);
13

14
    //输出结果：eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjczMDA5NzU0fQ.RcVIR65AkGiax-ID6FjW60eLFH3tPTKdoK7UtE4A1ro
15
}
16

17
@Test
18
public void parseJwt(){
19
    Claims claims = Jwts.parser()
20
        .setSigningKey("aXRjYXN0")//指定签名密钥
21
        .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjczMDA5NzU0fQ.RcVIR65AkGiax-ID6FjW60eLFH3tPTKdoK7UtE4A1ro")  //解析令牌
22
        .getBody(); //获取自定义信息
23

24
    System.out.println(claims);
25
}

依赖引入

1
<!-- JWT依赖-->
2
<dependency>
3
    <groupId>io.jsonwebtoken</groupId>
4
    <artifactId>jjwt</artifactId>
5
    <version>0.9.1</version>
6
</dependency>

1
package com.itheima.Utils;
2

3
import io.jsonwebtoken.Claims;
4
import io.jsonwebtoken.Jwts;
5
import io.jsonwebtoken.SignatureAlgorithm;
6

7
import java.util.Date;
8
import java.util.Map;
9

10
public class JwtUtils {
11

12
    private static String signKey = "SVRIRUlNQQ==";
13
    private static Long expire = 43200000L;
14
    /**
15
     * 生成JWT令牌
16
     * @return
17
     */
18
    public static String generateJwt(Map<String,Object> claims){
19
        String jwt = Jwts.builder()
20
                .addClaims(claims)//添加自定义属性
21
                .signWith(SignatureAlgorithm.HS256, signKey)//签名算法
22
                .setExpiration(new Date(System.currentTimeMillis() + expire))//设置令牌过期时间
23
                .compact();
24
        return jwt;
25
    }
26
    /**
27
     * 解析JWT令牌
28
     * @param jwt JWT令牌
29
     * @return JWT第二部分负载 payload 中存储的内容
30
     */
31
    public static Claims parseJWT(String jwt){
32
        Claims claims = Jwts.parser()
33
                .setSigningKey(signKey)//签名算法
34
                .parseClaimsJws(jwt)//解析JWT令牌
35
                .getBody();//获取负载
36
        return claims;
37
    }
38
}

Service

1
@Override
2
public LoginInfo login(Emp emp) {
3
    //调用mapper接口查询账号密码是否匹配
4
    Emp empLogin = empMapper.getUsernameAndPassword(emp);
5
    if(empLogin != null){
6
        //1. 生成JWT令牌
7
        Map<String,Object> dataMap = new HashMap<>();
8
        dataMap.put("id", empLogin.getId());
9
        dataMap.put("username", empLogin.getUsername());
10

11
        String jwt = JwtUtils.generateJwt(dataMap);////传入自定义对象的集合并生成jwt令牌
12
        LoginInfo loginInfo = new LoginInfo(empLogin.getId(), empLogin.getUsername(), empLogin.getName(), jwt);
13
        return loginInfo;
14
    }
15
    return null;
16
}

服务器响应的JWT令牌存储在本地浏览器哪里了呢？
- 在当前案例中，JWT令牌存储在浏览器的本地存储空间 localstorage中了。 localstorage 是浏览器的本地存储，在移动端也是支持的。
- 此时我们可以看到在请求头中包含一个token(JWT令牌)，后续的每一次请求当中，都会将这个令牌携带到服务端。

过滤器

概念：Filter过滤器，是JavaWeb三大组件（Servlet、Filter、Listener）之一。
过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能。
过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。

定义Filter：定义一个类，实现Filter接口，并实现其所有方法。
配置Filter：Filter类上加@WebFilter注解，配置拦截路径。引导类上加 aServletComponentScan 开启Servlet组件支持。

1
public class DemoFilter implements Filter {
2

3
    // 初始化方法，web服务器启动，创建Filter实例时调用，只调用一次
4
    public void init(FilterConfig filterConfig) throws ServletException {
5
        System.out.println("init ...");
6
    }
7

8
    // 拦截到请求时，调用该方法，可以调用多次
9
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws Exception {
10
        System.out.println("拦截到了请求...");
11
        chain.doFilter(servletRequest, servletResponse);
12
    }
13

14
    // 销毁方法，web服务器关闭时调用，只调用一次
15
    public void destroy() {
16
        System.out.println("destroy ...");
17
    }
18
}

登录校验

所有的请求，拦截到了之后，都需要校验令牌吗？有一个例外，登录请求
拦截到请求后，什么情况下才可以放行，执行业务操作？有令牌，且令牌校验通过（合法）；否则都返回未登录错误结果

1
/**
2
 * 令牌校验过滤器
3
 */
4
@Slf4j
5
@WebFilter(urlPatterns = "/*")
6
public class TokenFilter implements Filter {
7
    @Override
8
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
9
        HttpServletRequest request = (HttpServletRequest) req;
10
        HttpServletResponse response = (HttpServletResponse) resp;
11
        //1. 获取请求url。
12
        String url = request.getRequestURL().toString();
13

14
        //2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行。
15
        if(url.contains("login")){ //登录请求
16
            log.info("登录请求 , 直接放行");
17
            chain.doFilter(request, response);
18
            return;
19
        }
20

21
        //3. 获取请求头中的令牌（token）。
22
        String jwt = request.getHeader("token");
23

24
        //4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）。
25
        if(!StringUtils.hasLength(jwt)){ //jwt为空
26
            log.info("获取到jwt令牌为空, 返回错误结果");
27
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
28
            return;
29
        }
30

31
        //5. 解析token，如果解析失败，返回错误结果（未登录）。
32
        try {
33
            Claims claims = JwtUtils.parseJWT(jwt);
34
           Integer empId=Integer.valueOf( claims.get("id").toString());
35
           CurrentHolder.setCurrentId(empId);
36
           log.info("当前用户id为将其导入ThreadLocal中：{}",empId);
37
        } catch (Exception e) {
38
            e.printStackTrace();
39
            log.info("解析令牌失败, 返回错误结果");
40
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
41
            return;
42
        }
43

44
        //6. 放行。
45
        log.info("令牌合法, 放行");
46
        chain.doFilter(request , response);
47
        //移除ThreadLocal中的数据
48
        CurrentHolder.remove();
49
    }
50

51
}

拦截器

• 定义：实现HandlerInterceptor接口

preHandle
postHandle
afterCompletion

• 配置：定义一个配置类实现WebMvcConfigurer接口，注册拦截器(/**)

1
//自定义拦截器
2
//@Component
3
public class DemoInterceptor implements HandlerInterceptor {
4
    //目标资源方法执行前执行。返回 true：放行    返回 false：不放行
5
    @Override
6
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
7
        System.out.println("preHandle .... ");
8

9
        return true; //true 表示放行
10
    }
11

12
    //目标资源方法执行后执行
13
    @Override
14
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
15
        System.out.println("postHandle ... ");
16
    }
17

18
    //视图渲染完毕后执行，最后执行
19
    @Override
20
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
21
        System.out.println("afterCompletion .... ");
22
    }
23
}

1
//@Component
2
@Slf4j
3
public class TokenInterceptor implements HandlerInterceptor {
4
    @Override
5
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
6
        //获取url
7
        //1. 获取请求url。
8
        String url = request.getRequestURL().toString();
9

10
        //2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行。
11
        if(url.contains("login")){ //登录请求
12
            log.info("登录请求 , 直接放行");
13
            return true;
14
        }
15

16
        //3. 获取请求头中的令牌（token）。
17
        String jwt = request.getHeader("token");
18

19
        //4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）。
20
        if(!StringUtils.hasLength(jwt)){ //jwt为空
21
            log.info("获取到jwt令牌为空, 返回错误结果");
22
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
23
            return false;
24
        }
25

26
        //5. 解析token，如果解析失败，返回错误结果（未登录）。
27
        try {
28
            JwtUtils.parseJWT(jwt);
29
        } catch (Exception e) {
30
            e.printStackTrace();
31
            log.info("解析令牌失败, 返回错误结果");
32
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
33
            return false;
34
        }
35

36
        //6. 放行。
37
        log.info("令牌合法, 放行");
38
  return true;
39
    }
40
    }

1
//@Configuration
2
public class WebConfig implements WebMvcConfigurer {
3

4
    //自定义的拦截器对象
5
    @Autowired
6
    private TokenInterceptor demoInterceptor;
7

8

9
    @Override
10
    public void addInterceptors(InterceptorRegistry registry) {
11
        //注册自定义拦截器对象
12
        registry.addInterceptor(demoInterceptor).addPathPatterns("/**").excludePathPatterns("/login");//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
13
    }
14
    @Override
15
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
16
        // 禁用默认的资源处理器，避免将未知路径当作静态资源处理
17
        registry.setOrder(1);
18
    }
19
}

SpringAop

初识

AOP 是面向切面编程，适合把一些和业务逻辑无关、但很多方法都需要的公共功能抽取出来统一处理，比如：

统计方法执行耗时
日志记录
权限校验
事务管理
异常处理

1
<dependency>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-aop</artifactId>
4
</dependency>

@Aspect：声明当前类是切面类

@Component：把切面类交给 Spring 管理

@Around：环绕通知，可以在目标方法前后都执行代码

joinPoint.proceed()：执行原始目标方法

execution(...)：指定哪些方法需要被增强

通知

@Pointcut 的作用

如果切点表达式很长，或者多个通知都要用同一个表达式，可以用 @Pointcut 抽取出来。

1
@Slf4j
2
@Aspect
3
@Component
4
public class RecordTimeAspect {
5

6
    @Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
7
    public void pt() {
8
    }
9
    @Around("pt()")
10

11
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
12
        long begin = System.currentTimeMillis();
13

14
        Object result = joinPoint.proceed();
15

16
        long end = System.currentTimeMillis();
17

18
        log.info("方法 {} 执行耗时: {}ms", joinPoint.getSignature(), end - begin);
19

20
        return result;
21
    }
22
}

通知类型

切入点表达式

execution

execution 主要根据方法的返回值、包名、类名、方法名、参数等信息来匹配方法。

1
execution(public void com.itheima.service.DeptService.delete(java.lang.Integer))
2

3
com.itheima.service.DeptService
4
public void delete(Integer id)

1
execution(* com.*.service.*.update*(*))

任意返回值
com 下一级任意包
service 包
任意类
以 update 开头的方法
方法有一个任意类型参数

.. 表示多个连续任意符号。

1
 execution(* com.itheima..DeptService.*(..))

com.itheima包及其任意子包下的DeptService`
DeptService 中任意方法
任意参数个数和类型

1
@Before("execution(* com.itheima.service.impl.DeptServiceImpl.list(..)) || " +
2
        "execution(* com.itheima.service.impl.DeptServiceImpl.delete(..))")
3
public void before() {
4
    log.info("before ...");
5
}
6
//匹配多个方法

annotation

@annotation 用来匹配加了指定注解的方法。

哪个方法需要增强，就在哪个方法上加 @LogOperation

连接点

JoinPoint 可以获取目标方法运行时的信息。

1
@Before("execution(* com.itheima.service.*.*(..))")
2
public void before(JoinPoint joinPoint) {
3
    Object target = joinPoint.getTarget();
4
    log.info("目标对象: {}", target);
5

6
    String className = joinPoint.getTarget().getClass().getName();
7
    log.info("目标类名: {}", className);
8

9
    String methodName = joinPoint.getSignature().getName();
10
    log.info("目标方法名: {}", methodName);
11

12
    Object[] args = joinPoint.getArgs();
13
    log.info("目标方法参数: {}", Arrays.toString(args));
14
}

@Around 通知使用 ProceedingJoinPoint
其他通知一般使用 JoinPoint
ProceedingJoinPoint 是 JoinPoint 的子接口
只有 ProceedingJoinPoint 才能调用 proceed() 执行原始方法

执行顺序

1
@Slf4j
2
@Order(2)
3
@Aspect
4
@Component
5
public class SecondAspect {
6
}

目标方法执行前：@Order 数字小的先执行
目标方法执行后：@Order 数字小的后执行

1
Order(1) 前置
2
    Order(2) 前置
3
        目标方法
4
    Order(2) 后置
5
Order(1) 后置

1
@Around("execution(* com.itheima.service.impl.*.*(..))")
2
public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
3
    long begin = System.currentTimeMillis();
4
    Object result = joinPoint.proceed();
5
    long end = System.currentTimeMillis();
6
    log.info("方法 {} 执行耗时: {}ms", joinPoint.getSignature(), end - begin);
7
    return result;
8
}

execution 适合批量匹配一批方法，@annotation 适合精确控制哪些方法需要增强。

音乐

音乐

Tlias管理系统

项目需求

工程搭建

部门管理

统一响应结果

部门表查询

前置数据

部门实体类

mybatis属性封装

手动映射

起别名

驼峰命名（推荐）

Controller

Service

Mapper

前后端联调

部门删除

@RequestParam

Controller

Service

Mapper

新增部门

@RequestBody

Controller

Service

Mapper

修改部门

根据id查询部门

@PathVariable

Controller

Service

Mapper

修改部门

@RequestBody

Controller

Service

Mapper

@RequstMapping

日志技术

定义

日志框架

对比

Logback 依赖引入

配置文件 logback.xml

日志级别

常见场景

注意事项

员工管理

前置数据

实体类

分页查询

引入依赖

Mapper

Controller

Service

条件查询

需求

初始

优化

实体类

Controller

Service

动态sql

新增员工

新增字段

Controller

Service

Mapper

Spring事务

初识

进阶

事务传播

文件上传

Controller

yml文件

工具类

删除员工

Controller

`@RequestParam`