跳到正文

发布于 2025年10月5日

javaweb+ai黑马课程总结 ​

最后更新于2025-10-05 22:07:23

前言 ​

今天正式完结这个课程的学习,跳过了其中的一些章节,总的来说通过这个课程还是学到了蛮多东西基础的curd最起码学会了

还是学的挺着急,主要是因为现在时间紧张,已经大三第一学期了技术还是这么拉跨,我放寒假还想着去投一下实习试试,而且在学习这个课程之前我在学习react框架,之前只会一个vue3局限性还是太大了,我觉得技术栈还是得拓的宽一些,也是在react课程中碰到了一些api接口的写法问题所以索性直接来学习下后端看看java后端到底长啥样子

前端api部分我不太会写,所以就想着熟悉一下这些基础的网络请求啥的于是就开始了javaweb之旅,我之前的javase也是看的b站的黑马程序员的课程,就是那个分为上下两部的课程,不过我并没有看完

这个课程是我很久之前看的,大一看过一点然后今年三月份接着看然后前半个月说是接着看,但是也没看多少,因为我看后面的什么stream流 IO流啥的我在JavaScript当中也接触过一些这些后面的异常线程什么的实际中也暂时用不到,所以我就选择直接来看这个javaweb+ai的课程

看完之后总觉得心里空落落的,想着还是写一下总结会让人感觉安心一些,然后我又在纠结是该写纸质的还是电子版的,刚好最近买了把新的键盘,那便写电子的吧

我的基础还是比较差劲的,水平也比较一般,并且我教育背景是双非非计算机科班专业,专业上跟各位科班出来的也有一定差距,理解不到位请各位轻喷

创建项目环境 ​

我的开发环境 ​

我这里用的是25版本的IDEA然后JDK版本用的17

新建项目 ​

这块就是idea里面的新建项目直接创建一个springboot项目,语言选择java类型选择maven然后记得把软件包的名称改成跟组的名称一样的,然后在下一步里面记得勾选

  • Lombok
  • Spring Web
  • Mybatis Framework
  • MySQL Driver

再然后就是删除多余的文件以及文件夹只剩下src以及pom.xml即可

pom.xml依赖 ​

除了上面的操作引入的依赖之外到后面还会陆陆续续引入别的

xml
<!-- 分页查询要用的 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>
<!-- 阿里云OSS存储依赖 -->
<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.17.4</version>
</dependency>
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.1</version>
</dependency>
<dependency>
    <groupId>javax.activation</groupId>
    <artifactId>activation</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.3</version>
</dependency>
<!-- apo切片编程依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- jwt登录令牌认证依赖 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

application.yml配置 ​

yaml
# 项目核心配置文件(YAML格式):包含应用标识、数据库连接、MyBatis框架、阿里云OSS存储配置
spring:
  application:
    # 配置Spring Boot应用名称:用于服务注册发现(如微服务场景)、日志/监控标识
    name: tlias-web-management
  datasource:
    # MySQL数据库连接地址:格式为jdbc:mysql://[IP]:[端口]/[数据库名],此处IP、端口、数据库名已脱敏
    url: jdbc:mysql://xxx.xxx.xxx.xxx:xxxx/xxxx
    # MySQL驱动类:com.mysql.cj.jdbc.Driver适配MySQL 8.0+版本(5.x版本驱动为com.mysql.jdbc.Driver)
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库访问用户名:已脱敏
    username: xxx
    # 数据库访问密码:已脱敏,生产环境建议加密存储
    password: xxx
mybatis:
  configuration:
    # MyBatis日志输出配置:将SQL语句、参数、结果集打印到控制台,用于开发阶段调试SQL
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 开启下划线命名与驼峰命名自动映射:解决MySQL字段(如user_name)与Java实体属性(如userName)的映射问题,无需手动配置resultMap
    map-underscore-to-camel-case: true

# 阿里云OSS(对象存储服务)配置:用于项目中图片、文档等静态资源的上传/下载/存储,关键信息已脱敏
aliyun:
  oss:
    # OSS服务访问域名(Endpoint):对应北京区域公网Endpoint格式,具体地址已脱敏
    endpoint: https://oss-cn-beijing.aliyuncs.com
    # OSS存储桶名称(Bucket):已脱敏,需在阿里云OSS控制台提前创建
    bucketName: xxx
    # OSS存储桶所在区域:cn-beijing表示北京区域,需与Endpoint区域一致,避免跨区域访问异常
    region: cn-beijing

这样相较于原本的application.properties文件写法更加简洁清晰

logback.xml ​

这个配置文件的命名一定要按照这个名字来因为约定如此并且不用作多余的操作就能生效,你只需要写好这份配置文件即可

这个配置文件的作用就是控制控制台的日志输出并把输出保存为log日志文件

还需要强调一个东西是@Slf4j这个注解是Lombok库中的东西并不是springboot里面的

xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- Logback日志框架配置文件:用于定义日志的输出方式、格式和存储策略 -->
<configuration>
    <!-- 1. 控制台日志输出器(命名为STDOUT) -->
    <!-- ConsoleAppender:Logback提供的控制台输出组件,负责将日志打印到控制台 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 编码器:定义日志输出的格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!-- 日志格式说明:
                 %d{yyyy-MM-dd HH:mm:ss.SSS}:日志产生的时间(精确到毫秒)
                 [%thread]:当前线程名称
                 %-5level:日志级别(左对齐,占5个字符宽度,如INFO、ERROR)
                 %logger{50}:日志所属的类/日志器名称(最多显示50个字符,超出省略)
                 %msg%n:日志具体内容 + 换行符 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 2. 文件滚动日志输出器(命名为FILE) -->
    <!-- RollingFileAppender:Logback提供的文件输出组件,支持日志文件自动拆分(滚动) -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 滚动策略:定义日志文件何时/如何拆分 -->
        <!-- SizeAndTimeBasedRollingPolicy:按时间+文件大小双重条件拆分日志 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 日志文件命名规则:
                 log/:日志文件存储的目录(项目根目录下的log文件夹)
                 %d{yyyy-MM-dd}:按日期分组(每天一个基础文件名)
                 %i:同一天内文件拆分的序号(从0开始,如log.2023-10-05.0.log、log.2023-10-05.1.log) -->
            <fileNamePattern>log/log.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>10MB</maxFileSize> <!-- 单个日志文件的最大容量,超过则自动创建新文件 -->
            <maxHistory>30</maxHistory>      <!-- 日志文件保留天数,超过30天的旧日志会自动删除 -->
            <totalSizeCap>1GB</totalSizeCap> <!-- 所有日志文件的总容量限制,超过1GB会删除最旧的日志 -->
        </rollingPolicy>

        <!-- 文件日志编码器:格式与控制台保持一致,便于前后端日志对照排查问题 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 3. 根日志器配置:控制整个项目的日志输出行为 -->
    <root level="INFO"> <!-- 全局日志级别:只输出INFO及以上级别日志(INFO/WARN/ERROR),忽略DEBUG/TRACE -->
        <appender-ref ref="STDOUT" /> <!-- 引用控制台输出器,日志同时输出到控制台 -->
        <appender-ref ref="FILE" />   <!-- 引用文件输出器,日志同时输出到文件 -->
    </root>
</configuration>

三层架构示例(src) ​

首先我也不是很清楚在这里这么说是否严谨,因为目前我对java后端理解尚浅,所以就在这里大概说一下流程

在这里的说明我们参考一下接口文档中的学员管理部分,链接我贴在下面了

pojo ​

这个目录中就是用来放一些实体类文件的

Result ​

这个是用来封装Controller层返回的结果

java
package xyz.cmcy.pojo;

import lombok.Data;

@Data
public class Result {
    private Integer code;
    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.code = 0;
        result.msg = msg;
        return result;
    }
}

PageResult ​

这个类是为了封装分页查询返回的结果

java
package xyz.cmcy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageResult<T> {
    private Long total;
    private List<T> rows;
}

Student ​

这是学员的类

java
package xyz.cmcy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.time.LocalDateTime;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private Integer id; //ID
    private String name; //姓名
    private String no; //序号
    private Integer gender; //性别 , 1: 男 , 2 : 女
    private String phone; //手机号
    private String idCard; //身份证号
    private Integer isCollege; //是否来自于院校, 1: 是, 0: 否
    private String address; //联系地址
    private Integer degree; //最高学历, 1: 初中, 2: 高中 , 3: 大专 , 4: 本科 , 5: 硕士 , 6: 博士
    private LocalDate graduationDate; //毕业时间
    private Integer clazzId; //班级ID
    private Short violationCount; //违纪次数
    private Short violationScore; //违纪扣分
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间

    private String clazzName;//班级名称
}

StudentQueryParam ​

这个主要是为了封装一下前端传递过来的get请求的参数

java
package xyz.cmcy.pojo;

import lombok.Data;

@Data
public class StudentQueryParam {
    private String name;
    private Integer degree;
    private Integer clazzId;
    private Integer page = 1;
    private Integer pageSize = 10;
}

Controller ​

Controller层就是在没有过滤器跟拦截器的情况下请求进来的第一层也是响应返回的最后一层我自认为我这里的代码写的还是比较规整的

java
package xyz.cmcy.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import xyz.cmcy.pojo.PageResult;
import xyz.cmcy.pojo.Result;
import xyz.cmcy.pojo.Student;
import xyz.cmcy.pojo.StudentQueryParam;
import xyz.cmcy.service.StudentService;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/students")
public class StudentController {
    @Autowired
    private StudentService studentService;

    @GetMapping
    public Result page(StudentQueryParam studentQueryParam){
        log.info("分页查询学生,参数:{}", studentQueryParam);
        PageResult<Student> pageResult = studentService.page(studentQueryParam);
        return Result.success(pageResult);
    }
    @DeleteMapping("/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        log.info("删除学生:{}", ids);
        studentService.delete(ids);
        return Result.success();
    }
    @PostMapping
    public Result save(@RequestBody Student student){
        log.info("保存学生:{}", student);
        studentService.save(student);
        return Result.success();
    }
    @GetMapping("/{id}")
    public Result getInfo(@PathVariable Integer id){
        log.info("查询学生:{}", id);
        Student student = studentService.getInfo(id);
        return Result.success(student);
    }
    @PutMapping
    public Result update(@RequestBody Student student){
        log.info("更新学生:{}", student);
        studentService.update(student);
        return Result.success();
    }
    @PutMapping("/violation/{id}/{score}")
    public Result updateScore(@PathVariable Integer id, @PathVariable Short score){
        log.info("违纪处理:{},{}", id, score);
        studentService.updateScore(id, score);
        return Result.success();
    }

}

Service ​

在Spring Boot中,Service层采用“接口(如StudentService)+实现类(如StudentServiceImpl)”的结构,是为了遵循面向接口编程思想,通过接口定义功能规范、实现类处理具体逻辑,从而降低代码耦合度;这种设计便于后续扩展(可新增实现类而不修改调用方),能更好地支持Spring的AOP等特性(依赖接口生成动态代理),同时使代码职责更清晰,利于团队协作和单元测试,是企业级开发中提升代码灵活性与可维护性的最佳实践。

StudentService ​

接口类

java
package xyz.cmcy.service;

import xyz.cmcy.pojo.PageResult;
import xyz.cmcy.pojo.Student;
import xyz.cmcy.pojo.StudentQueryParam;

import java.util.List;

public interface StudentService {
    PageResult<Student> page(StudentQueryParam studentQueryParam);

    void delete(List<Integer> ids);

    void save(Student student);

    Student getInfo(Integer id);

    void update(Student student);

    void updateScore(Integer id, Short score);
}

StudentServiceImpl ​

实现类

java
package xyz.cmcy.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import xyz.cmcy.mapper.StudentMapper;
import xyz.cmcy.pojo.PageResult;
import xyz.cmcy.pojo.Student;
import xyz.cmcy.pojo.StudentQueryParam;
import xyz.cmcy.service.StudentService;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentMapper studentMapper;

    @Override
    public PageResult<Student> page(StudentQueryParam studentQueryParam) {
        PageHelper.startPage(studentQueryParam.getPage(), studentQueryParam.getPageSize());
        List<Student> studentList = studentMapper.list(studentQueryParam);
        Page<Student> p = (Page<Student>) studentList;
        return new PageResult<Student>(p.getTotal(), p.getResult());
    }

    @Override
    public void delete(List<Integer> ids) {
        studentMapper.deleteByIds(ids);
    }

    @Override
    public void save(Student student) {
        student.setCreateTime(LocalDateTime.now());
        student.setUpdateTime(LocalDateTime.now());
        studentMapper.save(student);
    }

    @Override
    public Student getInfo(Integer id) {
        Student studentInfo = studentMapper.getInfo(id);
        return studentInfo;
    }

    @Override
    public void update(Student student) {
        student.setUpdateTime(LocalDateTime.now());
        studentMapper.updateById(student);
    }

    @Override
    public void updateScore(Integer id, Short score) {
        studentMapper.updateScore(id, score);
    }
}

Mapper ​

StudentMapper ​

java
package xyz.cmcy.mapper;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Options;
import xyz.cmcy.pojo.Student;
import xyz.cmcy.pojo.StudentQueryParam;

import java.util.List;
import java.util.Map;

@Mapper
public interface StudentMapper {
    List<Student> list(StudentQueryParam studentQueryParam);

    void deleteByIds(List<Integer> ids);

    @Options(useGeneratedKeys = true, keyProperty = "id")
    @Insert("insert into student(name, no, gender, phone, id_card, is_college, address, degree, graduation_date, clazz_id, create_time, update_time)\n" +
            "values (#{name},#{no},#{gender},#{phone},#{idCard},#{isCollege},#{address},#{degree},#{graduationDate},#{clazzId},#{createTime},#{updateTime})")
    void save(Student student);

    Student getInfo(Integer id);

    void updateById(Student student);

    void updateScore(Integer id, Short score);

    @MapKey("name")
    List<Map<String, Object>> getStudentDegreeData();
}

在该 StudentMapper 接口中,带有 @Insert 等注解的方法(如 save 方法)直接通过注解编写了 SQL 逻辑;而未被任何 MyBatis 注解(如 @Select、@Update、@Delete)修饰的方法(如 list、deleteByIds、getInfo、updateById、updateScore、getStudentDegreeData),其对应的 SQL 语句则需要在配套的 MyBatis XML 映射文件中进行配置和编写。

xyz.cmcy.mapper ​

这个包是在resources文件夹下面的

xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="xyz.cmcy.mapper.StudentMapper">
    <update id="updateById">
        update student set name = #{name},
        no = #{no},
        gender = #{gender},
        phone = #{phone},
        id_card = #{idCard},
        is_college = #{isCollege},
        address = #{address},
        degree = #{degree},
        graduation_date = #{graduationDate},
        clazz_id = #{clazzId},
        update_time = #{updateTime}
        where id = #{id}
    </update>
    <update id="updateScore">
        update student set violation_score = violation_score + #{score}
        where id = #{id}
    </update>
    <delete id="deleteByIds">
        delete from student where id in
        <foreach collection="ids" item="id" separator="," close=")" open="(">
            #{id}
        </foreach>
    </delete>
    <select id="list" resultType="xyz.cmcy.pojo.Student">
        select * from student s
        <where>
            <if test="name != null and name != ''">
                and s.name like concat('%',#{name},'%')
            </if>
            <if test="degree != null">
                and s.degree = #{degree}
            </if>
            <if test="clazzId != null">
                and s.clazz_id = #{clazzId}
            </if>
        </where>
        order by s.update_time desc
    </select>
    <select id="getInfo" resultType="xyz.cmcy.pojo.Student">
        select * from student where id = #{id}
    </select>
    <select id="getStudentDegreeData" resultType="java.util.Map">
        select (case
        when degree = 1 then '初中'
        when degree = 2 then '高中'
        when degree = 3 then '大专'
        when degree = 4 then '本科'
        when degree = 5 then '硕士'
        else '其他' end) name,
        count(*) value
        from student
        group by degree
        order by value
    </select>
</mapper>

阿里云OSS对象存储 ​

文件上传既然接触了一点那就在这里大概说一下吧

首先这个文件上传是放在src/utils/下面的

AliyunOSSProperties ​

这下属于是回旋镖了之前的application.yml文件里面定义的aliyun.oss中的属性在这里用到了这样有利于提高代码的可维护性

java
package xyz.cmcy.utils;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliyunOSSProperties {
    private String endpoint;
    private String bucketName;
    private String region;
}

AliyunOSSOpreator ​

java
package xyz.cmcy.utils;

import com.aliyun.oss.ClientBuilderConfiguration;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.common.comm.SignVersion;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.UUID;

@Component
public class AliyunOSSOperator {
    @Autowired
    private AliyunOSSProperties aliyunOSSProperties;

    public String upload(byte[] content, String originalFilename) throws Exception {
        String endpoint = aliyunOSSProperties.getEndpoint();
        String bucketName = aliyunOSSProperties.getBucketName();
        String region = aliyunOSSProperties.getRegion();

        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();

        String dir = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM"));

        String newFilename = UUID.randomUUID() + originalFilename.substring(originalFilename.lastIndexOf("."));
        String objectName = dir + "/" + newFilename;

        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content));
        } finally {
            ossClient.shutdown();
        }

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

其实这段代码也没啥好说的主要就是要用的时候上AliyunOSS上面看文档即可

需要注意的是文件上穿路径的处理以及对文件名的处理以及最终返回的url的处理

UploadController ​

java
package xyz.cmcy.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import xyz.cmcy.pojo.Result;
import xyz.cmcy.utils.AliyunOSSOperator;

import java.io.IOException;

@Slf4j
@RestController
public class UploadController {
    @Autowired
    private AliyunOSSOperator aliyunOSSOperator;

    @PostMapping("/upload")
    public Result upload(MultipartFile file) throws Exception {
        log.info("文件上传:{}", file.getOriginalFilename());
        String url = aliyunOSSOperator.upload(file.getBytes(), file.getOriginalFilename());
        log.info("文件上传OSS,URL:{}",url);
        return Result.success(url);
    }
}

不需要什么Service只需要调用一个阿里云对象存储工具类即可

不过这里也有一定局限性因为课程里面并没有把文件上上传跟用户关联起来,我想着是这里应该是在用户更新个人数据或者是新增用户的时候上传自己的头像的时候调用这个工具类并且最后把这个url保存到数据库里面前端想要看到直接调用即可

全局异常处理 ​

GlobalExceptionHandler ​

这个全局异常处理类能生效,核心是依靠@RestControllerAdvice和@ExceptionHandler注解的配合:@RestControllerAdvice将类声明为全局控制器增强器并使方法返回值自动转为JSON,@ExceptionHandler标记的方法则分别负责特定异常(如DuplicateKeyException)和所有未被专门处理的异常(Exception);当Controller抛出异常且未被本地捕获时,Spring会自动匹配并执行对应异常处理方法,实现全局统一的异常处理逻辑。

java
package xyz.cmcy.exception;

import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import xyz.cmcy.pojo.Result;

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler
    public Result handleException(Exception e){
        log.error("服务器异常:{}",e.getMessage());
        return Result.error("服务器异常");
    }

    @ExceptionHandler
    public Result handleDuplicateKeyException(DuplicateKeyException e){
        log.error("数据库异常:{}",e.getMessage());
        return Result.error("数据库异常");
    }
}

Jwt登录认证 + 请求拦截器 ​

Jwt登录认证 ​

JWT令牌由用英文句点(.)分隔的Header(头部)、Payload(载荷)、Signature(签名)三段信息组成:Header是经Base64Url编码的JSON对象,主要说明令牌类型为JWT以及所用的签名算法(比如HS256);Payload同样是经Base64Url编码的JSON对象,用来存放用户ID、过期时间等不涉及敏感信息的声明内容;Signature则是按照Header里指定的算法,把编码后的Header和Payload与密钥(或密钥对)结合加密生成的签名,目的是验证令牌有没有被篡改、是否真实有效,这三段内容共同构成了可用于数据传输的JWT字符串。

JwtUtils ​

java
package xyz.cmcy.pojo;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.Map;

/**
 * JWT令牌操作工具类
 */
public class JwtUtils {

    // 签名密钥,与测试类中保持一致
    private static final String SECRET_KEY = "Y2hpbWluZ2NoYW5neWlu";

    // 令牌过期时间:12小时(单位:毫秒)
    private static final long EXPIRATION_TIME = 12 * 3600 * 1000;

    /**
     * 生成JWT令牌
     * @param claims 要包含在令牌中的自定义数据
     * @return 生成的JWT令牌字符串
     */
    public static String generateToken(Map<String, Object> claims) {
        // 计算过期时间:当前时间 + 12小时
        Date expirationDate = new Date(System.currentTimeMillis() + EXPIRATION_TIME);

        // 构建并返回JWT令牌
        return Jwts.builder()
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)  // 使用HS256算法和指定密钥签名
                .addClaims(claims)  // 添加自定义数据
                .setExpiration(expirationDate)  // 设置过期时间
                .compact();  // 生成令牌字符串
    }

    /**
     * 解析JWT令牌
     * @param token 要解析的JWT令牌字符串
     * @return 令牌中包含的自定义数据(Claims对象)
     */
    public static Claims parseToken(String token) {
        // 解析令牌并返回其中的自定义数据
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)  // 指定签名密钥(必须与生成时使用的一致)
                .parseClaimsJws(token)  // 解析令牌
                .getBody();  // 获取包含自定义数据的Claims对象
    }
}

请求拦截器 ​

Filter差不多相当于全局的过滤任何请求都会被拦截,依赖Servlet容器

而后面说的Interceptor仅仅是会拦截Spring容器当中的内容

所以姑且可以理解为Filter包含Interceptor

TokenFilter ​

注意一下引入的新装饰器@WebFilter即可这里可以匹配拦截的路径这里的配置是一个全局的然后在下面排除登录或者是注册的路径

需要注意的是这个是通过Servlet 规范的机制生效的,跟Spring中的IOC容器没关系

核心是@WebFilter(urlPatterns = "/*")注解的作用:它声明该类是一个过滤器,并指定拦截所有请求(/*)

java
package xyz.cmcy.filter;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import xyz.cmcy.pojo.JwtUtils;

import java.io.IOException;

@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        //1.获取请求路径
        String requestURI = request.getRequestURI();
        //2.判断是否是登录请求,如果路径中包含 /login,说明是登录操作,放行
        if (requestURI.contains("/login")) {
            log.info("登录请求!放行!!!");
            filterChain.doFilter(request, response);
            return;
        }
        //3.获取请求头中的token
        String token = request.getHeader("token");
        //4.判断token是否存在,如果不存在,说明有就几乎没有登录,返回错误信息
        if (token == null || token.isEmpty()) {
            log.info("令牌为空响应,401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }
        //5.如果token存在,校验令牌,如果校验失败,返回错误信息
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            log.info("令牌非法,401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }
        //6.校验通过放行
        log.info("令牌合法,放行!!!");
        filterChain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

TokenInterceptor ​

java
package xyz.cmcy.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import xyz.cmcy.pojo.JwtUtils;

@Slf4j
@Component
public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        String requestURI = request.getRequestURI();
//        //2.判断是否是登录请求,如果路径中包含 /login,说明是登录操作,放行
//        if (requestURI.contains("/login")) {
//            log.info("登录请求!放行!!!");
//            return true;
//        }
        //3.获取请求头中的token
        String token = request.getHeader("token");
        //4.判断token是否存在,如果不存在,说明有就几乎没有登录,返回错误信息
        if (token == null || token.isEmpty()) {
            log.info("令牌为空响应,401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
        //5.如果token存在,校验令牌,如果校验失败,返回错误信息
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            log.info("令牌非法,401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
        //6.校验通过放行
        log.info("令牌合法,放行!!!");
        return true;
    }
}

WebConfig ​

这就是为什么上面的Interceptor拦截器注释掉了获取URI以及判断URI中是否包含登录或者是注册路径

就是因为在这里的

这个跟上面的不一样,这个是注册到Spring的IOC容器中的

被@Configuration标记的WebConfig类实现WebMvcConfigurer接口,在重写的addInterceptors方法中通过InterceptorRegistry注册TokenInterceptor,并配置拦截所有请求(排除登录接口);Spring 启动时加载该配置类,使拦截器按设定规则全局生效。

java
package xyz.cmcy.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import xyz.cmcy.interceptor.TokenInterceptor;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private TokenInterceptor tokenInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenInterceptor).addPathPatterns("/**").excludePathPatterns("/login");//拦截所有请求
    }
}

AOP ​

这块我没仔细看因为他这里又重新引入了一堆东西我懒得搞现在先有个概念能看懂等到后面的苍穹外卖里面再去深究一下

这个 AOP 切面无需手动注入就能使用,因为@Component注解已将RecordTimeAspect注册到 Spring IOC 容器,@Aspect又声明其为切面类并结合@Around定义了切入点(拦截DeptServiceImpl的所有方法)与增强逻辑;Spring 启动后会自动识别容器中的该切面并解析配置,当目标方法执行时,通过动态代理自动触发切面的增强逻辑,无需在其他类中显式注入切面即可生效。

java
@Component
@Aspect //当前类为切面类
@Slf4j
public class RecordTimeAspect {

    @Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();

        //执行原始方法
        Object result = pjp.proceed();

        //记录方法执行结束时间
        long end = System.currentTimeMillis();

        //计算方法执行耗时
        log.info("方法执行耗时: {}毫秒",end-begin);
        return result;
    }
}

最后想说的话 ​

不得不说Springboot还是提供了一整覆盖项目开发全流程的完整解决方案比之前的nestjs东拼西凑的强多了,果然后端还得是java

至于为什么我十天就能搞完是因为这个课程里面的

  • 所有前端部分
  • MySQL
  • Linux项目部署
  • Docker部署

我之前都学过

所以这个课程我会比别人少花一半的时间

然后就是希望接下来这一个月我能够继续坚持学习继续拓展我的技术栈