后端 – chang的个人博客 https://www.qiqin-chang.cn Mon, 19 Jan 2026 23:45:57 +0000 zh-Hans hourly 1 https://wordpress.org/?v=6.9.4 https://www.qiqin-chang.cn/wp-content/uploads/2025/04/cropped-无背景-圆形-32x32.png 后端 – chang的个人博客 https://www.qiqin-chang.cn 32 32 功能演示 https://www.qiqin-chang.cn/demonstration/ https://www.qiqin-chang.cn/demonstration/#respond Mon, 19 Jan 2026 22:45:10 +0000 https://www.qiqin-chang.cn/?p=622 SpringBoot3+Vue3：

登录模块：

### 登录功能：

注册功能：

记住密码：

找回密码：

确认账户：

说明：第一次图片验证码用于人机验证

安全认证：

重置密码：

成功找回：

个人中心：

个人信息：

修改密码：

信息模块：

数据统计：

系统公告：

系统日志：

文章模块：

文章分类：

文章信息：

查看文章：

编辑文章：

文章前台：

阅读文章：

文章目录：

音乐模块：

音乐管理：

前台界面：

说明：基础播放按键+旋转唱片+歌词跳动

播放列表：

图片模块：

展示页面：

轮播图：

用户模块：

用户管理：

发送邮件：

导入导出：

说明：导入 点击导入选择文件就可以导入信息 导出 点击导出就能生成Excel文件

+SpringSecurity：

说明：本项目为个人SpringSecurity脚手架-权限管理系统

记住密码：本次项目中使用了cookie代替了session存储密码，并使用RSA非对称加密算法做了存储加密

账号登录：会使用pinia依次保存token，动态路由（由权限管理12级目录分配，为菜单管理的目录，菜单），动态权限（由权限管理3级目录分配，为菜单管理的按钮的权限标识），和个人信息；

安全退出：会清除登录时存储的四种信息，并清除Redis中的会话链token

会话个数控制：设置单一账号登录个数，登录设备数量超过预设数量，最早的设备会退出登录，通过Redis会话链实现

会话频率控制：使用Redis实现，目前设置同一用户每0.3秒才可请求一次，否则显示请求频率过快，不过可以使用Sentinel实现不再讨论

标签：通过路由守卫监听浏览器路由变化添加标签，首页被锁定添加（pinia实现）不能删除（路由守卫过滤）

数据库设计：数据库使用RBAC设计，用户-角色-权限分离

基础配置：

异常处理：设置全局异常处理器和自定义异常处理器，权限不足异常-由于自定义异常无法监听到Security中过滤器，所以要单独设置

JWT过滤器：白名单放行，检测token存在，token过期，token无效

JWT工具包：token生成 信息-用户名，id；加密-签名；过期判断-签发时间，过期时间；唯一性-uuid（保证每次签发的token都不同）

token解析 token存在判断（此时为静默处理） 验签 判断过期

跨域配置：CorsConfig自定义跨域配置

Redis序列化器：RedisConfig

WebConfig：图片存储路径映射

缓存管理：SpringCache

连接池：druid

security配置：

WebSecurityConfig额外：

实现跨域处理（这个是Security的跨域配置） 开启授权保护 关闭csrf攻击防御 限流过滤器（由token代替）JWT过滤器 登录配置

以下均通过WebSecurityConfig加入Security过滤链

密码加密：使用BCryptPasswordEncoder

用户信息管理：判断密码正确性，判断是否为封禁用户，封装用户权限

登录成功处理器：生成并返回token，进行用户Redis中token链的判断

登录失败处理器：返回失败信息

注销处理器：清除Redis中的token

以下已经由token代替：

拒绝访问处理器：由于权限不足产生，被全局异常处理器代替

认证异常处理器：未检测出认证信息，由于使用token代替认证信息，但token为无状态信息，此阶段无法被识别，故舍弃

会话处理器：可以控制会话个数和会话频率但token为无状态所以不会产生会话

配置：

环境：dev开发环境配置；preprod预生产环境配置

dockerfile：配置了dockerfile，并配置了一键部署

后台设计：

说明：动态路由+动态菜单+动态标签页（固定首页）+面包屑导航+导航收缩按键+头像下拉栏+安全退出

权限模块：

用户管理：

管理界面：

分配角色：

权限管理：

菜单管理：

个人中心：

基本资料：

修改密码：

]]> https://www.qiqin-chang.cn/demonstration/feed/ 0 MyBatis-持久层框架 https://www.qiqin-chang.cn/mybatis-%e6%8c%81%e4%b9%85%e5%b1%82%e6%a1%86%e6%9e%b6%ef%bc%9a/ https://www.qiqin-chang.cn/mybatis-%e6%8c%81%e4%b9%85%e5%b1%82%e6%a1%86%e6%9e%b6%ef%bc%9a/#respond Tue, 02 Sep 2025 13:47:51 +0000 http://www.qiqin-chang.cn/?p=559 官方网站：https://mybatis.org/mybatis-3/zh_CN/index.html

依赖：

<!-- MyBatis 持久层框架 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

配置：

## MyBatis配置与xml映射
mybatis:
  ## 映射xml
  mapper-locations: classpath:mapper/*.xml 
  configuration:
    ## 日志配置
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    ## 映射格式转换
    map-underscore-to-camel-case: true

自动映射：

Java：驼峰命名：departmentId

数据库：下划线：department_id

mapper包扫描：

启动类注解：

@MapperScan("com.chang.mapper")

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="对应mapper接口引用">
    
</mapper>

XML格式：

<select id="selectAll" resultType="com.chang.entity.Employee"> <!--id对应方法名 resultType：结果类型 对应实体类引用-->
    select * from employee
    <where>
        <if test="name!=null">name like concat('%',#{name},'%')</if>
    </where>
</select>
​
<insert id="insert" parameterType="com.chang.entity.Employee"> <!--parameterType：参数类型-->
    insert into `employee` (name,sex,no,age,description,department_id) <!--下划线命名法-->
    values (#{name},#{sex},#{no},#{age},#{description},#{departmentId}) <!--驼峰命名-->
</insert>

注解查询：

@Select("select * from employee where id = #{id}")
Employee selectById(Integer id);

代码模版：

Mapper:

package com.chang.mapper;
​
public interface EmployeeMapper {
}

Service:

package com.chang.service;
​
import org.springframework.stereotype.Service;
​
@Service
public class EmployeeService {
}

分页插件-分页查询：

依赖：

<!--PageHelper 分页插件-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.4.6</version>
    <exclusions>
       <exclusion>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
       </exclusion>
    </exclusions>
</dependency>

代码：

controller：

/**
 * 分页查询数据
 * pageNum: 当前页码
 * pageSize: 每页的个数
 */
@GetMapping("/selectPage")
public Result selectPage(@RequestParam(defaultValue = "1") Integer pageNum,
                         @RequestParam(defaultValue = "10") Integer pageSize){
    PageInfo<Employee> pageInfo = employeeService.selectPage(pageNum, pageSize);
    return Result.success(pageInfo);
}

service：

@Override
public PageInfo<Employee> selectPage(Integer pageNum, Integer pageSize) {
    PageHelper.startPage(pageNum, pageSize);
    List<Employee> list = employeeMapper.selectAll();
    return PageInfo.of(list) ;
}

CRUD：

Controller层：

package com.chang.controller;
​
import com.chang.common.Result;
import com.chang.entity.Employee;
import com.chang.service.EmployeeService;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
​
import java.util.List;
​
@RestController
@RequestMapping("/employee")
public class EmployeeController {
​
    @Autowired
    private EmployeeService employeeService;
​
    /**
     * 查询单个数据
     */
    @GetMapping("/selectById/{id}")
    public Result selectById(@PathVariable Integer id){
        Employee employee = employeeService.selectById(id);
        return Result.success(employee);
    }
​
    /**
     * 查询所有的数据
     */
    @GetMapping("/selectAll")
    public Result selectAll(){
        List<Employee> list = employeeService.selectAll();
        return Result.success(list);
    }
​
    /**
     * 分页查询数据
     * pageNum: 当前页码
     * pageSize: 每页的个数
     */
    @GetMapping("/selectPage")
    public Result selectPage(@RequestParam(defaultValue = "1") Integer pageNum,
                             @RequestParam(defaultValue = "10") Integer pageSize){
        PageInfo<Employee> pageInfo = employeeService.selectPage(pageNum, pageSize);
        return Result.success(pageInfo);
    }
​
    /**
     * 新增数据
     */
    @PostMapping("/add")
    public Result add(@RequestBody Employee employee){
        employeeService.add(employee);
        return Result.success();
    }
​
    /**
     * 跟新数据
     */
    @PutMapping("/update")
    public Result update(@RequestBody Employee employee){
        employeeService.update(employee);
        return Result.success();
    }
​
    /**
     * 删除单个数据
     */
    @DeleteMapping("/deleteById/{id}")
    public Result update(@PathVariable Integer id){
        employeeService.deleteById(id);
        return Result.success();
    }
}

ServiceImpl接口：

package com.chang.service.impl;
​
import com.chang.entity.Employee;
import com.github.pagehelper.PageInfo;
​
import java.util.List;
​
public interface EmployeeServiceImpl {
​
    Employee selectById(Integer id);
​
    List<Employee> selectAll();
​
    PageInfo<Employee> selectPage(Integer pageNum, Integer pageSize);
​
    void add(Employee employee);
​
    void update(Employee employee);
​
    void deleteById(Integer id);
}

Service层：

package com.chang.service;
​
import com.chang.entity.Employee;
import com.chang.mapper.EmployeeMapper;
import com.chang.service.impl.EmployeeServiceImpl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
​
import java.util.List;
​
@Service
public class EmployeeService implements EmployeeServiceImpl {
​
    @Autowired
    private EmployeeMapper employeeMapper;
​
    @Override
    public Employee selectById(Integer id) {
        return employeeMapper.selectById(id);
    }
​
    @Override
    public List<Employee> selectAll() {
        //额外业务操作
        return employeeMapper.selectAll();
    }
​
    @Override
    public PageInfo<Employee> selectPage(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<Employee> list = employeeMapper.selectAll();
        return PageInfo.of(list) ;
    }
​
    @Override
    public void add(Employee employee) {
        employeeMapper.insert(employee);
    }
​
    @Override
    public void update(Employee employee) {
        employeeMapper.updateById(employee);
    }
​
    @Override
    public void deleteById(Integer id) {
        employeeMapper.deleteById(id);
    }
​
}

Mapper层：

package com.chang.mapper;
​
import com.chang.entity.Employee;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Select;
​
import java.util.List;
​
public interface EmployeeMapper {
​
    List<Employee> selectAll();
​
    @Select("select * from `employee` where id = #{id}")
    Employee selectById(Integer id);
​
    void insert(Employee employee);
​
    void updateById(Employee employee);
​
    @Delete("delete from `employee` where id = #{id}")
    void deleteById(Integer id);
}

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="com.chang.mapper.EmployeeMapper">
​
    <select id="selectAll" resultType="com.chang.entity.Employee">
        select * from employee
    </select>
​
    <insert id="insert" parameterType="com.chang.entity.Employee">
        insert into `employee` (name,sex,no,age,description,department_id)
        values (#{name},#{sex},#{no},#{age},#{description},#{departmentId})
    </insert>
​
    <update id="updateById" parameterType="com.chang.entity.Employee">
        update `employee` set name = #{name},sex = #{sex},no=#{no},age=#{age},
        description=#{description},department_id=#{departmentId}
        where id=#{id}
    </update>
​
</mapper>
]]> https://www.qiqin-chang.cn/mybatis-%e6%8c%81%e4%b9%85%e5%b1%82%e6%a1%86%e6%9e%b6%ef%bc%9a/feed/ 0 Git-远程仓库 https://www.qiqin-chang.cn/git-%e8%bf%9c%e7%a8%8b%e4%bb%93%e5%ba%93/ https://www.qiqin-chang.cn/git-%e8%bf%9c%e7%a8%8b%e4%bb%93%e5%ba%93/#respond Thu, 10 Apr 2025 05:10:51 +0000 http://8.153.197.211/?p=170 下载安装：

官方网站：https://git-scm.com

下载地址：https://git-scm.com/download

本地克隆：

git clone 项目克隆地址

IDEA中Git克隆项目：

推送：

在导航栏点击VCS->创建Git仓库->选择项目根目录
​
在GitHub上创建仓库->复制仓库SSH路径->在idea中点击提交键输入要存入的Git仓库地址

返回顶部

]]> https://www.qiqin-chang.cn/git-%e8%bf%9c%e7%a8%8b%e4%bb%93%e5%ba%93/feed/ 0 Maven-依赖管理 https://www.qiqin-chang.cn/maven-%e4%be%9d%e8%b5%96%e7%ae%a1%e7%90%86/ https://www.qiqin-chang.cn/maven-%e4%be%9d%e8%b5%96%e7%ae%a1%e7%90%86/#respond Thu, 10 Apr 2025 05:09:27 +0000 http://8.153.197.211/?p=165 Maven下载安装：

官网：https://maven.apache.org

下载地址：https://maven.apache.org/download.cgi

安装方式：解压安装

Maven配置：

修改Maven安装目录->conf->settings.xml文件：

配置本地仓库：

  <!--本地仓库地址-->
  <localRepository>D:/maven/jarku</localRepository>

配置远程仓库：

<!--远程仓库地址-->
<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

在Maven同级目录下创建本地仓库文件夹：jarku

IDEA中Maven配置：

IDEA中编码配置：

返回顶部

]]> https://www.qiqin-chang.cn/maven-%e4%be%9d%e8%b5%96%e7%ae%a1%e7%90%86/feed/ 0 阿里云OSS-对象存储 https://www.qiqin-chang.cn/%e9%98%bf%e9%87%8c%e4%ba%91oss-%e5%af%b9%e8%b1%a1%e5%ad%98%e5%82%a8/ https://www.qiqin-chang.cn/%e9%98%bf%e9%87%8c%e4%ba%91oss-%e5%af%b9%e8%b1%a1%e5%ad%98%e5%82%a8/#respond Thu, 10 Apr 2025 04:31:29 +0000 http://8.153.197.211/?p=153 基本配置：

依赖：

<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.17.4</version>
</dependency>

Java 9及以上的版本，则需要添加以下JAXB相关依赖：

<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>
<!-- no more than 2.3.3-->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.3</version>
</dependency>

配置：

chang:
    alioss:
        endpoint: ${chang.alioss.endpoint}
        access-key-id: ${chang.alioss.access-key-id}
        access-key-secret: ${chang.alioss.access-key-secret}
        bucket-name: ${chang.alioss.bucket-name}

配置类：

/**
 * 配置类，用于创建AliOssUtil对象
 */
@Configuration
@Slf4j
public class OssConfiguration {
​
    @Bean
    @ConditionalOnMissingBean
    public AliOssUtil aliOssUtil(AliOssProperties aliOssProperties) {
        log.info("开始创建阿里云文件上传工具类对象：{}",aliOssProperties);
        return new AliOssUtil(
                aliOssProperties.getEndpoint(),
                aliOssProperties.getAccessKeyId(),
                aliOssProperties.getAccessKeySecret(),
                aliOssProperties.getBucketName());
    }
}

参数类：

@Component
@ConfigurationProperties(prefix = "chang.alioss")
@Data
public class AliOssProperties {
​
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
​
}

工具类：

@Data
@AllArgsConstructor
@Slf4j
public class AliOssUtil {
​
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
​
    /**
     * 文件上传
     *
     * @param bytes
     * @param objectName
     * @return
     */
    public String upload(byte[] bytes, String objectName) {
​
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
​
        try {
            // 创建PutObject请求。
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(bytes));
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
​
        //文件访问路径规则 https://BucketName.Endpoint/ObjectName
        StringBuilder stringBuilder = new StringBuilder("https://");
        stringBuilder
                .append(bucketName)
                .append(".")
                .append(endpoint)
                .append("/")
                .append(objectName);
​
        log.info("文件上传到:{}", stringBuilder.toString());
​
        return stringBuilder.toString();
    }
}

工具操作：

账号准备：

注册阿里云账户（注册完成后需要实名认证）

https://account.aliyun.com/login/login.htm?oauth_callback=https%3A%2F%2Fwww.aliyun.com%2F

注册完账号之后，就可以登录阿里云

开通OSS云服务：

通过控制台找到对象存储OSS服务：

选择要开通的服务：

如果是第一次访问，需开通对象存储服务OSS ：

开通OSS服务之后，就可以进入到阿里云对象存储的控制台:

点击左侧的 “Bucket列表”，创建一个Bucket

输入Bucket的相关信息

其他的信息，配置项使用默认的即可。

配置AccessKey:

创建AccessKey:

点击 “AccessKey管理”，进入到管理页面。

点击 “创建AccessKey”。

配置AccessKey:

以管理员身份打开CMD命令行，执行如下命令，配置系统的环境变量。

set OSS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
set OSS_ACCESS_KEY_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

注意：将上述的ACCESS_KEY_ID 与 ACCESS_KEY_SECRET 的值一定要替换成自己的 。

执行如下命令，让更改生效。

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

执行如下命令，验证环境变量是否生效。

echo %OSS_ACCESS_KEY_ID%
echo %OSS_ACCESS_KEY_SECRET%

返回顶部

]]> https://www.qiqin-chang.cn/%e9%98%bf%e9%87%8c%e4%ba%91oss-%e5%af%b9%e8%b1%a1%e5%ad%98%e5%82%a8/feed/ 0 WebSocket-全双工通信协议 https://www.qiqin-chang.cn/websocket-%e5%85%a8%e5%8f%8c%e5%b7%a5%e9%80%9a%e4%bf%a1%e5%8d%8f%e8%ae%ae/ https://www.qiqin-chang.cn/websocket-%e5%85%a8%e5%8f%8c%e5%b7%a5%e9%80%9a%e4%bf%a1%e5%8d%8f%e8%ae%ae/#respond Wed, 09 Apr 2025 12:30:19 +0000 http://8.153.197.211/?p=70 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

配置类：

/**
 * WebSocket配置类，用于注册WebSocket的Bean
 */
@Configuration
public class WebSocketConfiguration {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

websocket服务类：

/**
 * WebSocket服务
 */
@Component
@ServerEndpoint("/ws/{sid}")
public class WebSocketServer {
​
    //存放会话对象
    private static Map<String, Session> sessionMap = new HashMap();
​
    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("sid") String sid) {
        System.out.println("客户端：" + sid + "建立连接");
        sessionMap.put(sid, session);
    }
​
    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, @PathParam("sid") String sid) {
        System.out.println("收到来自客户端：" + sid + "的信息:" + message);
    }
​
    /**
     * 连接关闭调用的方法
     *
     * @param sid
     */
    @OnClose
    public void onClose(@PathParam("sid") String sid) {
        System.out.println("连接断开:" + sid);
        sessionMap.remove(sid);
    }
​
    /**
     * 群发
     *
     * @param message
     */
    public void sendToAllClient(String message) {
        Collection<Session> sessions = sessionMap.values();
        System.out.println("发送");
        for (Session session : sessions) {
            try {
                //服务器向客户端发送消息
                session.getBasicRemote().sendText(message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
​
}

返回顶部

]]> https://www.qiqin-chang.cn/websocket-%e5%85%a8%e5%8f%8c%e5%b7%a5%e9%80%9a%e4%bf%a1%e5%8d%8f%e8%ae%ae/feed/ 0 SpringTask-定时任务 https://www.qiqin-chang.cn/springtask-%e5%ae%9a%e6%97%b6%e4%bb%bb%e5%8a%a1/ https://www.qiqin-chang.cn/springtask-%e5%ae%9a%e6%97%b6%e4%bb%bb%e5%8a%a1/#respond Wed, 09 Apr 2025 12:29:21 +0000 http://8.153.197.211/?p=68 使用步骤：

  • 导入maven坐标：spring-context(已存在)
  • 启动类添加注解：@EnableScheduling //开启任务调度
  • 自定义定时任务类

与ServiceImpl层相似:

/**
 * 定时任务 
 */
@Scheduled(cron = "0/5 * * * * ?") //每隔5秒触发一次
public void execute() {
    log.info("定时任务开始执行：{}",new Date());
}

返回顶部

]]> https://www.qiqin-chang.cn/springtask-%e5%ae%9a%e6%97%b6%e4%bb%bb%e5%8a%a1/feed/ 0 JWT-令牌加密 https://www.qiqin-chang.cn/jwt-%e4%bb%a4%e7%89%8c%e5%8a%a0%e5%af%86/ https://www.qiqin-chang.cn/jwt-%e4%bb%a4%e7%89%8c%e5%8a%a0%e5%af%86/#respond Wed, 09 Apr 2025 12:28:17 +0000 http://8.153.197.211/?p=66 依赖： 
<!--JWT 令牌加密-->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>4.3.0</version>
</dependency>

工具包：

旧：

生成Token 获取用户信息：

package com.chang.utils;
​
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.chang.entity.Account;
import com.chang.service.impl.AdminServiceImpl;
import com.chang.service.impl.EmployeeServiceImpl;
import jakarta.annotation.PostConstruct;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
​
import java.util.Date;
​
@Component
public class TokenUtils {
​
    @Autowired
    AdminServiceImpl adminService;
    @Autowired
    EmployeeServiceImpl employeeService;
​
    static AdminServiceImpl staticAdminService;
    static EmployeeServiceImpl staticEmployeeService;
​
    //springboot工程启动后会加载这段代码
    @PostConstruct
    public void init(){
        staticAdminService = adminService;
        staticEmployeeService = employeeService;
    }
​
​
    /**
     * 生成token
     */
    public static String createToken(String data,String sign) {
        return JWT.create().withAudience(data) //将userId-role 保存到token里面，作为载荷
                .withExpiresAt(DateUtil.offsetDay(new Date(),1)) //1天后token过期
                .sign(Algorithm.HMAC256(sign)); //秘钥签名 以password 作为token的秘钥，HMAC256算法加密
    }
​
    /**
     * 获取当前登录用户信息
     */
    public static Account getCurrentUser() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token  = request.getHeader("token");
        if (StrUtil.isBlank(token)){
            token = request.getParameter("Token");
        }
        if (StrUtil.isBlank(token)){
            return null;
        }
        //拿到token的载荷数据
        String audience = JWT.decode(token).getAudience().get(0);
        String[] split = audience.split("-");
        String userId = split[0];
        String role = split[1];
        //根据token解析出来的userId去对应的表查询用户信息
        if ("ADMIN".equals(role)){
            return staticAdminService.selectById(Integer.valueOf(userId));
        } else if ("EMP".equals(role)) {
            return staticEmployeeService.selectById(Integer.valueOf(userId));
        }
​
        return null;
    }
}
​

Service层login方法中：

生成token并返回给前端：

String token = TokenUtils.createToken(dbAdmin.getId() + "-" + "ADMIN", dbAdmin.getPassword());
dbAdmin.setToken(token);

获取当前用户信息：

Account currentUser = TokenUtils.getCurrentUser();

新：

package com.chang.utils;
​
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.chang.entity.Account;
import com.chang.service.impl.AdminServiceImpl;
import com.chang.service.impl.EmployeeServiceImpl;
import com.chang.service.impl.UserServiceImpl;
import jakarta.annotation.PostConstruct;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
​
import java.util.Date;
​
@Component
public class JWTUtils {
​
    private static final String sign = "chang_2025";
​
    @Autowired
    AdminServiceImpl adminService;
    @Autowired
    EmployeeServiceImpl employeeService;
    @Autowired
    UserServiceImpl userService;
​
    static AdminServiceImpl staticAdminService;
    static EmployeeServiceImpl staticEmployeeService;
    static UserServiceImpl staticUserService;
​
    //springboot工程启动后会加载这段代码
    @PostConstruct
    public void init(){
        staticAdminService = adminService;
        staticEmployeeService = employeeService;
        staticUserService = userService;
    }
​
    /**
     * 生成 Token
     */
    public static String createToken(Integer id, String role) {
        return JWT.create()
                .withClaim("id", id)
                .withClaim("role", role)               // 角色
                .withExpiresAt(DateUtil.offsetDay(new Date(), 1)) // 1天后过期
                .sign(Algorithm.HMAC256(sign));
    }
​
    /**
     * 获取用户信息
     * @return
     */
    public static Account getCurrentUser() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("Token");
        if (StrUtil.isBlank(token)) {
            token = request.getParameter("Token");
        }
        if (StrUtil.isBlank(token)) {
            return null; //只能进行静默处理
        }
​
        try {
            // 1. 验签
            DecodedJWT decodedJWT = JWT.require(Algorithm.HMAC256(sign)).build().verify(token);
​
            // 2. 解析 payload
            Integer userId = decodedJWT.getClaim("id").asInt();
            String role = decodedJWT.getClaim("role").asString();
​
            // 根据角色查对应表
            if ("ADMIN".equals(role)) {
                return staticAdminService.selectById(userId); // 假设 username 是主键
            } else if ("EMP".equals(role)) {
                return staticEmployeeService.selectById(userId);
            } else if ("USER".equals(role)) {
                return staticUserService.selectById(userId);
            }
        } catch (Exception e) {
            return null;
        }
​
​
        return null;
    }
​
}

拦截器：

注册拦截器：

package com.chang.config;
​
import com.chang.interceptor.JWTInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
​
@Configuration
public class WebConfig implements WebMvcConfigurer {
​
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor()).addPathPatterns("/**").excludePathPatterns("/login","/register");
    }
    
    @Bean
    public JWTInterceptor jwtInterceptor() {
        return new JWTInterceptor();
    }
}

实现拦截器：

旧：

package com.chang.interceptor;
​
import cn.hutool.core.util.StrUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.chang.entity.Account;
import com.chang.exception.CustomException;
import com.chang.service.AdminService;
import com.chang.service.EmployeeService;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
​
@Component
public class JWTInterceptor implements HandlerInterceptor {
    
    @Autowired
    AdminService adminService;
    @Autowired
    EmployeeService employeeService;
​
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.从请求头中获取token
        String token = request.getHeader("Token");
        if (StrUtil.isEmpty(token)){
            //如果没拿到，从参数里再拿一次
            token = request.getParameter("Token");
        }
        //2.认证token
        if (StrUtil.isBlank(token)){
            throw new CustomException("401","您无权限操作");
        }
​
        Account account = null;
        try{
            //拿到token的载荷数据
            String audience = JWT.decode(token).getAudience().get(0);
            String[] split = audience.split("-");
            String userId = split[0];
            String role = split[1];
            //根据token解析出来的userId去对应的表查询用户信息
            if ("ADMIN".equals(role)){
                account = adminService.selectById(Integer.valueOf(userId));
            } else if ("EMP".equals(role)) {
                account = employeeService.selectById(Integer.valueOf(userId));
            }
        }catch (Exception e){
            throw new CustomException("401","您无权限操作");
        }
        if (account == null){
            throw new CustomException("401","您无权限操作");
        }
​
        //验证签名
        try {
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(account.getPassword())).build();
            jwtVerifier.verify(token);
        }catch (Exception e){
            throw new CustomException("401","您无权限操作");
        }
        
        return true;
    }
}

新：

package com.chang.interceptor;
​
import cn.hutool.core.util.StrUtil;
import com.chang.entity.Account;
import com.chang.exception.CustomException;
import com.chang.utils.TokenUtils;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
​
@Component
public class JWTInterceptor implements HandlerInterceptor {
​
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.从请求头中获取token
        String token = request.getHeader("Token");
        if (StrUtil.isEmpty(token)){
            //如果没拿到，从参数里再拿一次
            token = request.getParameter("Token");
        }
​
        //2.认证token
        if (StrUtil.isBlank(token)){
            throw new CustomException("401", "未检测到登录凭证，请先登录");
        }
​
        Account account = TokenUtils.getCurrentUser();
        if (account == null) {
            throw new CustomException("401", "Token无效或已过期，请重新登录");
        }
​
        return true;
    }
}

前端：

设置拦截器：

utils包：

request.js:

添加请求头 处理错误信息：

import axios from 'axios';
import {ElMessage} from 'element-plus';
import router from "@/router/index.js";
​
const request = axios.create({
    baseURL:'http://localhost:9090',
    timeout:30000, //后台接口超时时间
})
​
//request 拦截器
//可以自动请求发送前对请求做的一些处理
request.interceptors.request.use(
    config => {
        config.headers['Content-Type'] = 'application/json;charset=utf-8';
        let user = JSON.parse(localStorage.getItem('chang-user')||'{}');
        config.headers['token'] = user.token
        return config;
    },
    error => {
        return Promise.reject(error);
    }
)
​
//response 拦截器
//可以在接口响应后统一处理结果
request.interceptors.response.use(
    response => {
        let res = response.data;
        //兼容服务端返回的字符串数据
        if (typeof res === 'string') {
            res = res ? JSON.parse(res) : res;
        }
        if (res.code === '401') {
            ElMessage.error(res.msg);
            router.push('/login');
        }else{
            return res;
        }
        return res;
    },
    error => {
        if (error.response.status === 404) {
            ElMessage.error('未找到请求接口')
        }else if (error.response.status === 500) {
            ElMessage.error('系统异常，请查看后端控制台报错')
        }else {
            console.error(error.message);
        }
        return Promise.reject(error);
    }
)
​
export default request;

拼接Token令牌：

eg：更改导出数据代码:

user:JSON.parse(localStorage.getItem('chang-user')||'{}'),
​
//导出数据
const exportData=()=>{
  let url =  `http://localhost:9090/employee/export`
  + `?Token=${data.user.token}`;
  //导出数据 是通过流的形式下载 excel   打开流的连接，浏览器会自动帮我们下载文件
  window.open(url);
}
]]> https://www.qiqin-chang.cn/jwt-%e4%bb%a4%e7%89%8c%e5%8a%a0%e5%af%86/feed/ 0 Lombok-构建工具 https://www.qiqin-chang.cn/lombok-%e6%9e%84%e5%bb%ba%e5%b7%a5%e5%85%b7/ https://www.qiqin-chang.cn/lombok-%e6%9e%84%e5%bb%ba%e5%b7%a5%e5%85%b7/#respond Wed, 09 Apr 2025 12:25:21 +0000 http://8.153.197.211/?p=64 依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

使用方法：

注解添加位置说明
@Setter:注解在类/字段生成setter方法
@Getter:注解在类/字段生成getter方法
@ToString:注解在类生成toString方法
@EqualsAndHashCode:注解在类生成hashCode和equals方法
@NoArgsConstructor:注解在类生成无参构造方法
@RequireArgsConstructor:注解在类为需要特殊处理的字段生成构造方法（如final和被@NonNull注解的字段）
@Data:注解在类生成setter、getter、equals、canEqual、hashCode、toString方法。(final属性，不会生成setter方法)
@Slf4j:注解在类生成log日志
@Builder：注解在类链式构造Java类对象

返回顶部

]]> https://www.qiqin-chang.cn/lombok-%e6%9e%84%e5%bb%ba%e5%b7%a5%e5%85%b7/feed/ 0 Swagger-接口文档 https://www.qiqin-chang.cn/swagger-%e6%8e%a5%e5%8f%a3%e6%96%87%e6%a1%a3/ https://www.qiqin-chang.cn/swagger-%e6%8e%a5%e5%8f%a3%e6%96%87%e6%a1%a3/#respond Wed, 09 Apr 2025 12:24:24 +0000 http://8.153.197.211/?p=62 依赖：

<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
</dependency>

常用注解：

注解说明
@Api用在Controller类上
@ApiOperation用在Controller方法上
@ApiModel用在pojo类上
@ApiModelProperty用在pojo属性上

使用方法：

/**
 * 配置类，注册web层相关组件
 */
@Configuration
@Slf4j
public class WebMvcConfiguration extends WebMvcConfigurationSupport {

    /**
 	* 通过knife4j生成接口文档
 	* @return
 	*/
	@Bean
	public Docket docket() {
    	ApiInfo apiInfo = new ApiInfoBuilder()
            	.title("标题")
            	.version("2.0")
        	    .description("描述")
    	        .build();
   	 	Docket docket = new Docket(DocumentationType.SWAGGER_2)
        	    .apiInfo(apiInfo)
    	        .select()
	            //指定生成接口需要扫描的包
	            .apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
            	.paths(PathSelectors.any())
        	    .build();
    	return docket;
	}

	/**
 	* 设置静态资源映射
 	* @param registry
 	*/
	protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    	registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
    	registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
	}
}

返回顶部

]]> https://www.qiqin-chang.cn/swagger-%e6%8e%a5%e5%8f%a3%e6%96%87%e6%a1%a3/feed/ 0