Skip to content

接口开发 ​

Restful ​

是后端开发中最主流的 API 设计风格,它不是一种技术或框架,而是一套约定和规范

核心:用 URL 定位资源,用 HTTP 方法表达操作

由于每个人的命名习惯不一致,如在新增用户时,接口地址可能会出现不一致的情况(saveUser 或 add),项目越大越不易维护

传统风格url请求方式含义
http://localhost:8080/user/getById?id=1GET查询id为1的用户
http://localhost:8080/user/saveUserPOST新增用户
http://localhost:8080/user/updateUserPOST修改用户
http://localhost:8080/user/deleteUser?id=1GET删除id为1的用户

REST 风格以请求方式表达其功能(增删改查)更加简洁

REST风格url请求方式含义
http://localhost:8080/users/1GET查询id为1的用户
http://localhost:8080/users/1DELETE删除id为1的用户
http://localhost:8080/usersPOST新增用户
http://localhost:8080/usersPUT修改用户

Apifox ​

Apifox 是一款集成了 Api 文档、Api 调试、ApiMock、Api 测试的一体化协作平台

作用:接口文档管理、接口请求测试、Mock 服务

官网:https://apifox.com/

目录结构 ​

准备工作 ​

这里以 MyBatis 使用作为说明

在src\main\java\com\example\demo 下创建 pojo(实体类,定义接口数据接口)、 controller(控制层,接受请求、调用 service 层、响应结果)、 service(业务层,调用 mapper 层的方法)、 mapper(持久层,编写 sql 查询数据)等目录

在 src\main\java\com\example\demo\pojo\Dept.java 中写入业务实体类,用于定义 Dept 的表结构字段

java
// Lombok 注解,加上后编译时会自动为所有字段生成 getter,所有非 final 字段生成 setter
@Data
// Lombok 注解,生成无参构造器:public Dept() {},MyBatis 查询结果映射时,通常先通过无参构造器 new 出对象,再调 setter 赋值。没有无参构造器会报错
@NoArgsConstructor
/*
Lombok 注解,生成全参构造器:
public Dept(Integer id, String name, LocalDateTime createTime, LocalDateTime updateTime) {
    this.id = id;
    this.name = name;
    this.createTime = createTime;
    this.updateTime = updateTime;
}
方便一次性构造完整对象,比如测试、手动组装数据、Service 层返回 DTO 时
*/
@AllArgsConstructor
public class Dept {
    // 注意实体类属性名和数据库表查询返回的字段名一致,mybatis 会自动封装,否则则不会,最终导致接口查询回来的会缺少不一致的字段。
    // 如果不一致可以使用 @Results 注解解决这一问题,下方会讲解
    private Integer id;
    private String name;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

在 src\main\java\com\example\demo\pojo\Result.java 中写入统一响应结果的实体类,用于定义接口固定响应结果结构以及接口响应成功与失败的工具函数

java
@Data
public class Result {
    private Integer code; // 编码: 1成功,0为失败
    private String msg; // 错误信息
    private Object data; // 数据

    public static Result success() {
        Result result = new Result();
        result.code = 1;
        result.msg = "success";
        return result;
    }

    public static Result success(Object object) {
        Result result = new Result();
        result.data = object;
        result.code = 1;
        result.msg = "success";
        return result;
    }

    public static Result error(String msg) {
        Result result = new Result();
        result.msg = msg;
        result.code = 0;
        return result;
    }
}

在 src\main\java\com\example\demo\mapper\DeptMapper.java 中写入,方便后续借助 MyBatis 查询数据库

java
// MyBatis 注解,告诉 Spring "这个接口是 MyBatis 的 Mapper,请为它生成代理实现并注册成 "Bean"
@Mapper
public interface DeptMapper {}

在 src\main\java\com\example\demo\service\DeptService.java 中写入

java
public interface DeptService {}

在 src\main\java\com\example\demo\service\impl\DeptServiceImpl.java 中写入

java
// Spring 的组件注解,它告诉 Spring 启动时把这个类扫描并实例化,注册成一个 Bean,交给 IoC 容器管理,这样其他地方就能通过 @Autowired 或构造器注入 DeptService,实际拿到的就是这个 DeptServiceImpl 实例
@Service
// 这里的 DeptService 类是上方刚写好的 DeptService 类
public class DeptServiceImpl implements DeptService {}

在 src\main\java\com\example\demo\controller\DeptController.java 中写入,负责接收 HTTP 请求并返回响应

java
// Spring 4 引入的组合注解,等价于@Controller 和 @ResponseBody
// @Controller:把这个类标记为控制器,并注册为 Spring Bean(本质是 @Component 的语义化子注解),启动时被组件扫描注册到 IoC 容器
// @ResponseBody:类中所有处理方法的返回值不再被解析为视图名(如 JSP、Thymeleaf 模板),而是直接写入 HTTP 响应体。如果返回的是 Java 对象,会由 Jackson 自动序列化为 JSON
// 所以用 @RestController 时,方法返回 List<Dept>、Dept、Map 等对象,客户端收到的就是 JSON
@RestController 
public class DeptController {}

编写逻辑 ​

在 src\main\java\com\example\demo\controller\DeptController.java 补充接口逻辑

java
// 这是一个组合注解,等于 @Controller + @ResponseBody,表示这个类是一个控制器,用来接收 HTTP 请求,类中所有方法的返回值都会直接作为 HTTP 响应体返回,而不是跳转到某个页面
@RestController
public class DeptController {
    // Java 平台通用注解,Spring 从 2.5 开始支持
    // 容器启动时,Spring 扫描到 @Resource,就会从 IoC 容器里找到匹配的 DeptService Bean 并赋值给这个字段。开发者不用 new、不用手动查找
    @Resource
    private DeptService deptService;

    // 可以使用 @RequestMapping("/api") 注解为此类下所有接口定义路径前缀
    @GetMapping("/depts")
    public Result list() {
        try {
             // 这里的 Dept 是上方写好的 src\main\java\com\example\demo\pojo\Dept.java 中的实体类,用来描述接口返回的 data 的数据结构
            List<Dept> depList = deptService.findAll();
            // 这里的 Result 是上方写好的 src\main\java\com\example\demo\pojo\Result.java 中的类,用于定义接口返参的固定数据结构
            return Result.success(depList);
        } catch (Excepion e) {
            // 捕获异常调用上方封装好的失败函数
            return Result.error("查询失败!");
        }
    }
}

在 src\main\java\com\example\demo\service\DeptService.java 补充代码

java
public interface DeptService {
    // 这里的 Dept 是上方写好的 src\main\java\com\example\demo\pojo\Dept.java 中的实体类,用来描述接口返回的 data 的数据结构
    List<Dept> findAll();
}

在 src\main\java\com\example\demo\service\impl\DeptServiceImpl.java 补充代码

java
@Service
public class DeptServiceImpl implements DeptService {
    @Resource
    private DeptMapper deptMapper;

    public List<Dept> findAll() {
        return deptMapper.findAll();
    }
}

在 src\main\java\com\example\demo\mapper\DeptMapper.java 补充具体 sql 查询数据代码

java
@Mapper
public interface DeptMapper {
    // 用于解决数据库某些字段与 src\main\java\com\example\demo\pojo\Dept.java 定义的实体类(接口返参 data 中的数据类型)不一致导致的接口字段缺少问题,即接口对应字段为 null
    @Results({
        	// column 是数据库字段名,property 是实体类的字段名
            @Result(column = "create_time", property = "createTime"),
            @Result(column = "update_time", property = "updateTime")
    })
    /*
    针对这一问题还可以通过起别名的方式解决:
    只需要在 sql 中 create_time 和 update_time 后填写和实体类中一致的别名即可
    @Select("create_time createTime, update_time updateTime from dept order by update_time desc")
    */
    @Select("select id, name, create_time, update_time from dept order by update_time desc")
    List<Dept> findAll();
}

针对上述问题(数据库字段与实体类字段不一致导致接口参数缺失问题),推荐开启驼峰命名的解决方式

yml
# src\main\resources\application.yml
# 如果字段名与属性名符合驼峰命名规则,mybatis 会自动通过驼峰命名规则映射
# 如 create_time 和 createTime
mybatis: 
  configuration: 
    map-underscore-to-camel-case: true

接下来请求 http://localhost:8080/depts 就可以调用接口了

接收参数 ​

接收查询参数 ​

打开 src\main\java\com\example\demo\controller\DeptController.java 写入

java
public class DeptController {
    @Resource
    private DeptService deptService;

    // 声明 DELETE 请求
    @DeleteMapping("/depts")
    // @RequestParam spring 注解,从请求中取名为 id 的参数,绑定到方法的 id 参数上,即前端请求地址:/depts?id=1 读取 id 的值
    // 一旦声明了 @RequestParam,该参数在请求时必须传递,如果不传递将会报错
    // 如果需要非必填可改写:@RequestParam(value = "id", required = false) Integer deptId
    // 可以通过 @RequestParam(defaultValue = “2”) Integer deptId 来指定默认值
    /*
    当需要接收日期格式的参数时需要使用 @DateTimeFormat 注解(springBoot 提供)指定日期格式
    @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin
    */
    public Result delete(@RequestParam("id") Integer id) {
        System.out.println("接收到的参数" + id);
    }
    
    // 当请求参数名与形参变量名相同时可以省略 @RequestParam,下方代码等同于上方代码
    public Result delete(Integer id) {
        System.out.println("接收到的参数" + id);
    }
}

接收请求体参数 ​

打开 src\main\java\com\example\demo\controller\DeptController.java 写入

java
public class DeptController {
    @Resource
    private DeptService deptService;

    // 声明 Post 请求
    @PostMapping("/depts")
    // @RequestBody spring 注解,从请求体中读取数据,把 HTTP 请求体(body)的内容,按 Content-Type 指定的格式(通常是 application/json)反序列化成 Dept 对象
    // 规则:JSON 数据的键名与方法形参对象的属性名相同,并需要使用 @RequestBody 注解标识
    // Dept 是上方 src\main\java\com\example\demo\pojo\Dept.java 写好的实体类,用于定义数据库字段类型
    public Result add(@RequestBody Dept dept) {
        System.out.println(dept);
    }
}

接收路径参数 ​

打开 src\main\java\com\example\demo\controller\DeptController.java 写入

java
public class DeptController {
    @Resource
    private DeptService deptService;

    // 声明 Get 请求和路径参数占位符,表示这一段路径是可变参数
    @GetMapping("/depts/{id}")
    // @PathVariable spring 注解,从路径参数中读取数据,并赋值给 getInfo 函数的形参 id
    // @PathVariable("id") 里的 "id" 对应路径占位符 {id} 的名字,两者必须一致
    // 当前端请求为 /depts/2 时需要使用 @PathVariable 来读取
    public Result getInfo(@PathVariable("id") Integer id) {
        System.out.println("参数是:" + id);
    }
    
    // 当路径名与方法形参名一致时,可简写为如下写法
    public Result getInfo(@PathVariable Integer id) {
        System.out.println("参数是:" + id);
    }
}

分页查询 ​

原始方式 ​

java
// 定义分页查询固定返参数据类型
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageResult<T> {
    private Long total;
    private List<T> rows;
}
java
// 原始方式需要在 Mapper 层通过两条 sql 分别查询数据以及数据总数
@Mapper
public interface EmpMapper {
    // 查询符合条件的数据总数 sql
    @Select("select count(*) from emp e left join dept d on e.dept_id = d.id")
    public Long count();
	
    // 查询符合条件的数据 sql
    @Select("select e.*, d.name deptName from emp e left join dept d on e.dept_id = d.id order by e.update_time desc limit #{start},#{pageSize}")
    // 这里的 Emp 类定义了查询结果的数据类型
    public List<Emp> list(Integer start, Integer pageSize);
}

// 然后在 Service 层分别调用 Mapper 层的方法最后将结果组装到一起
@Service
public class EmpServiceImpl implements EmpService {
    @Resource
    private EmpMapper empMapper;
    
    @Override
    public PageResult<Emp> page(Integer page, Integer pageSize) {
        // 调用 Mapper 层 count 方法
        Long total = empMapper.count();
        // 调用 Mapper 层 list 方法
        List<Emp> rows = empMapper.list((page - 1) * pageSize, pageSize);
        // 组装结果
        // 使用上方定义 PageResult 实体类来组装结果
        return new PageResult<Emp>(total, rows);
    }
}

PageHelper 方式 ​

PageHelper 是第三方提供的在 Mybatis 框架中用来实现分页的插件,用来简化分页操作,提高开发效率

引入 PageHelper 依赖

xml
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>4.1.1</version>
</dependency>

改造 Mapper 层代码

java
@Mapper
public interface EmpMapper {
    // 删除查询数据总数的 count 方法
    // 删除关于分页相关的 sql 语句(即 limit #{start},#{pageSize} 这段代码)
    // 使用 PageHelper 后分页相关的 sql 结尾不能加分号(即 ;)
    @Select("select e.*, d.name deptName from emp e left join dept d on e.dept_id = d.id order by e.update_time desc")
    // 分页参数(即 start、 pageSize)也无需保留
    public List<Emp> list();
}

改造 Service 层代码

java
@Service
public class EmpServiceImpl implements EmpService {
    @Resource
    private EmpMapper empMapper;

    @Override
    public PageResult<Emp> page(Integer page, Integer pageSize) {
        // 1.设置分页参数(PageHelper)
        // 注意 PageHelper 仅仅能对紧跟在其后的第一个查询语句进行分页处理
        PageHelper.startPage(page,pageSize);
        // 2.调用修改后 Mapper 层方法执行查询
        List<Emp> empList = empMapper.list();
   // 3.解析查询结果,并封装(Page 是 PageHelper 提供的类,通过它可以获取查询回来的数据总数、数据等)
        Page<Emp> p = (Page<Emp>) empList;
        return new PageResult<Emp>(p.getTotal(),p.getResult());
    }
}

异常捕获 ​

可以在每个 Controller 方法捕获异常来解决,但项目一大每个方法都这么写就显得繁琐臃肿

java
// Controller 层代码
@RestController
public class DeptController {
    // 其他逻辑代码...
    @GetMapping("/depts")
    public Result list() {
        try {
            // 成功的逻辑代码...
            return Result.success();
        } catch (Excepion e) {
            // 出现异常的逻辑代码...
            return Result.error("查询失败!");
        }
    }
}

全局捕获 ​

可使用 SpringBoot 提供的全局异常处理器来解决

在 src\main\java\com\example\demo\exception\GlobalExceptionHandler.java 中写入

作用:当 Controller(及后续调用链)抛出异常时,统一拦截,返回一个格式化的错误响应,而不是把 500 堆栈直接丢给前端

java
@Slf4j
// Spring 注解,等价于 @ControllerAdvice 和 @ResponseBody
// @ControllerAdvice:AOP 风格的全局增强器,作用范围默认是所有 @Controller / @RestController。它本身也是 @Component 的派生,会被注册为 Bean
// @ResponseBody:方法返回值直接写入 HTTP 响应体(序列化为 JSON),而不是解析为视图名
// 组合起来:对所有 Controller 抛出的异常做统一处理,并以 JSON 返回结果
@RestControllerAdvice
public class GlobalExceptionHandler {
    // Spring 注解,标记这个方法是一个异常处理方法
    // 不写参数时,默认处理参数类型所表示的异常,这里参数是 Exception,所以它拦截所有 Exception 及其子类
    @ExceptionHandler
    // 全局兜底捕获
    public Result handleException(Exception e){
        // 这里的 Result 是上方写好的 src\main\java\com\example\demo\pojo\Result.java 中的类,用于定义接口返参的固定数据结构
        return Result.error("出错啦,请联系管理员~");
    }
}

添加更加精细的全局捕获(示例)

java
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler
    // 捕获数据库唯一键重复的异常(如用户身份证号)
    public Result handleDuplicateKeyException(DuplicateKeyException e) {
        String message = e.getMessage();
        int i = message.indexOf("Duplicate entry");
        String errMsg = message.substring(i);
        String[] arr = errMsg.split(" ");
        return Result.error(arr[2] + " 已存在");
    }
}

文件上传 ​

是指将本地图片、视频、音频等文件上传到服务器,供其他用户浏览或下载的过程

1.在 controller 层中接收前端上传的二进制文件

java
@RestController
public class UploadController {
    // 定义上传接口
    @PostMapping("/upload")
    public Result upload(MultipartFile file){
        // 接收
    }
}

存储到本地 ​

java
@RestController
public class UploadController throws IOException {
    // 定义上传接口
    @PostMapping("/upload")
    public Result upload(MultipartFile file){
        // 获取原始文件名
		String originalFilename = file.getOriginalFilename();
        // 截取文件后缀(.jpg 或 .txt 等)
        String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
        // 借助 UUID 创建一个不会重复的文件名
        String newFileName UUID.randomUUID().toString() + extension;
        // 保存到本地指定目录下(springBoot 默认单个文件最大大小为 1M ,超过后会保存失败)
        file.transferTo(new File("D:/images/" + newFileName));
    }
}

可在 src\main\resources\application.yml 中修改

yml
spring:
	servlet:
		multipart:
			# 最大单个文件大小
            max-file-size: 10MB
            # 最大请求大小(包括所有文件和表单数据)
            max-request-size: 100MB

阿里云OSS ​

在开发中一般不会将文件直接保存到服务器上,一般借助市面上提供的服务

阿里云是阿里巴巴集团旗下全球领先的云计算公司,也是国内最大的云服务提供商,提供多种云服务,如短信服务、对象存储、视频直播等

阿里云对象存储 OSS(Object Storage Service),是一款海量、安全、低成本、高可靠的云存储服务。使用 OSS 可以通过网络随时存储和调用包括文本、图片、音频和视频等在内的各种文件。官网:https://account.aliyun.com

基本流程:注册 => 充值 => 开通OSS服务 => 创建bucket(存储空间,存放文件的容器) => 获取并配置密钥 => 参照官方SDK编写入门程序 => 在项目中集成

1.将在阿里云后台创建的密钥复制下来(一定要保存好)打开 cmd 执行如下命令

shell
# 分别填写在阿里云后台创建的密钥信息
set OSS_ACCESS_KEY_ID=xxxxxxxxxxx
set OSS_ACCESS_KEY_SECRET=xxxxxxxxxxxxx

2.打开 cmd 执行如下命令,让更改生效

shell
setx OSS_ACCESS_KEY_ID "%OSS_ACCESS_KEY_ID%"
setx OSS_ACCESS_KEY_SECRET "%OSS_ACCESS_KEY_SECRET%"

打开 cmd 执行如下命令,验证环境变量是否生效

shell
echo %OSS_ACCESS_KEY_ID%
echo %OSS_ACCESS_KEY_SECRET%

3.参照官方文档编写入门程序

参考文档:https://help.aliyun.com/zh/oss/developer-reference/oss-sdk-for-java-2-0/?spm=a2c4g.11186623.0.i2

4.项目中集成(示例)

java
@RestController
public class UploadController throws IOException {
    // 定义上传接口
    @PostMapping("/upload")
    public Result upload(MultipartFile file){
// 调用上一步参照官方文档编写文件上传工具类程序 aliyunOSSOperator 上传文件并获取阿里云给的文件公网访问地址
        String url = aliyunOSSOperator.upload(file.getBytes(),file.getOriginalFilename())
    }
}

登录 ​

准备工作 ​

在 src\main\java\com\example\demo\controller\LoginController.java 写入登录接口

java
public class LoginController {
    @Resource
    private EmpService empService;

    @PostMapping("/login")
    public Result login(@RequestBody Emp emp) {
        // 调用 Service 层 login 方法获取查询到的
        Loginlnfo info = empService.login(emp);
        if (info != null) {
            return Result.success(info);
        }
        return Result.error("用户名密码错误!");
    }
}

在 src\main\java\com\example\demo\pojo\Loginlnfo.java 写入登录接口实体类

java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Loginlnfo {
    private Integer id;
    private String username;
    private String name;
    private String token;
}

在 src\main\java\com\example\demo\service\impl\EmpServiceImpl.java 写入 Service 层代码

java
@Service
public class EmpServiceImpl implements EmpService {
    @Resource
    private EmpMapper empMapper;

    @Override
    public Loginlnfo login(Emp emp) {
        // 1.调用 mapper 接口,根据用户名和密码查询员工信息
        Emp e = empMapper.selectByUsernameAndPassword(emp);
        // 2.判断:判断是否存在这个员工,如果存在,组装登录成功信息
        if (e != null) {
            return new Loginlnfo(e.getId(), e.getUsername(), e.getName(), "");
        }
        // 3.不存在,返回null
        return null;
    }
}

在 src\main\java\com\example\demo\mapper\EmpMapper.java 写入 mapper 层代码

java
@Mapper
public interface EmpMapper {
    @Select("select id, username, name from emp where username = #{username} and password = #{password}")
    public Emp selectByUsernameAndPassword(Emp emp);
}

登录校验 ​

优点:HTTP协议中支持的技术

缺点:

移动端APP无滤使用Cookie

不安全,用户可以自己禁用Cookie

Cookie不能跨域

java
// Controller 层代码示例
public class LoginController {
    @GetMapping("/c1")
    // 当浏览器调用此接口时会在接口响应头(Set-Cookie)中设置 Cookie 信息
    public Result cookie1(HttpServletResponse response) {
        // 设置 Cookie / 响应 Cookie
        // 接口响应头示例:Set-Cookie:login_username=zhangsan
        // 浏览器会自动将此信息保存,下次请求时会自动携带本地保存的所有(当前域名下) Cookie 发送给服务器
        response.addCookie(new Cookie("login_username", "zhangsan")); 
        return Result.success();
    }

    @GetMapping("/c2")
    // 当浏览器调用此接口时可以获取之前保存在浏览器的 Cookie
    public Result cookie2(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            if (cookie.getName().equals("login_username")) {
                System.out.println("login_username:" + cookie.getValue());
            }
        }
        return Result.success();
    }
}

JWT ​

定义了一种简洁的、自包含的格式,用于在通信双方以json数据格式安全的传输信息

java
// JWT 令牌示例
eyJhbGci0iJIUzI1NiIsInR5cCI6IkpXVCJ9.JTdCJTIybmFtZSUyMiUzQSUyM1RvbSUyMiUyQyUyMm1hdCUyMiUzQTE1MTYyMzkwMjI1N0Q=.Sf1KxwRJSMeKKF2QT4fwpMeJf...

// 第一部分(eyJhbGci0iJIUzI1NiIsInR5cCI6IkpXVCJ9)
// Header(头),记录令牌类型、签名算法等。 例如:{"alg":"HS256","type":"JWT"}
    
// 第二部分(JTdCJTIybmFtZSUyMiUzQSUyM1RvbSUyMiUyQyUyMm1hdCUyMiUzQTE1MTYyMzkwMjI1N0Q)
// Payload(有效载荷),携带一些自定义信息、默认信息等。例如:{"id":"1","username":"Tom"}
    
// 第三部分(.Sf1KxwRJSMeKKF2QT4fwpMeJf...)
// Signature(签名),防止Token被篡改、确保安全性。将header、payload融入,并加入指定秘钥,通过指定签名算法计算而来

引入jjwt的依赖

xml
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.13.0</version>
</dependency>

基本使用

java
// src\main\java\com\example\demo\utils\JwtUtils.java
public class JwtUtils {
    private static final String SECRET_KEY = "shaoyedog-shaoyedog-shaoyedog-shaoyedog-2024";
    private static final SecretKey KEY = Keys.hmacShaKeyFor(SECRET_KEY.getBytes(StandardCharsets.UTF_8));
    private static final long EXPIRATION_TIME = 12 * 60 * 60 * 1000L; // 12 小时

    // 生成令牌
    public static String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .signWith(KEY, Jwts.SIG.HS256)
                .claims(claims)
                .expiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .compact();
    }

    // 解析令牌
    public static Claims parseToken(String token) throws Exception {
        return Jwts.parser()
                .verifyWith(KEY)
                .build()
                .parseSignedClaims(token)
                .getPayload();
    }
}

修改上方 Service 层代码

java
@Override
public Loginlnfo login(Emp emp) {
    // 其他代码...
    if (e != null) {
        // 调用上方工具方法生成JWT令牌
        Map<String, Object> claims = new HashMap<>();
        claims.put("id", e.getId());
        claims.put("username", e.getUsername());
        String jwt = JwtUtils.generateToken(claims);
        // 将生成的 token 返回给前端
        return new Loginlnfo(e.getId(), e.getUsername(), e.getName(), jwt);
    }
    // 其他代码...
}
令牌校验 ​
过滤器方式 ​

过滤器可以把对资源的请求拦截下来,从而实现一些特殊的功能

过滤器一般完成一些通用的操作,比如:登录校验、统一编码处理、敏感字符处理等

基本使用

java
// 在启动类(src\main\java\com\example\demo\DemoApplication.java)中添加 @ServletComponentScan 注解
// 开启 SpringBoot 对 Servlet 组件的支持
@ServletComponentScan
@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}
java
// 在 src\main\java\com\example\demo\filter\DemoFilter.java 中写入
// urlPatterns 表示需要拦截的接口路径,/* 表示拦截所有请求,/login 表示只有访问 /login 路径时,才会被拦截,/emps/* 表示访问 /emps 下的所有资源,都会被拦截
@WebFilter(urlPatterns = "/*")
// Filter 是 jakarta.servlet.Filter 提供的接口
public class DemoFilter implements Filter {
    
    @Override
    // 拦截到请求时,调用该方法,调用多次
    public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
            throws IOException, ServletException {
        // 强制转换类型
        HttpServletRequest request = (HttpServletRequest) arg0;
        HttpServletResponse repponse = (HttpServletResponse) arg1;
        // 获取到请求路径(不包含协议和域名部分),如:/employee/login
        String requestURI = request.getRequestURI();
        // 判断是否是登录请求,如果是就放行
        if (requestURI.contains("/login")) {
            arg2.doFilter(arg0, arg1);
            return;
        }
        // 获取请求头中的 token 信息
        String token = request.getHeader("token");
        // 判断 token 是否存在
        if (token == null || token.isEmpty()) {
            // 如果不存在,说明用户没有登录,返回错误信息(响应401状态码)
            repponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }

        // 校验令牌合法性,如果校验失败 ->返回错误信息(响应401状态码)
        try {
            // 调用上面封装好的 token 校验工具类方法
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            repponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }
        // 当不执行如下代码时,接口将不会有任何返参(代码会卡在这里不会执行 controller 层的接口方法)
        // 校验通过,放行
        arg2.doFilter(arg0, arg1);
        // 这里的代码会在 controller 层执行完之后执行
        // 放行后的逻辑代码...
    }
    @Override
    // 初始化方法(非必须),web 服务器启动,创建 Filter 实例时调用,只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init ...");
    }
    @Override
    // 销毁方法(非必须),web服务器关闭时调用,只调用一次
    public void destroy() {
        System.out.println("destroy ... ");
    }
}

过滤器链:表示项目中配置了多个过滤器,接收到请求后会挨个执行过滤器

顺序:注解配置的 Filter,优先级是按照过滤器类名(字符串)的自然排序

java
// 过滤器代码参见上方
// 在 src\main\java\com\example\demo\filter\AFilter.java 中定义了过滤器1
// 在 src\main\java\com\example\demo\filter\BFilter.java 中定义了过滤器2

// 最终执行顺序是:浏览器 => AFilter 放行前 => AFilter 放行 => BFilter 放行前 => BFilter 放行 => 相应资源(如 controller 层的接口方法)=> BFilter 放行后 => AFilter 放行后 => 浏览器

// 之所以 AFilter 先执行是因为它的自然排序高(A => B)
拦截器方式 ​

是一种动态拦截方法调用的机制,类似于过滤器。Spring框架中提供的,主要用来动态拦截控制器方法的执行。

作用:拦截请求,在指定的方法调用前后,根据业务需要执行预先设定的代码

java
// 在 src\main\java\com\example\demo\interceptor\DemoInterceptor.java 中定义拦截器
@Component
public class DemoInterceptor implements HandlerInterceptor {
    @Override
    // 目标资源方法(controller 层的接口方法)执行前执行,放回 true 放行,返回 false 不放行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 由于下方加上了排除路径,这段校验是否是登录接口的逻辑就不需要了
        // String requestURI = request.getRequestURI();
        // if (requestURI.contains("/login")) {
        //    return true;
        //}
        // 校验逻辑和上方过滤器方式一致,这里不再过多解释
        String token = request.getHeader("token");
        if (token == null || token.isEmpty()) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            // 不放行
            return false;
        }
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
        // 放行
        return true;
    }

    @Override
    // 目标资源方法执行后执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
    }

    @Override
    // 视图渲染完毕后执行,最后执行(早期前后端不分离时,后端还需要书写前端页面),仅做了解
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
            Exception ex) throws Exception {
    }
}
java
// 在 src\main\java\com\example\demo\config\WebConfig.java 中注册拦截器
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Resource
    private DemoInterceptor demoInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
	// 注册上一步创建好的拦截器,addPathPatterns 中配置拦截路径,这里表示拦截所有请求,excludePathPatterns 表示不拦截哪些路径,可以传递一个 List 也可以是单个路径
 registry.addInterceptor(demoInterceptor).addPathPatterns("/**")
     .excludePathPatterns("/login");
    }
}
拦截路径含义举例
/*一级路径能匹配/depts, /emps, /login, 不能匹配 /depts/1
/**任意级路径能匹配/depts, /depts/1, /depts/1/2
/depts/*/depts下的一级路径能匹配/depts/1,不能匹配/depts/1/2, /depts
/depts/**/depts下的任意级路径能匹配/depts, /depts/1, /depts/1/2,不能匹配/emps/1

如果拦截器和过滤器同时存在,执行顺序是:浏览器 => 过滤器放行前 => 拦截器 preHandle 方法 => 相应资源(如 controller 层的接口方法)=> 拦截器 afterCompletion 方法 => 过滤器放行后 => 浏览器

区别 ​

过滤器可以拦截所有资源(包括图片、文件等静态资源),而拦截器默认只能拦截 Controller 层的动态接口请求

加密 ​

在开发中用户密码并不是明文传输和保存的,需要进行加密,以下以 MD5 方式加密为例

java
// 打开上方写好的 Controller 层登录接口
@RestController
public class LoginController {
    @Resource
    private EmpService empService;

    @PostMapping("/login")
    public Result login(@RequestBody Emp emp) {
        // 使用 spring 提供的工具类 DigestUtils.md5DigestAsHex 即可对数据加密
        String passWord = DigestUtils.md5DigestAsHex(emp.getPassword().getBytes());
        System.out.println(passWord);
        // 其他代码...
    }
}

Swagger ​

使用Swagger你只需要按照它的规范去定义接口及接口相关的信息,就可以做到生成接口文档,以及在线接口调试页面。官网:https://swagger.io/

springdoc-openapi ​

专门为 Spring Boot 应用自动生成 OpenAPI 3 文档

针对 Spring Boot 4,需要使用其 3.x 版本(如 3.2.0),而 2.x 版本是为 Spring Boot 3 准备的

安装

xml
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>3.2.0</version>
</dependency>

注意如果项目中使用了全局拦截器,需要排除 Swagger 路径

java
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Resource
    private DemoInterceptor demoInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(demoInterceptor).addPathPatterns("/**")
                .excludePathPatterns(
                        "/login", // 登录接口本身不拦
            
            			// 添加排除 Swagger 路径
                        "/swagger-ui.html",
                        "/swagger-ui/**", // UI 静态资源
                        "/v3/api-docs/**", // OpenAPI JSON
                        "/v3/api-docs/swagger-config");
    }
}

启动项目访问http://localhost:8080/swagger-ui/index.html#/ 即可查看自动生成的接口文档

如果直接部署到生产环境,任何人都能访问此接口文档,所以上线时记得关闭

yaml
# application-dev.yml
springdoc:
  api-docs:
    enabled: true
  swagger-ui:
    enabled: true
yml
# application-prod.yml
springdoc:
  api-docs:
    enabled: false
  swagger-ui:
    enabled: false

AOP ​

面向切面编程、面向方面编程,是一种编程思想,可简单理解为就是面向特定方法编程

场景:案例中部分业务方法运行较慢,定位执行耗时较长的方法,此时需要统计每一个业务方法的执行耗时

可以给每个接口方法写入记录执行时间的逻辑即可解决,但如果接口一多就不太适用了,这时可以使用 AOP 来解决

基本使用 ​

1.安装

xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>4.0.0-M2</version>
</dependency>

2.编写 AOP 程序:针对于特定的方法根据业务需要进行编程

java
// 在 src\main\java\com\example\demo\aop\RecordTimeAspect.java 中写入
// 标识当前是一个 AOP 类
@Aspect
@Component
public class RecordTimeAspect {
    // 表示 src\main\java\com\example\demo\service\impl 下的所有类中的方法都需要执行如下操作
    @Around("execution(* com.example.demo.service.impl.*.*(..))")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        // 1.记录方法运行的开始时间
        long begin = System.currentTimeMillis();
        // 2. 执行原始的方法
        Object result = pjp.proceed();
        // 3.记录方法运行的结束时间,记录耗时
        long end = System.currentTimeMillis();
        // pjp.getSignature() 可以获取原始方法名
        System.out.println("方法" + pjp.getSignature() + "执行耗时" + (end - begin) + "ms");
        // 将原始方法执行结果返回
        return result;
    }
}
// 输出示例:
// 方法List com.example.demo.service.impl.DeptServiceImpl.findAll()执行耗时308ms

核心概念 ​

连接点:JoinPoint,可以被 AOP 控制的方法(暗含方法执行时的相关信息),相当于上方 service\impl 下的所有类中的方法

通知:Advice,指那些重复的逻辑,也就是共性功能(最终体现为一个方法),相当于上方 RecordTimeAspect 中定义的计算执行耗时的逻辑

切入点:PointCut,匹配连接点的条件,通知仅会在切入点方法执行时被应用,相当于上方 @Around 中定义的实际控制的所有方法

切面:Aspect,描述通知与切入点的对应关系(通知+切入点)

目标对象:Target,通知所应用的对象相当于上方service\impl下的所有类

执行流程(原理)

通知类型 ​

@Around:环绕通知(常用),此注解标注的通知方法在目标方法前、后都被执行

@Before:前置通知,此注解标注的通知方法在目标方法前被执行

@After:后置通知,此注解标注的通知方法在目标方法后被执行,无论是否有异常都会执行

@AfterReturning: 返回后通知,此注解标注的通知方法在目标方法后被执行,有异常不会执行

@AfterThrowing:异常后通知,此注解标注的通知方法发生异常后执行

java
@Aspect
@Component
public class RecordTimeAspect {
    // 可通过 @Pointcut 注解抽离切入点表达式
    @Pointcut("execution(* com.example.demo.service.impl.*.*(..))")
    // 当然这里也可以使用 public 表示其他切面类也可以使用它
    // 使用 private 后只能在当前切面类中使用
    private void pt() {}
    
    // 环绕通知
    // 使用上方定义好的 pt 方法
    @Around("pt()")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before")
            
        Object result = pjp.proceed();
        
        System.out.println("after")
        return result;
    }
    
    @Before("pt()")
    public void before() {
        System.out.println("执行")
    }
    
    @After("pt()")
    public void after() {
        System.out.println("执行")
    }
    
    @AfterReturning("pt()")
    public void afterReturning() {
        System.out.println("执行")
    }
    
    @AfterThrowing("pt()")
    public void afterThrowing() {
        System.out.println("执行")
    }
}

通知顺序 ​

当有多个切面的切入点都匹配到了目标方法,目标方法运行时,多个通知方法都会被执行

不同切面类中,默认按照切面类的类名字母排序:

1.目标方法前的通知方法:字母排名靠前的先执行

2.目标方法后的通知方法:字母排名靠前的后执行

java
// 切面类 A
@Aspect
@Component
public class A {
    // 切面类 A、B 的切入点表达式都一样
    @Before("execution(* com.example.demo.service.impl.*.*(..))")
    public void before() {
        System.out.println("执行")
    }
}

// 切面类 B
@Aspect
@Component
public class B {
    @Before("execution(* com.example.demo.service.impl.*.*(..))")
    public void before() {
        System.out.println("执行")
    }
}

如果不想使用默认排序,可使用 @0rder(数字) 指定顺序

目标方法前的通知方法:数字小的先执行

目标方法后的通知方法:数字小的后执行

java
@Aspect
// 如果不想使用默认排序,可使用 @0rder 注解指定顺序
@0rder(5)
@Component
public class B {
    @Before("execution(* com.example.demo.service.impl.*.*(..))")
    public void before() {
        System.out.println("执行")
    }
}

切入点表达式 ​

描述切入点方法的一种表达式,用来决定项目中的哪些方法需要加入通知

常见形式

java
// 形式一
@Before("execution(* com.example.demo.service.impl.*.*(..))")
public void before(JoinPoint joinPoint){}

// 形式二
@Before("@annotatiom(com.example.demo.anno.Log)")
public void before() {}

形式一 ​

java
// execution 主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配,语法为:
execution(访问修饰符? 返回值 包名.类名.?方法名(方法参数) throws 异常?)

/* 
   其中带?的表示可以省略的部分
   访问修饰符:可省略(比如:public、protected)
   包名.类名:可省略
   throws 异常:可省略(注意是方法上声明抛出的异常,不是实际抛出的异常)
*/
    
// 可以使用通配符描述切入点
// *:单个独立的任意符号,可以通配任意返回值、包名、类名、方法名、任意类型的一个参数,也可以通配包、类、方法名的一部分
execution(* com.*.service.*.update*(*))
// ..:多个连续的任意符号,可以通配任意层级的包,或任意类型、任意个数的参数
execution(* com.itheima..DeptService.*(..))
// 根据业务需要,可以使用且(&&)、或()、非(!)来组合比较复杂的切入点表达式

形式二 ​

java
// 在 src\main\java\com\example\demo\anno\LogOperation.java 中创建注解
// 表示 LogOperation 注解只能加在方法上
@Target(ElementType.METHOD)
// 表示 LogOperation 注解在运行时生效
@Retention(RetentionPolicy.RUNTIME)
public @interface LogOperation{}
java
// 在切面代码使用
@Aspect
@Component
public class RecordTimeAspect {
    // 填入上面创建好的注解的全类名
    @AfterThrowing("@annotation(com.example.demo.anno.LogOperation)")
    public void before() {}
}
java
// 在需要 AOP 的方法上加上上方定义好的注解即可
@LogOperation
public List<Dept> list() {}

连接点 ​

在 Spring 中用 JoinPoint 抽象了连接点,用它可以获得方法执行时的相关信息,如目标类名、方法名、方法参数等

对于 @Around 通知,获取连接点信息只能使用 ProceedingJoinPoint

对于其它四种通知,获取连接点信息只能使用 JoinPoint,它是 ProceedingJoinPoint 的父类型

java
@Aspect
@Component
public class RecordTimeAspect {
    @Around("execution(* com.example.demo.service.impl.*.*(..))")
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        String className = joinPoint.getTarget().getClass().getName(); // 获取目标类名
        Signature signature = joinPoint.getSignature();// 获取目标方法签名
        String methodName = joinPoint.getSignature().getName(); // 获取目标方法名
        Object[] args = joinPoint.getArgs(); // 获取目标方法运行参数
        Object result = joinPoint.proceed();
        return result;
    }

    @Before("execution(* com.itheima.service.impl.*.*(..))")
    public void before(JoinPoint joinPoint) {
        // 1.获取目标对象
        Object target = joinPoint.getTarget();
        // 2.获取目标类
        String className = joinPoint.getTarget().getClass().getName();
        // 3.获取目标方法
        String methodName = joinPoint.getSignature().getName();
        // 4.获取目标方法参数
        Object[] args = joinPoint.getArgs();
    }
}

注入 ​

上方多次使用依赖注入(@Autowired / @Resource),什么时候需要使用有一个判断标准:

这个对象的字段/依赖,需不需要"别人"来填?需要 → 注入;自己能填满 → 直接 new

必须用 ​

1.需要配置文件里的值(application.yml)

2.依赖其他 Bean

java
@Component
public class AliyunOssOperator {
    @Resource
    private AliyunOSSProperties props;   // 依赖另一个 Bean
}

3.依赖框架生成的对象(接口代理、连接池等)

java
@Mapper
// EmpMapper 是接口,根本 new 不出来。MyBatis 在启动时用动态代理生成了实现类,注册为 Bean,只能注入
public interface EmpMapper { ... }

不用 ​

1.纯数据对象(DTO / VO / Entity)

java
// 这些类的使命就是"装数据",字段由业务代码自己填,不需要容器帮忙。@Data 生成的 setter 是给业务代码用的,不是给 Spring 用的
User user = new User(5, "gaoyuanyuan", "666888", "高圆圆", 18);
Emp emp = new Emp();
Result.success(data);
PageResult<Emp> pageResult = new PageResult<>(total, list);

2.无状态工具类

java
// 没有字段、没有依赖、纯静态方法,直接调用类名即可,连 new 都不用。这类类千万别加 @Component 然后注入——纯属多余
public class DateUtils {
    public static LocalDate parse(String s) { ... }
}

public class StringUtils { ... }

3.每次都要新实例、有独立状态的对象

java
// 这些对象每次都要独立的一份,如果做成单例 Bean 注入,多个请求会共享同一个对象,数据互相污染
StringBuilder sb = new StringBuilder();
List<Emp> list = new ArrayList<>();
Map<String, Object> map = new HashMap<>();

4.简单的值对象、配置常量

java
BigDecimal amount = new BigDecimal("100.00");
LocalDate today = LocalDate.now();

参数配置化 ​

@Value ​

指将一些需要灵活变化的参数(如上方阿里云相关配置),配置在配置文件中,然后通过@Value注解来注入外部配置的属性

yml
# src\main\resources\application.yml
# 自定义配置
aliyun:
	oss:
        endpoint: https://oss-cn-beijing.aliyuncs.com
        bucketName: java-ai
        region: cn-beijing

在业务代码中使用

java
// Spring 注解启动时扫描到这个类,把它实例化并注册为 Bean,方便其他类直接注入(通过 @Autowired / @Resource 注入它)使用
@Component
public class AliyunOssOperator {
    // Spring 的注解,用于从配置文件(application.yml / application.properties)或环境变量中读取值,注入到字段上,这里读取的是上方 endpoint 的值
    @Value("${aliyun.oss.endpoint}")
    private String endpoint;
    @Value("${aliyun.oss.bucketName}")
    private String bucketName;
    @Value("${aliyun.oss.region}")
    private String region;
}

@ConfigurationProperties ​

使用 @Value 注解注入配置文件的配置项,如果配置项多,注入繁琐,不便于维护管理和复用,这时可以使用它

yml
# src\main\resources\application.yml
# 自定义配置
aliyun:
	oss:
        endpoint: https://oss-cn-beijing.aliyuncs.com
        bucketName: java-ai
        region: cn-beijing

定义实体类

java
@Data
@Component
// Spring 注解,把配置文件中以 aliyun.oss 为前缀的所有属性,按名称绑定到本类的字段上
@ConfigurationProperties(prefix = "aliyun.oss")
    public class AliyunOSSProperties {
    // 注意字段名要与 application.yml 保持一致
    private String endpoint;
    private String bucketName;
    private String region;
}

在业务中使用

java
// Spring 的依赖注入有一个前提:注入方和被注入方都必须是 Spring 容器管理的 Bean,所以要在实体类加上@Component注解
@Component
public class AliyunoSSOperator {
    
    // 注入上方写好的实体类 AliyunOSSProperties
    @Resource
    private AliyunoSSProperties aliyunOSSProperties;
    public String upload() {
        // 获取值
        String endpoint = aliyunOSSProperties.getEndpoint();
        String bucketName = aliyunOSSProperties.getBucketName();
    }
}

日志 ​

程序中的日志,是用来记录应用程序的运行信息、状态信息、错误信息等,方便数据追踪、性能优化、问题排查、系统监控等

目前市面上已经有成熟的解决方案,如:JUL、Log4j、Logback,目前最为常用的是 Logback

基本使用 ​

springboot 项目中默认已经安装了 Logback 依赖,所以无需再次安装直接使用

新建 src\main\resources\logback.xml 文件用于配置 Logback

xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!-- 格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度 %logger{50}:最长50个字符(超出.切割) -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- 日志输出级别 -->
    <!-- level="off" 后控制台不在输出日志-->
    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

在 src\test\java\com\example\demo\DemoApplicationTests.java 文件中写入并运行测试

打印日志时推荐使用占位符写法,性能更高

占位符是惰性求值:SLF4J 只有在确认这条日志会被输出时,才去把参数填充进模板。日志被过滤掉时,零字符串构造开销,字符串拼接写法是立即执行的。即使当前日志级别高于 INFO(比如生产环境设为 WARN),"计算结果为:" + sum 仍然会先拼接字符串,然后才被日志框架丢弃。这个拼接开销白花了

java
// 可使用 @Slf4j 注解简化代码
class DemoApplicationTests {
    // 这里的 Logger、LoggerFactory 都是 slf4j 提供的,如果项目中使用了 lombok 包那么加上 @Slf4j 注解后这行代码就可以省略了
	private static final Logger log = 
        // getLogger 方法需要传递需要添加日志的类的字节码对象这里是 DemoApplicationTests
        LoggerFactory.getLogger(DemoApplicationTests.class);

	@Test
	void contextLoads() {
		log.debug("开始计算...");
		int sum = 0;
		int[] nums = { 1, 5, 3, 2, 1, 4, 5, 4, 6, 7, 4, 34, 2, 23 };
		for (int num : nums) {
			sum += num;
		}
        /*
          当输出的变量较多时可使用占位符写法且性能更高,log.info("计算结果为:" + sum) 等价于如下代码:
            log.info("计算结果为: {}",sum);
        */
        /*
            log.info("用户" + name + "在" + time + "从" + ip + "登录,结果:" + result);
            下方代码等价于上方代码
            log.info("用户{}在{}从{}登录,结果:{}", name, time, ip, result);
        */
		log.info("计算结果为:" + sum);
		log.debug("结束计算...");
	}
}
bash
# 控制台输出示例
16:54:06.201 [main] DEBUG com.example.demo.DemoApplicationTests - 开始计算...
16:54:06.202 [main] INFO  com.example.demo.DemoApplicationTests - 计算结果为:101
16:54:06.202 [main] DEBUG com.example.demo.DemoApplicationTests - 结束计算...

配置 ​

配置文件名:logback.xml

该配置文件是对 Logback 日志框架输出的日志进行控制的,可以来配置输出的格式、位置及日志开关等

常用的两种输出日志的位置:控制台、系统文件

xml
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">...</appender>

<!-- 系统文件输出 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"></appender>

<!-- 开启所有日志(ALL),关闭所有日志(OFF),其他可选值:debug、TRACE、INFO、WARN、ERROR 且不区分大小写,即 all 和 ALl 都是可以生效的 -->
<root level="ALL">
    <appender-ref ref="STDOUT" />
	<appender-ref ref="FILE" />
</root>

完整配置文件

xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 控制台输出配置 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!-- 控制台输出格式 -->
            <!-- 格式化输出:%d 表示日期,%thread 表示线程名,%-51eve1表示级别从左显示5个字符宽度,%1ogger显示日志记录器的名称,%msg表示日志消息,%n表示换行符 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 系统文件输出配置 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 日志文件输出的文件名,%i表示序号 -->
            <FileNamePattern>D:/tlias-%d{yyyy-MM-dd}-%i.log</FileNamePattern>
            <!-- 最多保留的历史日志文件数量 -->
            <MaxHistory>30</MaxHistory>
            <!-- 最大文件大小,超过这个大小会触发滚动到新文件,默认为 10MB -->
            <maxFileSize>10MB</maxFileSize>
        </rollingPolicy>
    </appender>

    <!-- 日志输出级别 -->
    <!-- 这表示既要往控制台输出还要往文件输出 -->
    <root level="ALL">
        <!-- 定位上方控制台输出和文件输出的配置 -->
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE" />
    </root>
</configuration>

日志级别 ​

日志级别指的是日志信息的类型,日志都会分级别,常见的日志级别如下(级别由低到高)

日志级别说明记录方式
trace追踪,记录程序运行轨迹【使用很少】og.trace("...")
debug调试,记录程序调试过程中的信息,实际应用中一般将其视为最低级别【使用较多】log.debug("...")
info记录一般信息,描述程序运行的关键事件,如:网络连接、io操作【使用较多】log.info("...")
warn警告信息,记录潜在有害的情况【使用较多】log.warn("...")
error错误信息【使用较多】log.error("...")

可以在配置文件中,灵活的控制输出那些类型的日志。大于等于配置的日志级别的日志才会输出

xml
<root level="info">
    <appender-ref ref="STDOUT" />
    <appender-ref ref="FILE" />
</root>

多表关系 ​

项目开发中,在进行数据库表结构设计时,会根据业务需求及业务模块之间的关系,分析并设计表结构。由于业务之间相互关联,所以各个表结构之间也存在着各种联系。分为三种:一对多(多对—)、一对一、多对多

一对多 ​

场景:部门与员工的关系(一个部门下有多个员工)

外键约束 ​

现象:部门表中删除某条部门数据(如开发部),但员工表中依赖部门表数据,就会出现员工表中存在大量开发部的员工数据(脏数据)

原因:目前上述的两张表,在数据库层面,并未建立关联,所以是无法保证数据的一致性和完整性的

物理外键(了解即可) ​

使用 foreign key 定义外键关联另外一张表

解决方案1:外键约束,可以在创建表时或表结构创建完成后,为字段添加外键约束,添加后只要员工表中存在开发部的员工数据,那么在删除部门表的开发部时数据库会报错(sql 执行失败)

sql
-- 具体语法如下:
-- 创建表时指定
create table 表名(
字段名 数据类型,
...
[constraint] [外键名称] foreign key (外键字段名) references 主表(字段名)
);

-- 建完表后,添加外键
alter table 表名 add constraint 外键名称 foreign key (外键字段名) references 主表(字段名);
-- 示例
-- 下方是为 emp 表中 dept_id 字段创建外键 fk_emp_dept_id (命名规范:fk_表1_表2_外键字段名)关联 dept 表中的 id 字段
alter table emp add constraint fk_emp_dept_id foreign key (dept_id) references dept(id);

物理外键存在诸多问题:

1.影响增、删、改的效率(需要检查外键关系)

2.仅用于单节点数据库,不适用与分布式、集群场景

3.容易引发数据库的死锁问题,消耗性能

所以在开发当中不推荐使用

逻辑外键 ​

在业务层逻辑(代码)中,解决外键关联,但表结构无关联,在开发中更为推荐

一对一 ​

案例:用户与身份证信息的关系

关系:一对一关系,多用于单表拆分,将一张表的基础字段放在一张表中,其他字段放在另一张表中,以提升操作效率

多对多 ​

案例:学生与课程的关系

关系:一个学生可以选修多门课程,一门课程也可以供多个学生选择

部署 ​

前端工程部署 ​

Nginx ​

Nginx是一款轻量级的Web服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器。其特点是占有内存少,并发能力强,在各大型互联网公司都有非常广泛的使用。官网:https://nginx.org/

下载 Nginx 压缩包并解压

解压目录 ​

以 Windows 为例

conf 文件夹::存放着 Nginx 配置文件

html 文件夹:存放需要部署的前端项目(dist 包)

logs 文件夹:存放着 Nginx 运行日志

temp 文件夹:临时文件存放目录

nginx.exe :启动程序,默认启动端口为 80

配置 ​

nginx
# Nginx/conf/nginx.conf 配置文件,配置反向代理
server {
  # 配置 nginx 虚拟服务器端口号
  listen 80;
  # location 用于定义匹配路径匹配的规则,^~/api/ 表示精确匹配,即只匹配以/api/开头的路径
  location ^~ /api/ {
    # rewrite 用于重写匹配到的路径,如 http://localhost:90/api/depts 路径 ^/api/(.*)$ /$1 break 表示将 http://localhost:90/api/depts 重写为 http://localhost:90/depts
    rewrite ^/api/(.*)$ /$1 break;
    # 用于代理转发,它将匹配到的请求转发给位于后端的指令服务器地址
    proxy_pass http://localhost:8080;
  }
}

负载均衡 ​

Nginx 站在客户端和后端服务器之间,作为反向代理,把收到的请求按照一定规则分发给多台后端服务器,而不是全部压在一台上

轮询 ​

不写任何策略指令,即默认启用

请求按时间顺序依次分配到每台后端,实现最简单,开销最低。后端宕机时,默认会被自动摘除(依赖被动健康检查)

适用场景:后端机器性能一致、服务无状态、请求处理时长相近的常规场景。这是零配置的默认选择

nginx
# nginx.conf 配置文件
# 定义后端连接池
upstream webservers{
    server 192.168.100.128:8080;
    server 192.168.100.129:8080;
}
server {
  # 其他配置...
  location /api/ {
  	# 负载均衡(默认),请求就会按轮询策略分发(会将前端请求平均的分发给各个后端服务处理)
  	proxy_pass http://webservers/admin/;
  }
}
加权轮询 ​

在 server 行追加 weight=N

权重方式,默认为1,权重越高,被分配的客户端请求就越多。

适用场景:集群内机器配置不均(CPU、内存、带宽存在差异),需要让强机器承担更多流量

nginx
upstream backend {
    server 10.0.0.11:8080 weight=3;
    server 10.0.0.12:8080 weight=1;
    # weight 默认为 1
    server 10.0.0.13:8080;        
}
server {
  # 其他配置...
  location /api/ {
    # 此时三台机器的请求分配比例约为 3:1:1
  	proxy_pass http://backend/admin/;
  }
}
IP 哈希 ​

在 upstream 块首行写 ip_hash

依据ip分配方式,这样每个访客可以固定访问一个后端服务

适用场景:应用未做会话共享(Session 存在本地),需要让同一用户始终落到同一台后端,避免登录状态丢失

nginx
upstream backend {
    ip_hash;
    server 10.0.0.11:8080;
    server 10.0.0.12:8080;
}
server {
  # 其他配置...
  location /api/ {
  	proxy_pass http://backend/admin/;
  }
}
最少连接 ​

在 upstream 块首行写 least_conn;,可与 weight 组合

每次将新请求分配给“活跃连接数 / 权重”最小的后端。它不只看请求次数,而是看当前谁“最闲”,因此能更好地应对请求处理时长差异大的情况。与 weight 结合时,高权重节点可以承载更多连接

适用场景:请求耗时差异大、存在长连接(如 WebSocket、文件上传/下载)、API 响应时间不稳定的场景。对于多数 HTTP API 和 WebSocket 工作负载,least_conn 是一个稳健的默认选择

nginx
upstream backend {
    least_conn;
    server 10.0.0.11:8080 weight=3;
    server 10.0.0.12:8080 weight=1;
}

server {
  # 其他配置...
  location /api/ {
  	proxy_pass http://backend/admin/;
  }
}

远程服务器部署 ​

1.在远程服务器(Linux)安装好 Nginx

2.使用 FinalShell(远程连接工具)将前端打包好的工程文件(dist目录下的静态文件)上传到nginx的html目录中

3.配置nginx的配置文件,在 conf/nginx.conf 中配置反向代理服务器及路径重写规则

yml
# conf/nginx.conf 配置文件,配置反向代理
server {
  listen 80;
  server_name localhost;
  client_max_body_size 10m;
  location / {
    root  html;
    index index.html index.htm;
    try_files $uri $uri/ /index.html;
  }
  location ^~ /api/ {
    rewrite ^/api/(.*)$ /$1 break;
    proxy_pass http://localhost:8080;
  }
}

4.在nginx的安装目录中,执行 sbin 目录下的nginx命令启动nginx服务:sbin/nginx 或 sbin/nginx -s reload

Linux ​

Linux是一套免费使用和自由传播的操作系统

分类系统特点
桌面操作系统Windows用户数量最多
桌面操作系统Mac OS操作体验好,办公人士首选
桌面操作系统Linux用户数量少
移动设备操作系统Android基于Linux、开源,主要用智能手机、平板、智能电视
移动设备操作系统IOS苹果公司开发、不开源,用于苹果公司的产品
移动设备操作系统HarmonyOS华为公司开发、开源,目前用于华为公司的产品
服务器操作系统Unix安全、稳定、付费
服务器操作系统Linux安全、稳定、免费、占有率高
服务器操作系统Windows Server付费、占有率低

安装 ​

分为内核版(由Linux核心团队开发、维护、免费、开源、负责控制硬件)和发行版(基于Linux内核版进行扩展、由各个Linux厂商开发、维护、有收费版本和免费版本)

开发中一般使用发行版,又分为许多版本,如:Ubuntu(以桌面应用为主,免费)、RedHat(面向企业用户,收费)、CentOS(RedHat的社区版,免费)等

分为两种安装方式:物理机安装(直接将操作系统安装到服务器硬件上)、虚拟机安装(通过虚拟机软件安装,借助 VMware 软件)

远程连接 ​

开发中公司在北京,服务器可能在上海/天津/香港/海外,这时可以使用远程连接工具来远程操作服务器

常用的SSH(Secure Shell,安全外壳协议)远程连接工具:Putty、SecureCRT、Xshell、FinalShell等

文件目录 ​

bin:存放二进制可执行文件

boot:存放系统引导时使用的各种文件

dev:存放设备文件

etc:存放系统配置文件

home:存放系统用户的文件

lib: 存放程序运行所需的共享库和内核模块

opt :额外安装的可选应用程序包所放置的位置

root:超级用户目录

sbin:存放二进制可执行文件,只有root用户才能访问

tmp :存放临时文件

usr:存放系统应用程序

var :存放运行时需要改变数据的文件,例如日志文件

常用命令 ​

Linux命令格式: command -options parameter

command:命令名

-options:选项,可用来对命令进行控制,也可以省略(可选)

parameter:参数,可以是零个、一个或多个(可选)

使用技巧:

Tab键自动补全

连续两次Tab键,给出操作提示

使用上下箭头快速调出曾经使用过的命令

使用clear命令或Ctrl+l快捷键实现清屏

目录操作 ​

ls ​

作用:显示指定目录下的内容

语法:ls [-al] [dir] ,中括号内的内容可选 [dir] 表示要查看的目录

选项:-a:显示所有文件及目录(. 开头的隐藏文件也会列出)、-l:除文件名称外,同时将文件类型(d表示目录,-表示文件)、权限、拥有者、文件大小等信息详细列出

由于我们使用 ls 命令(查看当前目录下的所有文件,pwd命令可查看当前所处目录)时经常需要加入 -l 选项,所以Linux为ls -l命令提供了一种简写方式,即ll

cd ​

作用:用于切换当前工作目录,即进入指定目录

语法:cd [dirName] 中括号内的内容可选 [dirName] 表示要切换的目录名

说明:.表示目前所在的目录、.. 表示目前目录位置的上级目录、~表示用户的home目录

举例:

cd ..:切换到当前目录的上级目录

cd ~:切换到用户的home目录

cd /usr/local :切换到/usr/local目录

cd -:切换到上一次所在目录

mkdir ​

作用:创建目录

语法: mkdir [-p] dirName 中括号内的内容可选

说明:

-p:确保目录名称存在,不存在的就创建一个。通过此选项,可以实现多层目录同时创建

举例:

mkdir demo:在当前目录下,建立一个名为 demo 的子目录

mkdir -p demo/test:在demo目录中创建test子目录,若demo目录不存在,则建立一个

rm ​

作用:删除文件或者目录

语法: rm [-rf] name 中括号内的内容可选

说明:

-r:将目录及目录中所有文件(目录)逐一删除,即递归删除

-f:无需确认,直接删除

举例:

rm -r demo/ 删除名为demo的目录和目录中所有文件,删除前需确认

rm -rf demo/ 无需确认,直接删除名为demo的目录和目录中所有文件

rm -f hello.txt 无需确认,直接删除hello.txt文件

文件操作 ​

cat ​

作用:用于显示文件的所有内容,适合查看小文件(文件内容一大内容会全显示在控制台上)

语法: cat [-n] fileName

说明:

-n:由1开始对所有输出的行数编号

举例:

cat /etc/profile:查看/etc目录下的profile文件内容

more ​

作用:以分页的形式显示文件内容,适合查看大文件

语法: more fileName

操作说明:

回车键:向下滚动一行

空格键:向下滚动一屏

b:返回上一屏

q或Ctrl+C:退出more

举例:

more /etc/profile:以分页方式显示/etc目录下的profile文件内容

作用:查看文件开头的内容

语法:head [-n] fileName

说明:

-n :输出文件开头的n行内容

举例:

head 1.log:默认显示1.log文件开头的10行内容

head -20 1.log:显示1.log文件开头的20行内容

tail ​

作用:查看文件末尾的内容

语法:tail [-nf] fileName

说明:

-n :输出文件末尾的n行内容

-f:动态读取文件末尾内容并显示,通常用于日志文件的内容输出

举例:

tail 1.log:默认显示1.log文件末尾10行的内容

tail -20 1.log:显示1.log文件末尾20行的内容

tail -f 1.log:动态读取1.log文件末尾内容并显示(实时刷新)

拷贝移动 ​

cp ​

作用:用于复制文件或目录

语法:cp [-r] source dest

选项:

-r:如果复制的是目录需要使用此选项,此时将复制该目录下所有的子目录和文件

举例: cp hello.txt demo/:将hello.txt复制到demo目录中

cp hello.txt ./hi.txt:将hello.txt复制到当前目录,并改名为hi.txt

cp -r demo/ ./demop/:将demo目录和目录下所有文件复制到demop目录下

cp -r demo/* ./demop/:将demo目录下所有文件复制到demop目录下

mv ​

作用:为文件或目录重命名、或将文件或目录移动到其它位置(第二个参数是已存在的目录执行移动)

语法: mv source dest

举例:

mv hello.txt hi.txt:将hello.txt改名为hi.txt

mv hi.txt demo/:将文件hi.txt移动到demo目录中

mv hi.txt demo/hello.txt:将hi.txt移动到demo目录中,并改名为hello.txt

mv demo/ demop/:如果demop目录不存在,将demo目录改名为demop

mv demo/ demop/:如果demop目录存在,将demo目录移动到demop目录中

打包压缩 ​

tar ​

作用:对文件进行打包、解包、压缩、解压

语法:tar [-zcxvf] fileName [files]

说明:

包文件后缀为.tar表示只是完成了打包,并没有压缩

包文件后缀为.tar.gz表示打包的同时还进行了压缩

选项:

-z:z代表的是gzip,通过gzip命令处理文件,gzip可以对文件压缩或者解压

-c:c代表的是create,即创建新的包文件

-x:x代表的是extract,实现从包文件中还原文件

-v:v代表的是verbose,显示命令的执行过程

-f:f代表的是file,用于指定包文件的名称

示例:

打包:

tar -cvf hello.tar hello :将当前目录下所有文件打包,打包后的文件名为hello.tar

tar -zcvf hello.tar.gz hello: 将当前目录下所有文件打包并压缩,打包后的文件名为hello.tar.gz

解包:

tar -xvf hello.tar:将hello.tar文件进行解包,并将解包后的文件放在当前目录

tar -zxvf hello.tar.gz:将hello.tar.gz文件进行解压,并将解压后的文件放在当前目录

tar -zxvf hello.tar.gz -C /usr/local :将hello.tar.gz文件进行解压,解压到指定的/usr/local目录中

文本编辑 ​

vi/vim ​

作用:vi命令是Linux系统提供的一个文本编辑工具,可以对文件内容进行编辑,类似于windows中的记事本

语法:vi fileName

说明:

1、vim是从vi发展来的一个功能更加强大的文本编辑工具,在编辑文件时可以对文本内容进行着色(更常用)。

2、要使用vim命令,需要我们自己完成安装。可以使用 yum install vim 命令来完成安装

vim ​

作用:对文件内容进行编辑,vim其实就是一个文本编辑器

语法: vim fileName

vim的三种模式,某些操作必须进入到特定模式下才可行,如何在三种模式切换,操作如下

命令模式指令

命令模式指令含义
gg定位到文本内容的第一行
G定位到文本内容的最后一行
dd删除光标所在行的数据
ndd删除当前光标所在行及之后的n行数据
u撤销操作
i 或 a或 o进入插入模式 (进入后光标所处的位置不同而已)

底行模式命令

底行模式命令含义
: wq保存并退出
: q!不保存退出
:set nu显示行号
:set nonu取消行号显示
:n定位到第n行,如:10 就是定位到第10行

查找 ​

find ​

作用:在指定目录下查找文件

语法: find dirName -option fileName

举例:

find . -name "*.log":在当前目录及其子目录下查找.log结尾文件 find /demo -name "*. log":在/demo目录及其子目录下查找.log结尾的文件

grep ​

作用:从指定文件中查找指定的文本内容

语法: grep [-inAB] word fileName

选项:

-i:检索的关键字忽略(ignore)大小写

-n:显示关键字所在的这一行的行号

-A:输出关键字所在行及之后(After)的几行记录(如:-A5 表示输出关键字所在行之后的5行记录)

-B:输出关键字所在行及之前(Before)的几行记录(如:-B5 表示输出关键字所在行之前的5行记录)

举例:

grep Hello HelloWorld.java:查找HelloWorld.java文件中出现的Hello字符串的位置

grep hello *.java:查找当前目录中所有.java结尾的文件中包含hello字符串的位置

常见软件安装 ​

安装方式 ​

1.二进制发布包安装:软件已经针对具体平台编译打包发布,只要解压,修改配置即可

2.rpm安装:软件已经按照redhat的包管理规范进行打包,使用rpm命令进行安装,不能自行解决库依赖问题

3.yum安装:一种在线软件安装方式,本质上还是rpm安装,自动下载安装包并安装,安装过程中自动解决库依赖问题

4.源码编译安装:软件以源码工程的形式发布,需要自己编译打包

JDK安装 ​

1.使用FinalShell(远程连接工具)自带的上传工具将jdk的二进制发布包上传到Linux,如:jdk-17.0.10_linux-x64_bin.tar.gz

2.解压安装包,命令为 tar -zxvf jdk-17.0.10_linux-x64_bin.tar.gz -C /usr/local

3.配置环境变量,使用vim命令修改/etc/profile文件,在文件末尾加入如下配置:

​ export JAVA_HOME=/usr/local/jdk-17.0.10

​ export PATH=$JAVA_HOME/bin:$PATH

4.重新加载profile文件,使更改的配置立即生效,命令为 source /etc/profile

5.检查安装是否成功,命令为 java -version

mysql安装 ​

1.准备工作:卸载Linux系统中自带的mysql/mariadb安装包,否则MySQL将安装失败

​ rpm -qa | grep mariadb

​ rpm -e -nodeps mariadb-libs-5.5.60-1.el7_5.x86_64

2.下载并上传mysql安装包,如:mysql-8.0.30-linux-glibc2.12-x86_64.tar.xz

3.解压安装包到当前目录,并将解压后的文件夹移动到/usr/local目录下,改名为mysql,命令:

​ tar -xvf mysql-8.0.30-linux-glibc2.12-x86_64.tar.xz

4.配置环境变量(编辑/etc/profile,追加内容)

​ export MYSQL_HOME=/usr/local/mysql

​ export PATH=$MYSQL_HOME/bin:$PATH

5.注册MySQL为系统服务

​ cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysql

​ chkconfig --add mysql

6.初始化数据库

​ groupadd mysql

​ useradd -r -g mysql -s /bin/false mysql

​ mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data

初始化完毕后,日志中会输出mysql的root用户的临时密码,记得复制记录下来。

7.启动服务登录MySQL

​ systemctl start mysql (systemctl stop mysql可停止服务)

​ mysql -uroot -pxxxxx

8.配置MySQL的root用户的密码,授权远程访问

​ ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '1234';

​ CREATE USER 'root'@'%' IDENTIFIED BY '1234’;

​ GRANT ALL PRIVILEGES ON *.* TO 'root'@'%';

​ FLUSH PRIVILEGES;

9.这时系统可能开启了防火墙,并不能远程连接服务器上的数据库

查看防火墙状态(systemctl status firewalld、firewall-cmd --state)

关闭防火墙(systemctl stop firewalld)

开启防火墙(systemctl start firewalld)

永久关闭防火墙(systemctl disable firewalld)

在实际开发中强烈不建议关闭防火墙,可尝试如下方式解决不能远程访问数据库的问题

开放指定端口(firewall-cmd --zone=public --add-port=8080/tcp --permanent)

·关闭指定端口(firewall-cmd --zone=public --remove-port=8080/tcp --permanent)

立即生效(firewall-cmd --reload)

查看开放的端口(firewall-cmd --zone=public --list-ports)

注意:

1.systemctl是管理Linux中服务的命令,可以对服务进行启动、停止、重启、查看状态等操作

2.firewall-cmd是Linux中专门用于控制防火墙的命令

3.为了保证系统安全,生产服务器的防火墙不建议关闭

Nginx安装 ​

1.安装nginx运行时需要的依赖:yum install -y pcre pcre-devel zlib zlib-devel openssl openssl-devel

2.上传nginx的源码包,如:nginx-1.20.2.tar.gz

3.解压源码包到当前目录:tar -zxvf nginx-1.20.2.tar.gz

4.进入到解压目录(cd nginx-1.20.2)后,执行指令:./configure --prefix=/usr/local/nginx

5.执行编译nginx的指令:make

6.执行安装nginx的指令,安装到上述指定的 /usr/local/nginx 目录:make install

7.进入到nginx安装目录/usr/local/nginx,启动nginx服务:sbin/nginx

后端项目部署 ​

1.在远程服务器(Linux)安装好 JDK

2.执行maven的父工程中的package生命周期,对项目进行打包(打包之前,先连接上服务器数据库,先测试通过)。

3.在linux服务器的/usr/local目录下,创建一个目录tlias-app,将jar包上传到服务器的 /usr/local/tlias-app 目录中。

4.然后在命令行执行命令,运行jar包:java -jar xxxxxx.jar

5.上述执行运行jar包之后,会占用前台窗口,窗口关闭服务也就停了。可以使用nohup指令,后台运行服务,执行指令:

​ nohup java -jar xxxxxx.jar &> tlias.log &

执行上述命令后会输出进程 id,可执行 kil1 -9 进程 id 来杀死进程

查看进程:ps -ef | grep xxxx,如 ps -ef | grep java 表示根据 java 关键字过滤后台运行的进程

Docker ​

是一款快速构建、运行、管理应用的工具。

在Linux上安装软件,以及如何在Linux上部署一个单体项目要执行的步骤太多,而且由于每台服务器的运行环境不同,你写好的安装流程、部署脚本并不一定在每个服务器都能正常运行,经常会出错。这就给系统的部署运维带来了很多困难,这时就需要使用它

安装 ​

1.首先如果服务器中已经存在旧的Docker,则先卸载 yum remove docker

2.配置Docker的yum库

​ 1.安装一个yum工具:sudo yum install -y yum-utils device-mapper-persistent-data lvm2

​ 2.配置Docker的yum源:sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

​ sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo

​ 3.更新yum,建立缓存:sudo yum makecache fast

3.安装Docker:yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

4.启动和校验

bash
# 启动Docker
systemctl start docker

# 停止Docker
systemctl stop docker

# 重启
systemctl restart docker

# 设置开机自启
systemctl enable docker

# 执行docker ps命令,如果不报错,说明安装启动成功
docker ps

5.配置镜像加速

bash
# 创建目录
rm -f /etc/docker/daemon.json

# 复制内容
tee /etc/docker/daemon.json <<-'EOF'
{
    "registry-mirrors": [
        "http://hub-mirror.c.163.com",
        "https://mirrors.tuna.tsinghua.edu.cn",
        "http://mirrors.sohu.com",
        "https://ustc-edu-cn.mirror.aliyuncs.com",
        "https://ccr.ccs.tencentyun.com",
        "https://docker.m.daocloud.io",
        "https://docker.awsl9527.cn"
    ]
}
EOF

# 重新加载配置
systemctl daemon-reload

# 重启Docker
systemctl restart docker

镜像和容器 ​

当我们利用Docker安装应用时,Docker会自动搜索并下载应用镜像(image)。镜像不仅包含应用本身,还包含应用运行所需要的环境、配置、系统函数库。Docker会在运行镜像时创建一个隔离环境,称为容器(container)

镜像:将应用所需的运行环境、配置文件、系统函数库等与应用一起打包得到的就是镜像

容器:为每个镜像的应用进程创建的隔离运行环境就是容器

镜像仓库:存储和管理镜像的平台就是镜像仓库,Docker官方维护了一个公共仓库:https://hub.docker.com

入门 ​

这里拿安装mysql为例

只需一条命令即可完成安装、环境配置、启动等一系列操作

bash
# 创建并运行一个容器,-d 是让容器在后台运行
docker run -d \
  # 给容器起个名字,必须唯一
  --name mysql \
  # 设置端口映射,每个容器内的数据库都会有自己独立的网络环境(如ip),但外部是无法直接通过此ip连接上数据库的,此时可以通过宿主机(当前数据库安装的机器)和此容器内的数据库建立链接映射端口3307,这时外部就可以直接连接此3307端口达到间接连接此数据库的目的
  -p 3307:3306 \
  # 设置环境变量
  -e TZ=Asia/Shanghai \
  # 设置环境变量,mysql 连接密码
  -e MYSQL_ROOT_PASSWORD=123 \
  # 指定运行的镜像的名字、版本,也可以不指定版本,默认代表最新版本的镜像
  mysql:8

核心 ​

常用命令 ​

Docker最常见的命令就是操作镜像、容器的命令,详见官方文档:https://docs.docker.com/

镜像命令

bash
# 从远程镜像仓库拉取镜像到本地
docker pull

# 查看本地镜像
docker images

# 删除本地镜像
docker rmi 镜像名

# 构建镜像,准备一份 DOCKERFILE 文件制作自己的镜像时使用
docker build

# 推送镜像,可以将上一步制作的镜像上传到镜像仓库供别人使用
docker push

# 打包镜像,上一步构建好镜像后可将镜像打包成包文件发送给别人,供他人使用
docker save

# 加载镜像,紧接上一步别人拿到包文件可加载镜像到本地
docker load

容器命令

bash
# 创建并运行一个容器
docker run

# 停止容器
docker stop

# 启动已经停止的容器
docker start

# 查看当前运行的容器,docker ps -a 可查看所有容器
docker ps

# 删除容器
docker rm

# 查看指定容器的运行日志
docker logs

# 进入到指定容器内部
# 如:docker exec -it nginx bash
# -it 表示进入 nginx 容器并分配一个终端交互
# bash 表示进入后打开一个 bashShell 用于交互
# 输入 exit 命令后即可退出当前容器
docker exec

数据卷 ​

数据卷(volume)是一个虚拟目录,是容器内目录(无法通过进入容器直接修改文件内容)与宿主机目录之间映射的桥梁,这样就可以操作宿主机目录文件内容,容器内目录文件内容会同步变化,如上传前端项目到nginx 容器中

数据卷命令

bash
# 创建数据卷
docker volume create

# 查看所有数据卷
docker volume ls

# 删除指定数据卷
docker volume rm

# 查看某个数据卷的详情(如:数据卷对应宿主机目录地址)
docker volume inspect

# 清除所有未使用的数据卷
docker volume prune

在执行docker run命令时,使用 -v 数据卷:容器内目录形式可以完成数据卷挂载(数据卷不存在,会自动创建)

bash
# 示例
# -v html:/usr/share/nginx/html 表示创建 html 数据卷以及映射容器内的目录为 /usr/share/nginx/html
docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx:1.20.2
匿名数据卷 ​

如在创建 mysql 容器时自动创建一个数据卷,用于在宿主机保存数据库文件(备份),防止删除 mysql 容器时将数据也一并删除且不可恢复

本地目录挂载 ​

注意:

1.本地目录必须以 / 或 ./ 开头,如果直接以名称开头,会被识别为数据卷而非本地目录

2.-v mysql:/var/lib/mysql 会被识别为一个数据卷,数据卷叫mysql

3.-v ./mysql:/var/lib/mysql 会被识别为当前目录下的mysql目录

bash
# 本地目录挂载
docker run -d --name 容器名 -p 宿主机端口:容器端口 -v⁺ 宿主机目录或文件:容器内目录或文件 镜像名
bash
# 当本地存在数据库文件但没安装数据库时(拿mysql为例,nginx也是同理),可使用本地目录挂载
docker run -d \
  --name mysql \
  -p 3307:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  # 如果本地已经有数据库文件了,可以直接指定数据卷目录
  -v /root/mysq1/data:/var/1ib/mysq1 \
  -v /root/mysq1/conf:/etc/mysq1/conf.d \
  -v /root/mysql/init:/docker-entrypoint-initdb.d \
  mysql:8

自定义镜像 ​

当使用 Docker 部署后端项目时就需要自定义镜像了,因为每个项目不一样

镜像就是包含了应用程序、程序运行的系统函数库、运行配置等文件的文件包。构建镜像的过程其实就是把上述文件打包的过程

Dockerfile ​

Dockerfile就是一个文本文件,其中包含一个个的指令(Instruction),用指令来说明要执行什么操作来构建镜像。将来Docker可以根据Dockerfile帮我们构建镜像

常见指令

指令说明示例
FROM指定基础镜像(系统函数库)FROM centos:7
ENV设置环境变量,可在后面指令使用ENV key=value
COPY拷贝本地(宿主机)文件到镜像的指定目录COPY ./jdk17.tar.gz /tmp
RUN执行Linux的shell命令,一般是安装过程的命令RUN tar -zxvf /tmp/jdk17.tar.gz
EXPOSE指定容器运行时监听的端口,是给镜像使用者看的EXPOSE 8080
ENTRYPOINT镜像中应用的启动命令,容器运行时调用ENTRYPOINT java -jar xx.jar

1.以下基于CentOS7(某个Linux发行版)基础镜像创建部署 java 应用为例,利用Dockerfile描述镜像结构

dockerfile
# 使用 CentOS 7 作为基础镜像
FROM centos:7

# 添加 JDK 安装包到镜像中并删除安装包
COPY jdk17.tar.gz /usr/local/
RUN tar -xzf /usr/local/jdk17.tar.gz -C /usr/local/ && rm /usr/local/jdk17.tar.gz

# 设置环境变量,jdk-17.0.10 是压缩包解压后的名字
ENV JAVA_HOME=/usr/local/jdk-17.0.10
ENV PATH=$JAVA_HOME/bin:$PATH

# 设置(如果需要)第三方环境变量(如阿里云OSS需要的环境变量)
ENV OSS_ACCESS_KEY_ID=xxxxxx
ENV OSS_ACCESS_KEY_SECRET=xxxxxx

# 指定 docker 容器在运行时使用的字符集
ENV LANG=en_US.UTF-8
ENV LANGUAGE=en_US:en
ENV LC_ALL=en_US.UTF-8

# 创建(如果需要)应用目录并更改工作目录(进入创建的目录)
RUN mkdir -p /app
WORKDIR /app

# 复制应用 JAR 文件到容器
COPY app.jar app.jar

# 暴露端口
EXPOSE 8080

# 运行命令
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

2.编写好了Dockerfile之后,可以利用下面命令来构建镜像

bash
# -t:是给镜像起名以及对应版本号,格式依然是 repository:tag 的格式,不指定 tag 时,默认为 latest(最新版本)
# .:是指定 Dockerfile 所在目录,如果就在当前目录,则指定为"."
docker build -t app:1.0 .

3.创建并运行容器,至此已经完成了部署

bash
docker run -d --name myapp -p 8080:8080 app:1.0

网络 ​

在开发当中,java程序、数据库一般是运行在不同容器中的,可以通过查看数据库容器ip来直接连接数据库,但是由于是自动分配的,每次重启后,数据库ip就可能发生变化,每次都去修改java代码非常麻烦。

自定义网络 ​

针对上面的问题,可以通过自定义网络解决。

常用命令

bash
# 创建一个网络
docker network create

# 查看所有网络
docker network ls

# 删除指定网络
docker network rm

# 清除未使用的网络
docker network prune

# 使指定容器连接加入某网络
docker network connect

# 使指定容器连接离开某网络
docker network disconnect

# 查看网络详细信息
docker network inspect

解决步骤

1.创建自定义网络

bash
docker network create javaApp

2.加入此网络

bash
# 将数据库容器加入到上一步创建的自定义网络中
docker network connect javaApp mysql

# 将 java 应用容器加入到上一步创建的自定义网络中
docker network connect javaApp myapp

3.验证

bash
# 进入 java 应用容器并打开命令行
docker exec -it myapp bash

# 直接 ping 容器名(无需写对应ip)即可查看是否通的
ping mysql

4.修改数据库连接地址

yml
# 打开 java 源码
# src/main/resources/application.yml
spring: 
	datasource: 
		# 这里填写的是上方数据库的容器名
		url: jdbc:mysql://mysql:3306/tlias

基于docker部署 ​

后端部署 ​

1.准备MySQL容器,并创建项目数据库(如tlias)及表结构,具体步骤可参照本笔记上方 “入门”以及“本地目录挂载”等部分

2.准备java应用(如tlias项目)镜像,部署Docker容器,运行测试。

2.1 修改tlias项目的配置文件,修改数据库服务地址及logback日志文件存放地址,打jar包

yml
# 打开 java 源码
# src/main/resources/application.yml
spring: 
	datasource: 
		# 这里填写的是第一步数据库的容器名以及对应的数据库名
		url: jdbc:mysql://mysql:3306/tlias
xml
<!-- 打开 java 源码 src/main/resources/logback.xml -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <!-- 修改日志输出文件在 java 应用镜像中的保存位置,这里表示放在根目录下的 tlias 文件夹下 -->
        <FileNamePattern>/tlias/tlias-%d{yyyy-MM-dd}-%i.log</FileNamePattern>
    </rollingPolicy>
</appender>

2.2 编写Dockerfile文件,可参考本笔记上方“Dockerfile”部分

2.3 构建Docker镜像。将下载好的 JDK压缩包(如:jdk17.tar.gz)、上一步的Dockerfile文件、以及 jar包通过FinalShell(远程连接工具)上传到服务器中想要放入的文件夹下

bash
# 都上传好后进入到此文件夹下执行,构建需要一点时间
docker build -t tlias:1.0 .

# 构建完成后可查看是否成功
# 查看本地所有镜像
docker images

2.4 部署Docker容器

bash
# 部署并运行 tlias-server 容器并将 tlias:1.0 镜像加入到 javaApp 这个网络中,同样还需要将数据库也加入到此网络中
# 关于如何创建网络和作用可查看本笔记上方的 “网络” 部分
docker run -d --name tlias-server -p 8080:8080 --network javaApp tlias:1.0

# 之后可通过如下命令查看 java 应用的运行日志
docker logs -f tlias-server

至此后端部署完成

前端部署 ​

1.准备nginx 配置文件以及前端 dist 目录下的文件

nginx
# nginx.conf 配置文件
server {
	# 其他配置可参考本笔记上方“远程服务器部署”部分
    location ^~ /api/ {
        rewrite ^/api/(.*)$ /$1 break;
        # 这里的服务端地址需要填写上一步 java 应用的容器名
        proxy_pass http://tlias-server:8080;
    }
}

2.上传前端项目以及 nginx 配置文件到服务器想要存放的目录下

bash
docker run -d \
# 创建 nginx-tlias 容器
--name nginx-tlias \
# 指定容器目录映射,用于存放前端工程以及 nginx 配置文件
-v /root/tlias-nginx/html:/usr/share/nginx/html \
-v /root/tlias-nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
# 加入到上一步创建好的自定义网络中
--network javaApp \
-p 80:80 \
# 指定 nginx 镜像版本,服务器需要先下载此镜像
nginx:1.20.2

DockerCompose ​

上方已经完成基于 Docker 部署前后端项目,一共创建了服务器容器、后端项目容器、nginx(前端)容器且是有先后依赖顺序的,但实际开发中可不止这么几个容器,当容器一多,区分先后依赖关系是比较麻烦的

针对上述问题可借助 DockerCompose 来解决

DockerCompose 通过一个单独的docker-compose.yml 模板文件(YAML 格式)来定义一组相关联的应用容器,帮助我们实现多个相互关联的Docker容器的快速部署。

只需创建一份docker-compose.yml (描述各容器的信息)就可以达到一键部署的目的

1.准备资源(tlias.sql,服务端的jdk17、jar包、Dockerfile,前端项目打包文件、nginx.conf),和上方一致,删除上方所有容器、自定义网络

2.准备docker-compose.yml配置文件

yml
services:
	# 配置数据库容器信息
    mysql:
    	# 数据库镜像
        image: mysq1:8
        # 据库容器名称
        container_name: mysql
        # 据库容器端口映射
        ports:
        	- "3307:3306"
        # 环境变量
        environment:
            TZ: Asia/Shanghai
            # 数据库密码
            MYSQL_ROOT_PASSWORD: 123
        # 本地目录挂载信息
        volumes :
            - "/usr/1ocal/app/mysq1/conf:/etc/mysq1/conf.d"
            - "/usr/1ocal/app/mysq1/data:/var/1ib/mysq1"
            - "/usr/local/app/mysql/init:/docker-entrypoint-initdb.d"
        # 数据库容器需要加入的自定义网络标识
        networks:
        	- tlias-net
    # 后端 java 应用容器信息
	tlias:
        # 需要自定义构建镜像
        build:
            # Dockerfile 文件存放的位置,此处表示当前目录
            context: .
            # 指定 Dockerfile 文件名
            dockerfile: Dockerfile
        # 设置基于上方构建出来的自定义容器名称(后端 java 应用容器名称)
        container_name: tlias-server
        # 端口映射
        ports:
        	- "8080:8080"
        # 后端 java 应用容器需要加入的自定义网络标识
        networks:
        	- tlias-net
        # 定义当前服务所依赖的服务
        depends_on:
        	# 依赖服务名,这里表示依赖上方的数据库服务
        	- mysq1
	# nginx 容器信息
	nginx:
		# nginx 镜像版本
        image: nginx:1.20.2
        container_name: nginx-tlias
        ports:
        	- "80:80"
        # 本地目录挂载信息
        volumes:
            - "/usr/1ocal/app/nginx/conf/nginx.conf:/etc/nginx/nginx.conf"
            - "/usr/1ocal/app/nginx/html:/usr/share/nginx/html"
        # 定义当前服务所依赖的服务
        depends_on:
        	# 依赖服务名,这里表示依赖上方的后端 java 应用服务
        	- tlias
       	# nginx 容器需要加入的自定义网络标识
        networks:
        	- tlias-net
# 自定义网络信息
networks:
	# 自定义网络标识,上方需要加入此网络时,需要填写这个
	tlias-net:
		# 自定义网络名称
		name: demo

3.将所有文件上传到服务器指定位置(要和上方docker-compose.yml中数据库服务、nginx 中的 volumes 一致)

4.上传好后进入到服务器指定目录下(和上方一致)

bash
# 按照上方的 docker-compose.yml 构建并启动所有服务(后台运行),构建完成后就完成了项目一键部署
docker compose up -d

常用命令

bash
# Docker Compose的命令格式(中括号内的表示可选):
docker compose [OPTIONS] [COMMAND]
类型参数或指令说明
Options-f指定compose文件的路径和名称
Options-p指定project名称
Commandsup创建并启动所有service容器
Commandsdown停止并移除所有容器、网络
Commandsps列出所有启动的容器
Commandslogs查看指定容器的日志
Commandsstop停止容器
Commandsstart启动容器
Commandsrestart重启容器
Commandstop查看运行的进程