HongheFinance: 虹和财务系统是一款基于Saas的企业级财务管理系统，旨在为企业提供一站式的财务管理解决方案。项目涵盖了从用户注册登录、账户管理、权限控制到凭证处理、报表生成等全流程的财务管理功能。通过该项目，我们成功构建了一个稳定、高效、易用的财务管理平台，有效提升了企业财务管理的效率和准确性

# HongheFinance

#### 介绍
虹和财务系统是一款基于Saas的企业级财务管理系统，旨在为企业提供一站式的财务管理解决方案。项目涵盖了从用户注册登录、账户管理、权限控制到凭证处理、报表生成等全流程的财务管理功能。通过该项目，我们成功构建了一个稳定、高效、易用的财务管理平台，有效提升了企业财务管理的效率和准确性

#### 软件架构
软件架构说明

#### 安装教程

1.  xxxx
2.  xxxx
3.  xxxx

#### 使用说明

1.  xxxx
2.  xxxx
3.  xxxx

#### 参与贡献

1.  Fork 本仓库
2.  新建 Feat_xxx 分支
3.  提交代码
4.  新建 Pull Request

#### 特技

1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)

# 登录注册模块

## 接口设计

-   获取客户端id接口：用于标识客户端的身份（未登录前）
-   获取图形验证码：用于获取短信验证码，用户密码登录时的校验
-   获取短信验证码接口：用于短信登录
    -   调用该接口时需要校验图形验证码，防止恶意刷接口
-   手机密码注册接口：通过手机号、密码注册用户
    -   调用该接口之前需要校验图形验证码以获取短信验证码
-   手机密码登录接口：使用手机号、密码进行登录
-   手机短信登录接口
    -   调用该接口之前需要校验图形验证码以获取短信验证码
-   生成微信公众号二维码：用于关注注册用户
    -   调用微信接口，生成公众号二维码
-   接收微信公众号推送事件：扫码之后，微信公众号会推送关注成功事件，该事件会调用我们的接口，调用我们的接口会自动注册登录
-   获取客户端token接口（**轮询接口**）：监听微信扫码登录自动生成的token，用于扫码成功之后自动登录后台
    -   该接口由前端驱动，轮询该接口，如果获取到了token，则登录成功

-   获取当前登录用户信息接口：用户登录成功后返回基本的用户信息（如用户昵称、头像等）

## 游客身份接口（获取ClientId接口）

[**feat: 获取客户端id接口(用于标识客户端的身份（未登录前）**](https://gitee.com/ninghongkang/honghe-finance/commit/c36567e4c845fcf71ce485d39d11f30b1e8a2f3d)

## 获取图形验证码接口

功能需求：

-   随机生成6位字符（我们这里直接使用hutool工具包）
-   将字符生成base64位格式的图片，返回给前端
-   将生成的字符存储到redis中，用匿名身份id（clientId）作为key的一部分，验证码作为value。

[**feat: 获取图形验证码**](https://gitee.com/ninghongkang/honghe-finance/commit/6347b61a079d2bc770b7f39cc64a3554958d5146)

[**feat: 图形验证码缓存到redis**](https://gitee.com/ninghongkang/honghe-finance/commit/ce064f825bc7d50efd8f5e24c637d107d4258c2f)

[**feat: 修改图形验证码redis key前缀**](https://gitee.com/ninghongkang/honghe-finance/commit/ce6585447dd63060686c2b77f96a9f1c6e1a0e0b)

[**fix: 修复获取图形验证码——redis图形验证码不及时更新导致校验失败**](https://gitee.com/ninghongkang/honghe-finance/commit/4d1b68ce478e82a33b401b023323de6d958f9185)

## 获取短信验证码接口

功能需求：

-   随机生成6位短信验证码

-   发送短信验证码之前需要校验图形验证码是否正确（防止恶意调用短信接口）
-   一个手机号，60秒内只能调用一次接口
    -   前端通过将按钮设置不可用，后端仍需要校验

-   可以发送登录短信验证码和注册短信验证码
-   短信验证码有效期15分钟
-   发送短信验证码到手机号

[**feat: 获取短信验证码**](https://gitee.com/ninghongkang/honghe-finance/commit/853f73602533717c9dfda6966c16ddfe085ba206)

[**fix: 修改获取短信验证码DTO类名**](https://gitee.com/ninghongkang/honghe-finance/commit/7a58ae5d581a7271d9f16420df0eaf0a3532dec3)

## 手机号注册接口

前提：

-   图形验证码接口（获取图形验证码）
-   短信验证码接口（获取短信验证码，且图形验证码校验通过才有资格获取短信验证码）

功能需求：

-   后端参数格式校验：手机、密码、短信验证码
-   无论短信验证码校验成功与否，必须清除验证码，防止暴力破解（验证码只用一次）
    -   补充，也可以不删除短信验证码，每次提交重新输入图形验证码（具体需求具体分析）
-   校验手机号是否已注册（注意：防止并发操作）
    -   方案一：数据库字段使用唯一索引（让db兜底，简单）
    -   方案二：使用分布式锁(我们这个接口使用这种方案)
-   插入数据（注意：开启事务）**使用编程式事务合理控制事务的粒度**
    -   租户表
    -   会员表
    -   会员绑定手机表

功能流程：

-   校验手机号、密码、短信验证码等格式校验
-   校验两次输入的密码是否一致，不一致抛出异常
-   校验短信验证码并清除验证码缓存
-   校验是否通过
    -   是：校验手机号是否已注册
        -   是：结束
        -   否：插入租户表，返回id；插入会员表，返回id；插入会员绑定手机表（开启事务）
    -   否：结束

[**feat: 手机号注册接口**](https://gitee.com/ninghongkang/honghe-finance/commit/9afe40f4706a1d861ca6df8c00c31089e8a6b909)

[**feat: 整合security的passwordEncoder能力完成密码加密**](https://gitee.com/ninghongkang/honghe-finance/commit/7ec0bea6f7612337fcac038878772e5a5ea9bcb7)

## 手机密码登录接口

前提：

-   图形验证码接口（获取图形验证码）

功能需求：

-   后端参数格式校验：手机、密码
-   无论图形验证码校验成功与否，必须清除验证码，防止暴力破解（图形验证码只用一次）
-   校验手机和密码是否匹配
-   校验通过之后生成token，并将用户的id，租户id，角色信息存入redis缓存中，方便后面使用

功能流程：

-   校验手机号、密码、图形验证码等格式校验
-   图形验证码校验是否通过
    -   是：校验手机号和密码是否匹配
        -   是：生成token，并将用户的id，租户id，角色信息存入redis缓存中
        -   否：结束
    -   否：结束

[**feat: 手机号密码登录接口**](https://gitee.com/ninghongkang/honghe-finance/commit/aab908dbd8fd4424899342903019cd1731853b66)

[**feat: 手机号密码登录——利用security passwordEncoder完成密码匹配**](https://gitee.com/ninghongkang/honghe-finance/commit/de183d1873930f8adef94b7001ab91e2f82d1749)

## 手机短信验证码登录接口（todo：优化为注册用户自动注册）

前提：

-   图形验证码接口（获取图形验证码）

功能需求：

-   后端参数格式校验：手机号、短信验证码
-   无论短信验证码校验成功与否，必须清除验证码，防止暴力破解（短信验证码只用一次）
-   校验手机和密码是否匹配
-   校验通过之后生成token，并将用户的id，租户id，角色信息存入redis缓存中，方便后面使用

功能流程：

-   校验图形验证码是否通过（只要校验就会清除图形验证码）
    -   否：结束
    -   是：发送短信验证码，并存入redis
    -   说明：这一步由前端来驱动，只要图形验证码校验通过，才会调用获取短信验证码接口
-   校验短信验证码是否通过（只要校验就会清除短信验证码）
    -   是：判断当前手机号是否已注册
        -   是：生成token，并将用户的id，租户id，角色信息存入redis缓存中
        -   否：结束
    -   否：结束

[**feat: 手机短信验证码登录接口**](https://gitee.com/ninghongkang/honghe-finance/commit/55b66b068b6dc504d67aefe0a2ffcbdf35cfe3b4)

# 微信扫码登录

**接口分析**

-   获取公众号token接口
    -   参考：https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_access_token.html
-   生成（获取）公众号二维码接口
    -   参考：https://developers.weixin.qq.com/doc/offiaccount/Account_Management/Generating_a_Parametric_QR_Code.html
-   微信回调接口（用户扫描后触发）
    -   微信接收到扫码成功事件，主动回调我们的接口，并自动注册登录
    -   参考：https://developers.weixin.qq.com/doc/offiaccount/Account_Management/Generating_a_Parametric_QR_Code.html
-   轮询自动登录接口
    -   校验token是否生成，如果生成成功则登录成功

## 开发前提

首先肯定是需要阅读 [接入指南](https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Access_Overview.html)

### 基本配置信息获取

-   获取公众号的开发者ID（AppID）
-   获取开发者密码(AppSecret)
-   获取设置IP白名单

### 配置微信公众号基础信息类

```java
package com.clear.honghefinance.wechat.config.wechat;

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

@Component
@ConfigurationProperties(prefix = "wechat")
@Getter
@Setter
public class WechatConfig {

/**
     * 公众号配置
     */
    private WechatDetailConfig mp;

/**
     * 小程序配置
     */
    private WechatDetailConfig miniApp;
}
```

```java
package com.clear.honghefinance.wechat.config.wechat;

@Getter
@Setter
public class WechatDetailConfig {

/**
     * appid
     */
    private String appId;

/**
     * 秘钥
     */
    private String secret;

/**
     * 二维码过期时间
     * 默认15分钟
     */
    private Integer codeExpire = 900;

/**
     * token
     */
    private String token;

/**
     * 消息加密密钥
     */
    private String encodingAESKey;
}
```

在honghe-finance-admin模块的application.yml中配置

```yaml
# 微信
wechat:
  mp:
    appid: wx347b3b2a761d0276
    secret: 0e343167061e90b955888f9a4aff9fe9
    codeExpire: 3600
    # 这个token是用于接入微信微服务，可任意
    token: 504e3c5d01fd4e4b828acfe47c7137d9
    encodingAESKey:
```

### 配置微信接口地址常量类

```java
package com.clear.honghefinance.wechat.constant;

public class WechatApiConstant {

/**
     * 获取微信token
     * https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET
     */
    public static final String ACCESS_TOKEN_API = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s";

/**
     * 生成临时公众号二维码
     * 文档地址：https://developers.weixin.qq.com/doc/offiaccount/Account_Management/Generating_a_Parametric_QR_Code.html
     */
    public static final String MP_QRCODE_CREATE = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=%s";

/**
     * 通过ticket换取二维码 GET请求地址
     */
    public static final String MP_QRCODE_URL = "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=%s";

}
```

## 获取微信公众号token接口

由于获取公众号二维码接口时需要使用token，所以需要先获取token

参考文档：[【获取 Access token】](https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_access_token.html)

阅读文档后总结，获取 Access token：

-   接口的https请求方式: GET https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET

-   入参

| 参数       | 是否必须 | 说明                                  |
| :--------- | :------- | :------------------------------------ |
| grant_type | 是       | 获取access_token填写client_credential |
| appid      | 是       | 第三方用户唯一凭证                    |
| secret     | 是       | 第三方用户唯一凭证密钥，即appsecret   |

-   返回结果

-   正常情况

```json
        {"access_token":"ACCESS_TOKEN","expires_in":7200}
        
        // access_token 获取到的凭证
        // expires_in 凭证有效时间，单位：秒
        ```

-   错误情况

```json
        {"errcode":40013,"errmsg":"invalid appid"}
        // errcode 返回码
        // errmag 错误信息
        ```

### 封装获取微信公众号token接口返回VO

```java
package com.clear.honghefinance.wechat.dto.resp;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

/**
 * 
 * 获取access token VO
 * 
 */
@Getter
@Setter
public class AccessTokenVO implements Serializable {

/**
     * 获取到的凭证
     */
    @JsonProperty(value = "access_token", required = true)  // jackson处理JSON数据与实体类字段不一致
    // @SerializedName("access_token")  // gson处理JSON数据与实体类字段不一致
    private String accessToken;

/**
     * 凭证有效时间，单位：秒
     * 官网描述:目前是7200秒之内的值
     */
    @JsonProperty(value = "expires_in", required = true)
    private Integer expiresIn;

/**
     * 错误码  请求成功0
     */
    @JsonProperty(value = "errcode", required = true)
    private String errCode;

/**
     * 错误信息
     */
    @JsonProperty(value = "errmsg", required = true)
    private String errMsg;
}
```

因为微信服务器端返回给我们的json对象中的属性与Java中驼峰命名规范不一致，因此引入了jackson来处理JSON数据与实体类字段不一致

在honghe-finance-wechat模块引入如下依赖

```xml
<dependency>
 <groupId>com.fasterxml.jackson.dataformat</groupId>
 <artifactId>jackson-dataformat-xml</artifactId>
</dependency>
```

### service编写

```java
package com.clear.honghefinance.wechat.service;

import com.clear.honghefinance.wechat.dto.resp.AccessTokenVO;

public interface WechatService {

/**
     * 获取微信公众号Access Token
     *
     * @param appId  appid 第三方用户唯一凭证
     * @param secret secret 第三方用户唯一凭证密钥，即appsecret
     * @return 微信公众号token
     */
    AccessTokenVO getMpAccessToken(String appId, String secret);
}
```

```java
package com.clear.honghefinance.wechat.service.impl;

import com.clear.honghefinance.wechat.constant.WechatApiConstant;
import com.clear.honghefinance.wechat.dto.resp.AccessTokenVO;
import com.clear.honghefinance.wechat.service.WechatService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

import javax.annotation.Resource;

@Service
@Slf4j
public class WechatServiceImpl implements WechatService {

@Resource
    private WebClient webClient;

/**
     * 接口重试次数
     */
    int retry = 3;

/**
     * 获取微信公众号Access Token
     * 根据appId和secret获取微信公众号的Access Token
     *
     * @param appId  appid 第三方用户唯一凭证
     * @param secret secret 第三方用户唯一凭证密钥，即appsecret
     * @return 微信公众号token
     */
    @Override
    public AccessTokenVO getMpAccessToken(String appId, String secret) {
        // 根据appId和secret构造请求URL
        final String url = String.format(WechatApiConstant.ACCESS_TOKEN_API, appId, secret);
        // 使用webClient发送GET请求，获取Access Token信息
        return webClient.get().uri(url).retrieve().bodyToMono(AccessTokenVO.class)
                // 根据配置的重试策略进行重试
                .retry(retry)
                // 阻塞等待结果
                .block();
    }

}
```

### WebClient配置

在获取微信公众号token的service中，我们使用的是WebClient发送请求，因此需要配置WebClient

1、在honghe-finance-wechat模块引入如下依赖

```xml
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
```

2、配置WebClient配置类

```java
package com.clear.honghefinance.wechat.config.webClient;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;

@Configuration
@Slf4j
public class WebClientDefaultConfig {

@Bean
    public WebClient webClient() {
        log.info("WebClientDefaultConfig init start ...");
        HttpClient httpClient = HttpClient.create();

WebClient webClient = WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(httpClient))
            .build();
        log.info("WebClientDefaultConfig init end");
        return webClient;
    }
}
```

### 编写测试

在honghe-finance-wechat模块引入如下依赖

```xml
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
</dependency>
```

```java
package com.clear.honghefinance.wechat;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WechatApplication {
    public static void main(String[] args) {
        SpringApplication.run(WechatApplication.class);
    }
}
```

```java
package com.clear.honghefinance.wechat.service;

import com.clear.honghefinance.wechat.dto.resp.AccessTokenVO;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class WechatTest {

@Resource
    private WechatService wechatService;

/**
     * 测试获取公众号token
     *
     * @return
     */
    @Test
    public void getMpAccessToken() throws JsonProcessingException {

// 微信测试号：https://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo?action=showinfo&t=sandbox/index
        AccessTokenVO accessTokenVO = wechatService.getMpAccessToken("wx347b3b2a761d0276", "0e343167061e90b955888f9a4aff9fe9");

ObjectMapper objectMapper = new ObjectMapper();
        System.out.println(objectMapper.writeValueAsString(accessTokenVO));
    }
}
```

结果如下：

```java
{"access_token":"83_iuESdxA8_raVylhJEn1_eaPxIWBUf8d7YZnisaFjdNcerVPRvaawgHzqgoLuAyVsW8cWDPatKsayNEHri5QGHKtYjpLsE9xdbZZBJv4j6jDe7eZroVXBmyThobwSBYbAAAFOL","expires_in":7200,"errcode":null,"errmsg":null}
```

[**feat: 微信登录——获取微信公众号token接口**](https://gitee.com/ninghongkang/honghe-finance/commit/8475351ee5f290134ace977df16766c29a1393f5)

[**reactor fix: 改造从缓存中获取公众号token方法（兜底方案：如果缓存为空，意味着xxl-job定时任务可能执行出现问题，手动去拿token）**](https://gitee.com/ninghongkang/honghe-finance/commit/38afb3c235151b97c88fc3126e1cfa2b39fd63d1)

[**fix: 修复缓存到redis的公众号token不过期导致42001（表明访问令牌（access_token）已经过期）报错**](https://gitee.com/ninghongkang/honghe-finance/commit/e3f320d89fc10fa7a76e5e13196486f153c975c6https://gitee.com/ninghongkang/honghe-finance/commit/e3f320d89fc10fa7a76e5e13196486f153c975c6)

## 生成微信公众号二维码接口（临时二维码）

用户扫描二维码后，公众号可以接收到事件推送。

参考文档：[【账号管理——生成带参数的二维码】](https://developers.weixin.qq.com/doc/offiaccount/Account_Management/Generating_a_Parametric_QR_Code.html)

阅读文档后总结，生成带参数的二维码：

-   目前有2种类型的二维码：
    -   临时二维码，最多可以设置30天（即2592000秒）后过期
        -   能够生成较多数量
        -   主要用于账号绑定等不要求二维码永久保存的业务场景 
    -   永久二维码，无过期时间
        -   生成的数量有限（目前是最多10万个）
        -   主要用于适用于账号绑定、用户来源统计等场景

-   用户扫描带场景值二维码时，可能推送以下两种事件：

-   如果用户未关注公众号，则用户可以关注公众号，关注后微信会将带场景值关注事件推送给开发者
    -   如果用户已经关注公众号，扫描后会自动进入会话，微信也会将带场景值扫描事件推送给开发者

-   获取带参数二维码的过程

-   首先，创建二维码ticket
    -   然后凭借ticket到指定URL换取二维码

-   **创建二维码ticket**

每次创建二维码ticket需要提供一个开发者自行设定的参数（scene_id），分别介绍临时二维码和永久二维码的创建二维码ticket过程。

-   **临时二维码请求说明**

```json
POST https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=TOKEN 
{
    "expire_seconds": 604800, // 该二维码有效时间，秒为单位。最大不超过2592000（即30天），默认60s
    "action_name": "QR_SCENE", // 二维码类型，QR_SCENE为临时的整型参数值，QR_STR_SCENE为临时的字符串参数值，QR_LIMIT_SCENE为永久的整型参数值，QR_LIMIT_STR_SCENE为永久的字符串参数值
    "action_info": { // 二维码详细信息
        "scene": {
            "scene_id": 123 // 场景值ID，临时二维码时为32位非0整型，永久二维码时最大值为100000（目前参数只支持1--100000）
        }
    }
}

// 创建字符串形式的二维码参数
{
    "expire_seconds": 604800,
    "action_name": "QR_STR_SCENE",
    "action_info": {
        "scene": {
            "scene_str": "test" // 场景值ID（字符串形式的ID），字符串类型，长度限制为1到64
        }
    }
}
```

-   **永久二维码请求说明**

```json
POST https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=TOKEN
{
    "action_name": "QR_LIMIT_SCENE",
    "action_info": {
        "scene": {
            "scene_id": 123
        }
    }
}

// 创建字符串形式的二维码参数
{
    "action_name": "QR_LIMIT_STR_SCENE",
    "action_info": {
        "scene": {
            "scene_str": "test"
        }
    }
}
```

-   返回结果说明

```json
{
  "ticket":"gQH47joAAAAAAAAAASxodHRwOi8vd2VpeGluLnFxLmNvbS9xL2taZ2Z3TVRtNzJXV1Brb3ZhYmJJAAIEZ23sUwMEmm3sUw==", // 获取的二维码ticket，凭借此ticket可以在有效时间内换取二维码
   "expire_seconds":60, // 该二维码有效时间，以秒为单位。 最大不超过2592000（即30天）
   "url":"http://weixin.qq.com/q/kZgfwMTm72WWPkovabbI"  // 二维码图片解析后的地址，开发者可根据该地址自行生成需要的二维码图片
}
```

-   **通过ticket换取二维码**

获取二维码ticket后，开发者可用ticket换取二维码图片。请注意，本接口无须登录态即可调用。

1、**请求说明**

```json
GET https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=TICKET

// 提醒：TICKET记得进行UrlEncode
```

2、**返回说明**

ticket正确情况下，http 返回码是200，是一张图片，可以直接展示或者下载

HTTP头（示例）如下：

```
Accept-Ranges:bytes
Cache-control:max-age=604800
Connection:keep-alive 
Content-Length:28026 
Content-Type:image/jpg 
Date:Wed, 16 Oct 2013 06:37:10 GMT Expires:Wed, 23 Oct 2013 14:37:10 +0800 Server:nginx/1.4.1
```

错误情况下（如ticket非法）返回HTTP错误码404。

### DTO、VO

```java
package com.clear.honghefinance.biz.dto.req;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;

/**
 * 
 * 生成微信公众号二维码DTO
 * 
 */
@Getter
@Setter
public class GenerateMpRegCodeDTO {

/**
     * 客户端id：此处用作标识，标记生成的二维码供谁使用
     */
    @NotBlank(message = "客户端id不能为空")
    @Pattern(regexp = "^[0-9A-Za-z]{6,32}$", message = "clientId非法")
    private String clientId;
}
```

```java
package com.clear.honghefinance.biz.dto.resp;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

/**
 * 
 * 生成微信公众号二维码VO
 * 
 */
@Getter
@Setter
public class GenerateMpRegCodeVO implements Serializable {

/**
     * 获取的二维码ticket，凭借此 ticket 可以在有效时间内换取二维码。
     */
    private String ticket;

/**
     * expire_seconds 该二维码有效时间，秒为单位。最大不超过2592000（即30天），默认60s
     */
    private Integer expireSeconds;

/**
     * 二维码图片解析后的地址，开发者可根据该地址自行生成需要的二维码图片
     */
    private String url;

/**
     * 二维码地址：通过ticket换取的二维码地址
     */
    private String qrCodeUrl;

}
```

### Controller

```java
package com.clear.honghefinance.admin.controller;

import com.clear.honghefinance.biz.modules.system.member.domain.dto.GenerateMpRegCodeDTO;
import com.clear.honghefinance.biz.modules.system.member.domain.dto.PhoneRegisterDTO;
import com.clear.honghefinance.biz.modules.system.member.domain.vo.GenerateMpRegCodeVO;
import com.clear.honghefinance.biz.modules.system.member.service.IMemberRegisterService;
import com.clear.honghefinance.common.dto.entity.ApiResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 
 * 注册controller
 * 
 *
 * @author 程序员clear
 */
@RestController
@RequestMapping("/reg")
@Slf4j
public class RegisterController {
 
	// 省略其他。。。

/**
 * 生成微信公众号二维码（关注微信公众号注册）
 *
 * @param dto req
 * @return 生成微信公众号二维码，供指定clientId使用
 */
 @GetMapping(value = "/generateMpRegCode")
 public ApiResponse<GenerateMpRegCodeVO> generateMpRegCode(@Validated @ModelAttribute GenerateMpRegCodeDTO dto) {
 GenerateMpRegCodeVO result = memberRegisterService.generateMpRegCode(dto.getClientId());
 return ApiResponse.success(result);
 }
}
```

### biz service

```java
package com.clear.honghefinance.biz.service;

import com.clear.honghefinance.biz.modules.system.member.domain.dto.PhoneRegisterDTO;
import com.clear.honghefinance.biz.modules.system.member.domain.vo.GenerateMpRegCodeVO;

public interface IMemberRegisterService {

// 省略其他。。。

/**
     * 生成微信公众号二维码（关注微信公众号注册）
     * @param clientId
     * @return
     */
    GenerateMpRegCodeVO generateMpRegCode(String clientId);
}
```

```java
package com.clear.honghefinance.biz.service.impl;

import com.clear.honghefinance.biz.constant.RedisKeyConstant;
import com.clear.honghefinance.biz.modules.system.member.converter.ObjectConvertor;
import com.clear.honghefinance.biz.modules.system.member.domain.entity.MemberBindPhone;
import com.clear.honghefinance.biz.modules.system.member.domain.dto.PhoneRegisterDTO;
import com.clear.honghefinance.biz.modules.system.member.domain.vo.GenerateMpRegCodeVO;
import com.clear.honghefinance.biz.modules.system.member.enums.SmsCodeTypeEnum;
import com.clear.honghefinance.biz.service.*;
import com.clear.honghefinance.common.exception.BizException;
import com.clear.honghefinance.common.exception.ParameterException;
import com.clear.honghefinance.common.util.redis.RedisUtil;
import com.clear.honghefinance.wechat.config.wechat.WechatConfig;
import com.clear.honghefinance.wechat.dto.req.GenerateMpQrcodeDTO;
import com.clear.honghefinance.wechat.dto.resp.AccessTokenVO;
import com.clear.honghefinance.wechat.dto.resp.GenerateMpQrcodeVO;
import com.clear.honghefinance.wechat.service.WechatService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

import javax.annotation.Resource;
import java.util.Objects;

@Service
@Slf4j
public class MemberRegServiceImpl implements IMemberRegisterService {

// 省略其他。。。

@Resource
    private WechatService wechatService;
    @Resource
    private WechatConfig wechatConfig;

// 省略其他。。。

/**
     * 生成微信公众号二维码（关注微信公众号注册）
     *
     * @param clientId
     * @return
     */
    @Override
    public GenerateMpRegCodeVO generateMpRegCode(String clientId) {
        // 获取微信公众号Access Token
        AccessTokenVO mpAccessTokenVO = wechatService.getMpAccessToken(wechatConfig.getMp().getAppId(), wechatConfig.getMp().getSecret());

GenerateMpQrcodeDTO dto = new GenerateMpQrcodeDTO();
        dto.setExpireSeconds(wechatConfig.getMp().getCodeExpire());
        dto.setActionName("QR_STR_SCENE");
        dto.setActionInfo(dto.new ActionInfo());
        dto.getActionInfo().setScene(dto.new Scene());
        // 场景值ID：ScanReg_appId_clientId
        dto.getActionInfo().getScene().setSceneStr("ScanReg_" + wechatConfig.getMp().getAppId() + "_" + clientId);
        if (log.isInfoEnabled()) {
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                log.info("生成微信公众号临时二维码，入参:{}", objectMapper.writeValueAsString(dto));
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
        }
        // 生成微信公众号临时二维码
        GenerateMpQrcodeVO vo = wechatService.generateMpQrcodeCreate(mpAccessTokenVO.getAccessToken(), dto);

// 对象转换
        return ObjectConvertor.INSTANCE.convertGenerateMpQrcodeVOToGenerateMpRegCodeVO(vo);
    }
}
```

### converter

因为Service中涉及到了对象转换，所有定义了转换类

```java
package com.clear.honghefinance.biz.converter;

import com.clear.honghefinance.biz.modules.system.member.domain.vo.GenerateMpRegCodeVO;
import com.clear.honghefinance.wechat.dto.resp.GenerateMpQrcodeVO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper
public interface ObjectConvertor {

ObjectConvertor INSTANCE = Mappers.getMapper(ObjectConvertor.class);

GenerateMpRegCodeVO convertGenerateMpQrcodeVOToGenerateMpRegCodeVO(GenerateMpQrcodeVO vo);
}
```

在honghe-finance-biz模块引入如下依赖

```xml
<dependency>
 <groupId>org.mapstruct</groupId>
 <artifactId>mapstruct</artifactId>
</dependency>
<dependency>
 <groupId>org.mapstruct</groupId>
 <artifactId>mapstruct-processor</artifactId>
</dependency>
```

### wecaht Service

```java
package com.clear.honghefinance.wechat.service;

import com.clear.honghefinance.wechat.dto.req.GenerateMpQrcodeDTO;
import com.clear.honghefinance.wechat.dto.resp.AccessTokenVO;
import com.clear.honghefinance.wechat.dto.resp.GenerateMpQrcodeVO;

public interface WechatService {

// 省略其他。。。

/**
     * 生成微信公众号临时二维码
     * @param token token
     * @param dto
     * @return
     */
    GenerateMpQrcodeVO generateMpQrcodeCreate(String token, GenerateMpQrcodeDTO dto);

}
```

```java
package com.clear.honghefinance.wechat.service.impl;

import com.clear.honghefinance.wechat.constant.WechatApiConstant;
import com.clear.honghefinance.wechat.dto.req.GenerateMpQrcodeDTO;
import com.clear.honghefinance.wechat.dto.resp.AccessTokenVO;
import com.clear.honghefinance.wechat.dto.resp.GenerateMpQrcodeVO;
import com.clear.honghefinance.wechat.service.WechatService;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;

import javax.annotation.Resource;
import java.util.Objects;

@Service
@Slf4j
public class WechatServiceImpl implements WechatService {

@Resource
    private WebClient webClient;

// 省略其他。。。

/**
     * 生成微信公众号临时二维码
     *
     * @param token token
     * @param dto   生成微信公众号二维码DTO
     * @return
     */
    @Override
    public GenerateMpQrcodeVO generateMpQrcodeCreate(String token, GenerateMpQrcodeDTO dto) {
        String url = String.format(WechatApiConstant.MP_QRCODE_CREATE, token);
        // 发起POST请求，携带JSON格式的请求体，获取生成的公众号二维码信息
        GenerateMpQrcodeVO vo = webClient.post().uri(url).contentType(MediaType.APPLICATION_JSON)
            .body(BodyInserters.fromValue(dto))
            .retrieve().bodyToMono(GenerateMpQrcodeVO.class)
            .retry(retry)
            .block();

if (Objects.isNull(vo) || Strings.isBlank(vo.getTicket())) {
            return vo;  // 返回空对象
        }

// 通过ticket换取二维码
        vo.setQrCodeUrl(String.format(WechatApiConstant.MP_QRCODE_URL, vo.getTicket()));
        return vo;
    }

}
```

[**feat: 微信登录——生成微信公众号二维码**](https://gitee.com/ninghongkang/honghe-finance/commit/c053a2e188e909882c1dcb519e05d307251e9f3d)

## 接收微信推送的回调事件（todo：优化消息加解密、引入策略模式，扫描登录引入分布式锁）

参考文档：[【开始开发——接入指南】](https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Access_Overview.html)

参考文档：[【基础消息能力——接收事件推送】](https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Receiving_event_pushes.html)

深入理解这句话：当普通微信用户向公众账号发消息时，微信服务器将POST消息的XML数据包到开发者填写的URL上

### **接入指南，阅读文档总结**

接入微信公众平台开发步骤

-   第一步：

-   填写服务器配置：服务器地址（URL）、Token和EncodingAESKey
        -   **URL**：用于接收微信事件、消息（接收回调的URL）注意：**需要公网IP**
        -   **Token**：可任意填写，用作生成签名（该Token会和接口URL中包含的Token进行比对，从而验证安全性）
        -   EncodingAESKey：手动填写或随机生成，将用作消息体加解密密钥
    -   补充：解密方式：明文模式（默认）、兼容模式和安全模式。
        -   如果选择兼容模式和安全模式需要提前配置好相关加解密代码
        -   参考文档：[【基础消息能力——消息加解密说明】](https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Message_encryption_and_decryption_instructions.html)

-   第二步：验证消息的确来自微信服务器（**验签**）

-   微信服务器发送GET请求至上述填写的URL

-   | GET请求参数 | 描述                                                    |
        | :---------- | :------------------------------------------------------ |
        | signature   | 微信加密签名，signature ==【token + timestamp + nonce】 |
        | timestamp   | 时间戳                                                  |
        | nonce       | 随机数                                                  |
        | echostr     | 随机字符串                                              |

-   如果【token + timestamp + nonce】进过SHA1摘要后与signature 对比

-   一致，则校验成功，返回echostr参数内容

-   第三步：依据接口文档实现业务逻辑
    -   成为开发者后，处理微信推送的消息和事件
    -   用户发送消息时，公众号收到的是用户的OpenID
    -   可通过微信开放平台获取用户的UnionID，实现跨平台账号统一

关键要点

-   安全性：确保使用安全的Token和EncodingAESKey。

-   消息加解密：根据需要选择加解密方式。

-   接口权限：通过微信认证获得更多的接口权限。

-   用户身份识别：使用OpenID和UnionID来识别用户。

微信机制：首先发送get请求进行验签，验签成功，证明token一致，接着发送post进行对接

### **接收事件推送，阅读文档总结**

-   事件类型概览
    -   关注/取消关注事件：用户关注或取消关注公众号时触发
    -   扫描带参数二维码事件：用户扫描带有场景值的二维码时触发
    -   上报地理位置事件：用户同意上报地理位置后，每次进入公众号会话时触发
    -   自定义菜单事件
        -   点击菜单拉取消息时的事件推送
        -   点击菜单跳转链接时的事件推送
-   本项目中生成的临时二维码是带参数的，因此只需要重点关注如下事件
-   **扫描带参数二维码事件**
    -   如果用户还未关注公众号，则用户可以关注公众号，关注后微信会将带场景值关注事件推送给开发者。
    -   如果用户已经关注公众号，则微信会将带场景值扫描事件推送给开发者。
-   **1. 用户未关注时，进行关注后的事件推送**

```xml
<xml>
 <ToUserName><![CDATA[toUser]]></ToUserName>
 <FromUserName><![CDATA[FromUser]]></FromUserName>
 <CreateTime>123456789</CreateTime>
 <MsgType><![CDATA[event]]></MsgType>
 <Event><![CDATA[subscribe]]></Event>
 <EventKey><![CDATA[qrscene_123123]]></EventKey>
 <Ticket><![CDATA[TICKET]]></Ticket>
</xml>
```

注意：

重点关注（消息类型，MsgType）、（事件类型、Event）

就比如说：[接收事件推送](https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Receiving_event_pushes.html)	这里面的都是事件，因此消息类型都为event，事件类型有subscribe(订阅)、unsubscribe(取消订阅)、CLICK、VIEW等

[被动回复用户消息](https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Passive_user_reply_message.html)，这里面是指用户关注公众号以后给用户被动回复的消息（会产生一个POST请求），消息类型有text（文本）、image（图片）、voice（语音）、video（视频）、news（图文）、音乐为music（音乐）等

-   **2. 用户已关注时的事件推送**

```xml
<xml>
 <ToUserName><![CDATA[toUser]]></ToUserName>
 <FromUserName><![CDATA[FromUser]]></FromUserName>
 <CreateTime>123456789</CreateTime>
 <MsgType><![CDATA[event]]></MsgType>
 <Event><![CDATA[SCAN]]></Event>
 <EventKey><![CDATA[SCENE_VALUE]]></EventKey>
 <Ticket><![CDATA[TICKET]]></Ticket>
</xml> 
```

关键要点

-   **事件推送**：微信服务器会主动向公众号推送特定类型的事件。

-   事件处理：开发者可以通过处理这些事件来提供更好的用户体验和服务。

-   消息排重：建议使用FromUserName + CreateTime进行消息排重。

-   重试机制：微信服务器在五秒内收不到响应会断掉连接，并且重新发起请求，总共重试三次。

-   响应时间：如果服务器无法在五秒内处理并回复，可以直接回复空串，微信服务器不会重试。

### 接入微信公众平台开发

1、填写服务器配置（已完成）：如果没有公网IP，可以使用花生壳、natapp等内网穿透工具

2、验证服务器地址的有效性（已完成）

3、依据接口文档实现业务逻辑，如下：

-   Controller接口

```java
package com.clear.honghefinance.admin.controller;

import com.clear.honghefinance.wechat.service.WechatMpEventService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 微信回调Controller
 */
@RestController
@RequestMapping("/wxEvent")
@Slf4j
public class WechatCallbackController {

@Resource
    private WechatMpEventService wechatMpEventService;

/**
     * 接收微信事件推送、接收微信公众号推送事件
     *
     * @param signature 微信加密签名，signature结合了开发者填写的token参数和请求中的timestamp参数、nonce参数。
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @param echostr   随机字符串
     * @return 验签成功返回echostr，否则返回空串【timestamp+token+nonce+密文(可选)】做SHA1摘要签名后与signature对比，一致则验证成功
     */
    @GetMapping(value = "/receiveMpEvent")
    public String receiveMpEvent(@RequestParam("signature") String signature,
                                 @RequestParam("timestamp") String timestamp,
                                 @RequestParam("nonce") String nonce,
                                 @RequestParam("echostr") String echostr) {
        log.info("get验签请求参数，signature:{}, timestamp:{}, nonce:{}, echostr:{}",
                 signature, timestamp, nonce, echostr);

boolean flag = wechatMpEventService.receiveMpEvent(signature, timestamp, nonce);
        if (flag) {
            return echostr;
        }
        return "unknown";
    }
}
```

-   Service

```java
package com.clear.honghefinance.wechat.service;

/**
 * 
 * 接收微信事件推送
 * 
 */
public interface WechatMpEventService {

/**
     * 接收微信事件推送、接收微信公众号推送事件
     *
     * @param signature 微信加密签名
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @return 验签结果
     */
    boolean receiveMpEvent(String signature, String timestamp, String nonce);
}
```

```java
package com.clear.honghefinance.wechat.service.impl;

import com.clear.honghefinance.wechat.config.wechat.WechatConfig;
import com.clear.honghefinance.wechat.service.WechatMpEventService;
import com.clear.honghefinance.wechat.util.SHA1Util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
@Slf4j
public class WechatMpEventServiceImpl implements WechatMpEventService {

@Resource
    private WechatConfig wechatConfig;

/**
     * 接收微信事件推送、接收微信公众号推送事件
     *
     * @param signature 微信加密签名
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @return 验证结果
     */
    @Override
    public boolean receiveMpEvent(String signature, String timestamp, String nonce) {
        log.info("验签中.. signature:{}, token:{}, timestamp:{}, nonce:{}, echostr:{}",
                signature, wechatConfig.getMp().getToken(), timestamp, nonce);
        String tmpStr = SHA1Util.getSHA1(wechatConfig.getMp().getToken(), timestamp, nonce, "");
        // 【timestamp+token+nonce+密文(可选)】做SHA1摘要签名后与signature对比，一致则验证成功
        if (signature.equals(tmpStr)) {
            return true;
        }
        return false;
    }
}
```

-   SHA1Util（代码来源：[【接入指南】](https://res.wx.qq.com/op_res/-serEQ6xSDVIjfoOHcX78T1JAYX-pM_fghzfiNYoD8uHVd3fOeC0PC_pvlg4-kmP)）

```java
package com.clear.honghefinance.wechat.util;

import com.clear.honghefinance.wechat.exception.AesException;
import lombok.extern.slf4j.Slf4j;

import java.security.MessageDigest;
import java.util.Arrays;

/**
 * 
 * SHA1 class
 * 
 * 计算公众平台的消息签名接口.
 */
@Slf4j
public class SHA1Util {

/**
 * 用SHA1算法生成安全签名
 *
 * @param token 票据
 * @param timestamp 时间戳
 * @param nonce 随机字符串
 * @param encrypt 密文
 * @return 安全签名
 * @throws AesException
 */
 public static String getSHA1(String token, String timestamp, String nonce, String encrypt) throws AesException {
 try {
 String[] array = new String[]{token, timestamp, nonce, encrypt};
 StringBuffer sb = new StringBuffer();
 // 字符串排序
 Arrays.sort(array);
 for (int i = 0; i < 4; i++) {
 sb.append(array[i]);
 }
 String str = sb.toString();
 // SHA1签名生成
 MessageDigest md = MessageDigest.getInstance("SHA-1");
 md.update(str.getBytes());
 byte[] digest = md.digest();

StringBuffer hexstr = new StringBuffer();
 String shaHex = "";
 for (int i = 0; i < digest.length; i++) {
 shaHex = Integer.toHexString(digest[i] & 0xFF);
 if (shaHex.length() < 2) {
 hexstr.append(0);
 }
 hexstr.append(shaHex);
 }
 return hexstr.toString();
 } catch (Exception e) {
 log.error("SHA1算法生成安全签名异常{}", e.getMessage(), e);
 throw new AesException(AesException.ComputeSignatureError);
 }
 }
}
```

```java
package com.clear.honghefinance.wechat.exception;

@SuppressWarnings("serial")
public class AesException extends RuntimeException {

public final static int OK = 0;
    public final static int ValidateSignatureError = -40001;
    public final static int ParseXmlError = -40002;
    public final static int ComputeSignatureError = -40003;
    public final static int IllegalAesKey = -40004;
    public final static int ValidateAppidError = -40005;
    public final static int EncryptAESError = -40006;
    public final static int DecryptAESError = -40007;
    public final static int IllegalBuffer = -40008;
    //public final static int EncodeBase64Error = -40009;
    //public final static int DecodeBase64Error = -40010;
    //public final static int GenReturnXmlError = -40011;

private int code;

private static String getMessage(int code) {
        switch (code) {
            case ValidateSignatureError:
                return "签名验证错误";
            case ParseXmlError:
                return "xml解析失败";
            case ComputeSignatureError:
                return "sha加密生成签名失败";
            case IllegalAesKey:
                return "SymmetricKey非法";
            case ValidateAppidError:
                return "appid校验失败";
            case EncryptAESError:
                return "aes加密失败";
            case DecryptAESError:
                return "aes解密失败";
            case IllegalBuffer:
                return "解密后得到的buffer非法";
//		case EncodeBase64Error:
//			return "base64加密错误";
//		case DecodeBase64Error:
//			return "base64解密错误";
//		case GenReturnXmlError:
//			return "xml生成失败";
            default:
                return null; // cannot be
        }
    }

public int getCode() {
        return code;
    }

public AesException(int code) {
        super(getMessage(code));
        this.code = code;
    }

}
```

[**feat: 接入微信公众平台开发完成**](https://gitee.com/ninghongkang/honghe-finance/commit/83ec47c21ff73ca1c42e0019f26a9f68c8abc7ba)

### 接收事件推送

当我们成功的接入微信公众平台后，我们扫描二维码，【关注、取关公众号等（消息类型为**event**  ）】统称为事件，事件类型有subscribe(订阅)、unsubscribe(取消订阅)、SCAN(扫描)等等

功能需求：

-   用户扫描带参数的临时二维码
    -   如果用户未关注，则用户关注后，后端接收到消息类型为subscribe的事件，完成用户注册、登录
    -   如果用户已关注，则后端接收到消息类型为scan的事件，完成用户登录

具体代码参考git提交记录：[**feat: 接收事件推送——完成用户扫描注册、登录**](https://gitee.com/ninghongkang/honghe-finance/commit/e2947787866cde9e16421c673b460ea8d7d405b9)

1、Controller接口

```java
package com.clear.honghefinance.admin.controller;

import com.clear.honghefinance.biz.modules.system.member.service.IMemberRegisterService;
import com.clear.honghefinance.wechat.service.WechatMpEventService;
import com.clear.honghefinance.wechat.util.XmlMessageParseUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Map;

/**
 * 微信回调Controller
 */
@RestController
@RequestMapping("/wxEvent")
@Slf4j
public class WechatCallbackController {

@Resource
    private WechatMpEventService wechatMpEventService;

@Resource
    private IMemberRegisterService memberRegisterService;

// 省略。。
 
 /**
 * 接收微信事件推送、接收微信公众号推送事件
 * 扫带参数二维码关注：消息为：{Ticket=gQGz8DwAAAAAAAAAAS5odHRwOi8vd2VpeGluLnFxLmNvbS9xLzAya1A5Qms0a3ljS0gxeVVDUDFDY2cAAgSoGLNmAwQQDgAA, CreateTime=1723013341, EventKey=qrscene_ScanReg_wx347b3b2a761d0276_dcafeac6f9d941c5a96f97d69783e54c, Event=subscribe, ToUserName=gh_6e508ba809bc, FromUserName=oVGIu6_1zuQ4tfvCLrbj2WRraUTI, MsgType=event}
 * 扫带参数二维码（已关注后）：消息为：{Ticket=gQGz8DwAAAAAAAAAAS5odHRwOi8vd2VpeGluLnFxLmNvbS9xLzAya1A5Qms0a3ljS0gxeVVDUDFDY2cAAgSoGLNmAwQQDgAA, CreateTime=1723013447, EventKey=ScanReg_wx347b3b2a761d0276_dcafeac6f9d941c5a96f97d69783e54c, Event=SCAN, ToUserName=gh_6e508ba809bc, FromUserName=oVGIu6_1zuQ4tfvCLrbj2WRraUTI, MsgType=event}
 *
 * @param request
 * @return
 */
 @PostMapping(value = "/receiveMpEvent", produces = "application/xml;charset=UTF-8")
 public String receiveMpEvent(HttpServletRequest request) throws IOException {
 // 1、解析xml
 Map<String, String> messageMap = XmlMessageParseUtil.parseXml(request.getInputStream());
 log.info("接收到微信服务器发送的消息：" + messageMap);

// 2、根据推送事件的不同进行分别处理
        wechatMpEventService.receiveMpEvent(messageMap);

return "扫描关注你";
    }
}
```

2、Service

```java
package com.clear.honghefinance.wechat.service;

import java.util.Map;

/**
 * 
 * 接收微信事件推送
 * 
 */
public interface WechatMpEventService {

// 省略。。

void receiveMpEvent(Map<String, String> msg);
}
```

```java
package com.clear.honghefinance.wechat.service.impl;

import com.clear.honghefinance.wechat.config.wechat.WechatConfig;
import com.clear.honghefinance.wechat.service.WechatMpEventService;
import com.clear.honghefinance.wechat.util.SHA1Util;
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Map;

@Service
@Slf4j
public class WechatMpEventServiceImpl implements WechatMpEventService {

@Resource
    private WechatConfig wechatConfig;
    
    @Resource
    private RocketMQTemplate rocketMQTemplate;

// 省略。。

@Override
 public void receiveMpEvent(Map<String, String> messageMap) {
 // 2、根据推送事件的不同进行分别处理
 if ("subscribe".equals(messageMap.get("Event"))) {
 log.info("订阅事件");
 // EventKey=qrscene_ScanReg_wx347b3b2a761d0276_dcafeac6f9d941c5a96f97d69783e54c, Event=subscribe
 // a.解析EventKey
 // 在生成带场景二维码时：scene_str 场景值ID：ScanReg_appId_clientId

// todo 后期也可以优化为使用Redis的发布订阅、MQ等
            // b.发布事件
            if (log.isInfoEnabled()) {
                log.info("发布消息：{}", new Gson().toJson(messageMap));
            }
            rocketMQTemplate.asyncSend("wx-event", messageMap, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("消息发送成功");
                }

@Override
                public void onException(Throwable throwable) {
                    System.out.println("消息发送失败");
                }
            });

} else if ("SCAN".equals(messageMap.get("Event"))) {
            log.info("扫描事件");
            // EventKey=ScanReg_wx347b3b2a761d0276_dcafeac6f9d941c5a96f97d69783e54c, Event=SCAN
            if (log.isInfoEnabled()) {
                log.info("发布消息：{}", new Gson().toJson(messageMap));
            }
            rocketMQTemplate.asyncSend("wx-event", messageMap, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("消息发送成功");
                }

@Override
                public void onException(Throwable throwable) {
                    System.out.println("消息发送失败");
                }
            });
        } else if ("unsubscribe".equals(messageMap.get("Event"))) {
            log.info("取消订阅事件");
        } else {
            log.info("其他消息，消息类型为:{}", messageMap.get("MsgType"));
            // 其他消息类型，如text、image、voice、vide等，留作扩展
        }
    }
}

```

3、listener

```java
package com.clear.honghefinance.biz.listener;

import com.clear.honghefinance.biz.modules.system.member.service.IMemberRegisterService;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Map;

@Component
@RocketMQMessageListener(topic = "wx-event", consumerGroup = "group_rocketmq")
public class handleMpSubscribeEventListener implements RocketMQListener<Map<String, String>> {

@Resource
    private IMemberRegisterService memberRegisterService;

@Override
 public void onMessage(Map<String, String> stringStringMap) {
 memberRegisterService.handleMpSubscribeEventRequest(stringStringMap);
 System.out.println("handleMpSubscribeEventListener.onMessage");
 }
}
```

rocketmq相关配置

```yaml
# rocketmq
rocketmq:
  name-server: 192.168.188.150:9876
  producer:
    group: group_rocketmq
```

4、service

```java
package com.clear.honghefinance.biz.service;

import com.clear.honghefinance.biz.modules.system.member.domain.dto.PhoneRegisterDTO;
import com.clear.honghefinance.biz.modules.system.member.domain.vo.GenerateMpRegCodeVO;
import com.clear.honghefinance.common.dto.vo.TokenResponse;

import java.util.Map;

public interface IMemberRegisterService {
	// 省略。。

/**
 * 处理微信公众号事件回调
 *
 * @param map
 */
 void handleMpSubscribeEventRequest(Map<String,String> map);
 
}
```

```java
com.clear.honghefinance.biz.service.impl;
// 省略。。

@Service
@Slf4j
public class MemberRegServiceImpl implements IMemberRegisterService {

// 省略。。

/**
 * 处理微信公众号事件回调（监听）
 *
 * @param map
 */
 @Override
 public void handleMpSubscribeEventRequest(Map<String, String> map) {
 log.info("监听到消息:{}", new Gson().toJson(map));
 // todo if-else可优化为策略模式
 if ("subscribe".equals(map.get("Event")) && StringUtils.isNotBlank(map.get("EventKey"))) {
 // EventKey=qrscene_ScanReg_wx347b3b2a761d0276_dcafeac6f9d941c5a96f97d69783e54c, Event=subscribe
 // a.解析EventKey
 // 提示：在生成带场景二维码时：scene_str（场景值ID）：ScanReg_appId_clientId
 String[] split = map.get("EventKey").split("_");
 String appId = split[2];
 String clientId = split[3];
 if ("qrscene".equals(split[0]) && "ScanReg".equals(split[1])) {
 String openId = map.get("FromUserName");
 this.registerByMpOpenId(appId, clientId, openId);
 }
 } else if ("SCAN".equals(map.get("Event")) && StringUtils.isNotBlank(map.get("EventKey"))) {
 // EventKey=ScanReg_wx347b3b2a761d0276_dcafeac6f9d941c5a96f97d69783e54c
 String[] split = map.get("EventKey").split("_");
 String appId = split[1];
 String clientId = split[2];
 if ("ScanReg".equals(split[0])) {
 String openId = map.get("FromUserName");
 this.registerByMpOpenId(appId, clientId, openId);
 }
 }
 }

/**
     * 根据openId注册、注册即登录
     *
     * @param appId
     * @param clientId 客户端id 用户构建token缓存key
     * @param openId
     * @return
     */
    private TokenResponse registerByMpOpenId(String appId, String clientId, String openId) {
        log.info("根据openId注册（登录） appId:{}, clientId={}, openId={}", appId, clientId, openId);
        // 扫描注册
        long memberId = scanRegister(appId, openId);
        // 写入token信息到redis
        AdminDTO adminDTO = new AdminDTO();
        adminDTO.setId(memberId);
        // todo 这应该也存入角色id

// 生成token
        adminTokenService.setToken(adminDTO);

// token存入redis
        String key = redisUtil.buildKey(RedisKeyConstant.CLIENT_TOKEN_KEY, clientId);
        redisUtil.setNx(key, new Gson().toJson(adminDTO.getToken()), 10L, TimeUnit.MINUTES);
        return adminDTO.getToken();
    }

/**
     * 扫描注册
     *
     * @param appId
     * @param openId
     * @return
     */
    private long scanRegister(String appId, String openId) {
        // 查询用户是否以注册
        MemberBindWxOpenId memberBindWxOpenId = memberBindWxOpenidService.get(appId, openId);
        if (Objects.nonNull(memberBindWxOpenId)) {
            // 用户存在，返回用户id
            return memberBindWxOpenId.getMemberId();
        }

// 编程式事务
        Long resMemberId = transactionTemplate.execute(transactionStatus -> {
            // a.租户表
            long tenantId = tenantService.add();
            // b.会员表、用户表
            long memberId = memberService.register(tenantId);
            memberBindWxOpenidService.register(appId, openId, memberId);
            return memberId;
        });
        if (Objects.isNull(resMemberId)) {
            throw new BizException("注册失败");
        }
        return resMemberId;
    }

}
```

[**feat: 接收事件推送——完成用户扫描注册、登录**](https://gitee.com/ninghongkang/honghe-finance/commit/e2947787866cde9e16421c673b460ea8d7d405b9)

[**fix: 基于spring提供的发布订阅功能修复微信扫描注册功能**](https://gitee.com/ninghongkang/honghe-finance/commit/a03582912eee61b4ee9519dcdc50a86d4d57f563)

## 轮询检测微信扫码登录状态

说明：这个轮询检测微信扫码登录状态接口是由前端调用的，后端提供接口即可，无需关心

功能需求：

-   从redis缓存中读取token信息，以读取登录状态

[ feat: 轮询接口开发（获取客户端token信息）](https://gitee.com/ninghongkang/honghe-finance/commit/11119a260114c319904802359dc119dcb4c4447d)

# 获取当前用户登录信息

功能需求：

当用户通过手机密码登录、手机短信验证码、扫描登录等任意场景登录成功后，需要调用此接口以获取用户的基本信息，如头像、昵称等。用于在右上角显示。

功能流程：

-   1、首先定义好响应的Controller接口
-   2、根据token信息拿到用户id
-   3、根据用户id去查数据库

参考：

[**feat：获取当前用户登录信息**](https://gitee.com/ninghongkang/honghe-finance/commit/fe9108eea49e354fff3ae3f4c5937d51ec290bf9)

[**feat: 获取用户登录信息VO新增email字段**](https://gitee.com/ninghongkang/honghe-finance/commit/d323dc719891de3db5c1d4ebbc4d57cb7f0b450c)

# 个人账户管理

## 功能需求

-   修改当前登录用户的邮箱和姓名
-   修改当前登录用户的密码（修改时需要校验旧密码是否正确）
-   修改当前登录用户的手机号（修改时需要校验短信验证码，手机号是否被使用）

## 接口设计

| **模块** | **页面**          | **接口**       | **说明**                                                     |
| -------- | ----------------- | -------------- | ------------------------------------------------------------ |
| 管理后台 | 个人账户-个人资料 | 修改邮箱和姓名 |                                                              |
|          | 个人账户-修改密码 | 修改密码       | 需要校验旧密码是否正确                                       |
|          | 个人账户-修改手机 | 获取图形验证码 |                                                              |
|          |                   | 获取短信验证码 | 获取短信验证码前需要校验图形验证码是否正确，防止恶意获取短信验证码 |
|          |                   | 修改手机       | 修改手机时需要校验短信验证码是否正确                         |

## 表设计

member（会员表）、member_bind_phone（会员绑定手机表）

## 修改邮箱和姓名接口

[**feat: 修改修改邮箱和姓名接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/0297bb5f7d67071472fe58b3eeac456d53a1b299)

## 修改密码接口

[**feat: 修改修改密码接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/b8fa1404c0a423b93c1f7fbeb9605f2d41bd84b8)

## 获取图形验证码接口

[**feat: 获取图形验证码接口开发（用于修改手机号）**](https://gitee.com/ninghongkang/honghe-finance/commit/becf7ec4cb4e069641dec317d954101626023b15)

## 获取短信验证码接口

[**feat: 获取短信验证码接口开发（用于修改手机号）**](https://gitee.com/ninghongkang/honghe-finance/commit/e6c26cc7947ab225adbca9795941692d62b99629)

## 修改手机号接口

前提

-   获取图形验证码接口
-   获取短信验证码接口

[**feat: 修改修改手机号接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/9ae7ba09850bf30a3e8d505436cf1f071b5ec46e)

# 数据校验与统一异常处理

一般情况下：

-   简单的校验：让表现层Controller来做，Controller放给业务层的数据基本合法
-   业务层进行校验：业务层进行和业务相关的复杂校验

## 开启校验

如何开启数据校验

1、导入校验依赖：spring-boot-starter-validation

```xml
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-validation</artifactId>
</dependency>
```

其中包含：

-   jakarta.validation-api：（JSR303规范）
-   hibernate-validator（校验实现）

2、给参数（DTO或VO）标注上校验注解

所有可用的注解都在：

-   `javax.validation.constraints`（jakarta.validation-api JSR303规范提供）

-   `org.hibernate.validator.constraints`（hibernate-validator 校验实现提供的扩展注解）

示例：

```java
/**
 * 手机号
 */
@Length(min = 11, max = 11, message = "手机号长度必须为11位")
private String phone;
```

3、开启校验，在参数位置标注`Valid` 或`Validated`注解即可

-   `Valid`：JSR303规范提供

-   `Validated`：Spring提供【有分组校验功能，但是不建议使用（我们可以通过维护不同的DTO）】
    -   分组校验：假设你有一个User类，它有一些属性，比如id, name, email, 和 password。你可能希望在用户注册时校验name, email, 和 password，但在更新用户信息时只校验name和email。

示例：

```java
public Result register(@Validated @RequestBody UserRegisterDTO userRegisterDTO) {

userInfoService.register(userRegisterDTO);
	return Result.ok();
}
```

效果：

-   提交正确值，进行业务
-   提交错误值，抛出异常；`MethodArgumentNotValidException`

## `BindingResult`捕获错误自行处理

4、`BindingResult`捕获错误自行处理

给controller方法校验参数后面添加一个`BindingResult`参数。会自动封装错误。

注意：

-   一旦有了 `BindingResult`，校验发生错误后，就会将错误信息封装到 br 对象，你需要手动判断是否有错误，再进行业务逻辑。不手动处理，框架不会抛出任何错误。
-   `BindingResult`紧跟在校验参数后面，只封装它前面校验参数的校验结果。如果有多个校验对象，每个对象后面都可以紧跟一个自己的`BindingResult`。
-   以前不写`BindingResult`，SpringBoot会自动返回错误提示

示例：

```java
@Operation(summary = "用户注册")
@PostMapping("/register")
public Result register(@Validated @RequestBody UserRegisterDTO userRegisterDTO,
                         BindingResult result) {

if (result.hasErrors()) {
 //1. 如果校验失败，返回错误
 //2. 封装错误和提示消息。一般建议为Map；key是字段名，value是错误消息
 Map<String, String> errorMap = new HashMap<>();
 result.getFieldErrors().forEach(error -> {
 errorMap.put(error.getField(), error.getDefaultMessage());
 });
 return Result.error().setData(errorMap);
 }
 userInfoService.register(userRegisterDTO);
 return Result.ok();
}
```

错误响应如下：

```json
{
  "code": 500,
  "msg": "error",
  "data": {
    "phone": "手机号格式不正确"
  }
}
```

## 配置自定义错误响应（错误提示——配置化）

如果希望数据校验错误后的消息可控，可做如下配置：

-   1、校验错误消息配置为代码

```java
@Length(min = 11, max = 11,message = "{phone.length.error}")
private String phone;
```

-   2、配置message（在application.yml中）

```yml
spring:
  messages:
    basename: i18n/messages
```

-   3、创建message.properties

```properties
phone.length.error = 手机号不正确
```

## 国际化（错误提示——国际化）

文件名以后叫 `message_语言_国家.properties`。如 `message_zh_CN.properties`

示例：

1、配置

message.properties（默认，找不到语言环境就会用这个）

```properties
phone.length.error = 手机号不正确
```

message_zh_CN.properties

```properties
phone.length.error = 手机号不正确
```

message_en_US.properties

```properties
phone.length.error = The phone number is incorrect
```

2、切换浏览器语言环境测试，就可以看到如下效果

```json
{
  "code": 500,
  "msg": "error",
  "data": {
    "phone": "The phone number is incorrect"
  }
}
```

## 自定义校验注解

如果JSR303规范和hibernate实现中提供的注解都不能满足我们的需求，就可以自定义注解

场景：检查用户名唯一；检查失败，提示错误

### 定义注解

com.\*.constraints

```java
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

/**
 * 自定义校验注解：查询数据库确保username唯一
 * Constraint：表示校验注解
 *  validatedBy 指定注解校验器
 * Target：指定注解可以用于那些元素上
 * Retention：指定注解保留策略
 *  RUNTIME 运行时保留，因此可以在运行时通过反射访问到
 */

@Documented
@Constraint(
        validatedBy = UniqueUserValidator.class
)
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UniqueUser {

String[] baned() default {"admin","root"}; // 不允许的用户名
    
    String message() default "用户名已存在";

Class<?>[] groups() default {};

Class<? extends Payload>[] payload() default {};

}
```

### 定义校验器

com.\*.constraints.validator

```java
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.Arrays;

/**
 * 自定义校验器：负责校验 @UniqueUser标注的String类型字段
 */
//因为要注入容器中组件，所以需要使用@Component注解
@Component
public class UniqueUserValidator implements ConstraintValidator<UniqueUser, String> {

@Autowired
    UserInfoService userInfoService;

private String[] baned;

/**
     * 初始化，获取注解上标注的信息
     */
    @Override
    public void initialize(UniqueUser constraintAnnotation) {
        // 初始化
        baned = constraintAnnotation.baned();
    }

@Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        // 查询是否在指定黑名单中
        long counted = Arrays.stream(baned).filter(s -> s.equals(value)).count();

// 查询数据库中是否存在该用户
        Long count = userInfoService.lambdaQuery()
                .eq(UserInfo::getUsername, value)
                .count();
        return count == 0 && counted == 0;
    }
}
```

### 配置属性校验（使用注解）

```java
/**
 * 用户名
 */
@UniqueUser(message = "{user.exists}")
private String username;
```

### 配置错误提示

message_zh_CN.properties

```properties
user.exists = user exists
```

### 效果如下

```json
{
  "code": 500,
  "msg": "error",
  "data": {
    "phone": "phone number error la!",
    "username": "user exists"
  }
}
```

## 枚举封装异常

我们通常会定义各种枚举情况，来表示系统中的异常

### 定义异常枚举

为什么需要定义异常枚举类？

1、减少硬编码

2、随着业务沉淀，快速定位错误原因

3、前端也需要根据错误码来进行不同的页面展示

```java
public enum BizExceptionEnum { // 如果项目比较大，也可以继续拆分，如OrderBizXxx、UserBizXxxx

/**
     * 1xxxx：系统异常码
     */
    BIZ_ERROR(10000, "系统异常"),

/**
     * 2xxxx：用户相关异常码
     */
    USERNAME_PASSWORD_ERROR(20001, "账号密码错误"),
    USER_EXISTS(20002, "用户已存在");

@Getter
    private int code;
    @Getter
    private String msg;
    BizExceptionEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}
```

### 定义异常类

```java
@Data
public class BizException extends RuntimeException {

private int code;
    private String message;

public BizException(String message) {
        super(message);
    }
    public BizException(int code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }
    public BizException(BizExceptionEnum exceptionEnum) {
        super(exceptionEnum.getMsg());
        this.code = exceptionEnum.getCode();
        this.message = exceptionEnum.getMsg();
    }
}
```

## 全局异常处理

利用全局异常处理机制，统一封装数据校验的错误信息，（不再去手动处理校验错误）

原理：数据校验抛出的异常是：`MethodArgumentNotValidException`

```java
/**
 * MethodArgumentNotValidException-Spring封装的参数验证异常处理
 * MethodArgumentNotValidException：作用于 @Validated @Valid 注解，
 * 接收参数加上@RequestBody注解（json格式）的异常处理。
 *
 * @param e MethodArgumentNotValidException异常信息
 * @return 响应数据
 */
@ExceptionHandler(MethodArgumentNotValidException.class)
public Object handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
    log.error(e.getMessage(), e);

Map<String, String> errors = new HashMap<>();
 BindingResult bindingResult = e.getBindingResult();
 // 获取所有校验错误的字段信息
 bindingResult.getFieldErrors().forEach(fieldError -> {
 // 封装错误和提示消息。一般建议为Map；key是字段名，value是错误消息
 String field = fieldError.getField(); // 发生错误的字段
 String message = fieldError.getDefaultMessage(); // 错误的提示
 errors.put(field, message);
 log.error(message);
 });

return ApiResponse.error(errors);
}
```

# 接口鉴权

功能需求

-   对一些白名单的接口，直接放行，无需拦截校验
    -   比如说登录、注册等接口
-   没有在白名单的且没有登录的则拦截
-   通过对登录用户的**角色id**判断当前接口是否具有访问权限，有权限放行，无权限则拦截

1、AntPathMatcher用于路径匹配

```java
package com.clear.honghefinance.common.config;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.AntPathMatcher;

/**
 * 路径匹配config
 */
@ConditionalOnProperty(prefix = "sys", name = "enable-my-security", havingValue = "true")   // bean的注入条件
@Configuration
public class PathMatcherConfig {

/**
     * 配置AntPathMatcher Bean
     *
     * @return AntPathMatcher实例，用于路径匹配
     */
    @Bean
    public AntPathMatcher antPathMatcher() {
        return new AntPathMatcher();
    }
}
```

2、过滤器处理service

```java
package com.clear.honghefinance.common.service;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public interface AuthFilterService<T> {

void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException;

/**
     * 不经过过滤器筛选
     *
     * @param request
     * @return
     * @throws ServletException
     */
    boolean shouldNotFilter(HttpServletRequest request) throws ServletException;
}
```

```java
package com.clear.honghefinance.common.service.impl;

import com.clear.honghefinance.common.config.SecurityConfig;
import com.clear.honghefinance.common.constant.CommonConstant;
import com.clear.honghefinance.common.dto.BaseUserInfoDTO;
import com.clear.honghefinance.common.exception.BizException;
import com.clear.honghefinance.common.exception.LoginException;
import com.clear.honghefinance.common.service.AuthFilterService;
import com.clear.honghefinance.common.service.TokenService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.servlet.HandlerExceptionResolver;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@ConditionalOnProperty(prefix = "sys", name = "enable-my-security", havingValue = "true") // bean的注入条件
@Component
@Slf4j
@RequiredArgsConstructor
public class AuthFilterServiceImpl<T extends BaseUserInfoDTO> implements AuthFilterService<T> {

private final TokenService<T> tokenService;
 private final SecurityConfig securityConfig;
 private final AntPathMatcher antPathMatcher;
 private final RedisTemplate<String, Object> redisTemplate;
 private final HandlerExceptionResolver handlerExceptionResolver;

@Override
    public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            if (Objects.isNull(securityConfig) || !securityConfig.getEnable()) {
                filterChain.doFilter(request, response);
                return;
            }

T userInfo = null;
            if ("token".equals(securityConfig.getGetUserType())) {
                // 从token中获取用户信息
                // api-access-token 由前后端协商的属性
                String token = request.getHeader("api-access-token");
                tokenService.checkToken(token);
            } else if ("gateway".equals(securityConfig.getGetUserType())) {
                // todo 从网关中获取用户信息

}
            // 未获取到用户信息，抛出异常
            if (Objects.isNull(userInfo)) {
                throw new LoginException("无法获取到用户信息");
            }
            BaseUserInfoDTO baseUserInfoDTO = (BaseUserInfoDTO) userInfo;
            // 鉴权
            checkPermissions(baseUserInfoDTO.getSysRoleIds(), request.getServletPath());
            // 存储用户信息在threadLocal中
            tokenService.setThreadLocalUser(userInfo);
            // 放行
            filterChain.doFilter(request, response);
            // 清除用户信息
            tokenService.removeThreadLocalUser();
        } catch (Exception e) {
            handlerExceptionResolver.resolveException(request, response, null, e);
        }
    }

/**
     * 不经过过滤器筛选
     *
     * @param request
     * @return
     * @throws ServletException
     */
    @Override
    public boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        if (Objects.isNull(securityConfig) || !securityConfig.getEnable() || CollectionUtils.isEmpty(securityConfig.getIgnores())) {
            return false;
        }
        String path = request.getServletPath();
        boolean ignore = securityConfig.getIgnores().stream().anyMatch(p -> antPathMatcher.match(p, path));
        if (log.isInfoEnabled()) {
            log.info("路径：{}，是否忽略权限过滤：{}", path, ignore);
        }
        return ignore;
    }

/**
 * 检查用户权限
 *
 * @param sysRoleIds 用户角色id列表
 * @param path 当前请求路径
 */
 private void checkPermissions(Set<Long> sysRoleIds, String path) {
 // 管理员角色不检查权限
 if (sysRoleIds.contains(CommonConstant.ROLE_ADMIN)) {
 return;
 }
 // 根据缓存查询角色对应的菜单id列表
 Set<Integer> roleMenuIds = listRoleMenuIdByCache(sysRoleIds);
 if (CollectionUtils.isEmpty(roleMenuIds)) {
 throw new BizException("角色对应的菜单id不存在");
 }
 // 根据缓存查询菜单路径
 List<String> menuPathList = listMenuPathByCache(roleMenuIds);
 if (CollectionUtils.isEmpty(menuPathList)) {
 throw new BizException("角色菜单配置不存在");
 }
 // 遍历菜单路径列表，检查当前请求路径是否匹配任一菜单路径
 for (String url : menuPathList) {
 // 如果路径匹配，则返回，表示权限检查通过
 if (antPathMatcher.match(url, path)) {
 return;
 }
 }
 throw new BizException("权限不足");
 }

/**
 * 根据缓存查询菜单路径
 *
 * @param menuIds 菜单id列表
 * @return 菜单路径列表
 */
 private List<String> listMenuPathByCache(Set<Integer> menuIds) {
 HashOperations<String, String, String> hashOps = redisTemplate.opsForHash();
 return hashOps.multiGet("MENU", menuIds.stream().map(String::valueOf).collect(Collectors.toSet()));
 }

/**
 * 从缓存中获取角色对应的菜单id列表
 *
 * @param roleIds 角色id列表
 * @return 角色对应的菜单id列表
 */
 private Set<Integer> listRoleMenuIdByCache(Set<Long> roleIds) {
 HashOperations<String, String, Set<Integer>> hashOps = redisTemplate.opsForHash();
 List<Set<Integer>> roleMenuIds = hashOps.multiGet("ROLE", roleIds.stream().map(String::valueOf).collect(Collectors.toSet()));
 // 对结果进行处理，将 List<List<Integer>> 转为 List<Integer>
 return roleMenuIds.stream()
 .flatMap(Set::stream)
 .collect(Collectors.toSet());
 }
}
```

3、过滤器配置

```java
package com.clear.honghefinance.admin.config;

import com.clear.honghefinance.common.dto.AdminDTO;
import com.clear.honghefinance.common.service.AuthFilterService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 配置认证过滤器，用于拦截请求并进行身份验证
 */
@Configuration
@Slf4j
public class AuthFilterConfig extends OncePerRequestFilter {

/**
 * 注入认证过滤服务，用于具体的身份验证逻辑
 */
 @Resource
 private AuthFilterService<AdminDTO> authFilterService;

/**
     * 执行过滤逻辑
     *
     * @param httpServletRequest  请求对象，包含请求的相关信息
     * @param httpServletResponse 响应对象，用于向客户端发送响应
     * @param filterChain         过滤器链对象，用于继续执行后续过滤器或目标资源
     * @throws ServletException 如果过滤器抛出Servlet异常
     * @throws IOException      如果过滤器抛出IO异常
     */
    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        authFilterService.doFilterInternal(httpServletRequest, httpServletResponse, filterChain);
    }

/**
     * 决定是否不执行过滤
     *
     * @param request 请求对象，用于判断是否需要过滤
     * @return 如果返回true，则表示不应该过滤该请求；如果返回false，则表示应该过滤
     * @throws ServletException 如果判断过程中抛出Servlet异常
     */
    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        return authFilterService.shouldNotFilter(request);
    }
}
```

4、白名单配置

```yaml
# 自定义安全配置
security:
  # 开启安全校验
  enable: true
  # 获取用户信息的方式
  getUserType: token
  # 白名单
  ignores:
    # swagger
    - /v3/api-docs
    - /swagger-resources/configuration/ui
    - /swagger-resources
    - /swagger-resources/configuration/security
    - /webjars/**
    - /swagger-ui.html
    - /doc.html
    # ico
    - /favicon.ico
    # 登录
    - /login/*
    # 注册
    - /reg/*
    # 微信回调
    - /wxEvent/receiveMpEvent
  # token 过期时间（秒）
  expire: 36000
```

# 菜单管理

功能需求：

-   当用户登录成功后，会路由到菜单管理，左侧Sider会显示菜单列表（可以根据角色id展示不同的菜单）
-   正文Content会显示对应菜单下的内容
-   此外还有增删改查的功能

## 接口设计

| **模块** | **页面** | **接口** | **说明** |
| -------- | ----------------- | -------------------------------------------------- | ------------------------------------------------------------ |
| 管理后台 | 左侧导航菜单Sider | 获取导航菜单列表 | 1、支持二级菜单（最多支持二级） 2、可根据不同的角色查询不同的菜单列表 3、从缓存中获取菜单列表（提升性能） |
| | 菜单管理Content | 菜单查询列表 | 1、根据菜单名称模糊查询 2、不需要分页 3、查询所有未删除的菜单 |
| | | 菜单查询列表（给编辑或创建页面的树形菜单组件使用） | 1、只返回需要的字段 |
| | | 创建菜单 | |
| | | 修改菜单 | 1、不允许修改父菜单 |
| | | 删除菜单 | 1、逻辑删除 2、如果删除的是父节点需要判断该父节点下面有没有子节点，如果有的话则不能删除 |
| | | 获取菜单明细 | |

## 表设计

```mysql
create table sys_menu
(
    id               int auto_increment primary key,
    pid              int          default 0                 not null comment '父级菜单',
    name             varchar(50)  default ''                not null comment '菜单名称',
    path             varchar(200) default ''                not null comment '菜单路由',
    component        varchar(200) default ''                not null comment '菜单组件',
    icon             varchar(20)  default ''                not null comment '图标',
    layout           tinyint(1)   default 1                 not null comment '是否使用布局',
    hide_in_menu     tinyint(1)   default 0                 not null comment '是否隐藏菜单',
    redirect         varchar(200) default ''                not null comment '重定向地址',
    sort             int          default 0                 not null comment '排序',
    member_id        bigint       default 0                 not null comment '用户id',
    update_member_id bigint       default 0                 not null comment '修改用户id',
    node_path        int          default 0                 not null comment '节点深度，0表示一级节点',
    create_time      datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    disable          tinyint(1)   default 0                 not null comment '是否禁用',
    del_flag         tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
)comment '系统菜单';
```

## CRUD开发

参考：

[ feat：菜单管理CRUD](https://gitee.com/ninghongkang/honghe-finance/commit/df14bbdc84643576b98b26443fed4133140ac775)

[**feat: 菜单管理——获取菜单列表VO新增字段sort、hideInMenu**](https://gitee.com/ninghongkang/honghe-finance/commit/61f5df96148e7b75158207e429680bc82fa2fca3)

[**fix: 修复菜单列表中菜单名称不显示（配合前端一起修改）**](https://gitee.com/ninghongkang/honghe-finance/commit/59ed4fba3daef1e331844aa133cedaad48d5c43d)

[**fix: 修复菜单列表条件查询（发现条件查询后失去树形结构，后期优化）**](https://gitee.com/ninghongkang/honghe-finance/commit/5ea6a4a93d6dc85a942873bd5f94d6790bb7353d)

[**fix: 修改根据id查询菜单列表逻辑错误**](https://gitee.com/ninghongkang/honghe-finance/commit/8ec93cfb8b9c1217b8df8fa137faf64daa16ebc9)

[**update: 更新根据id查询菜单列表、根据id查询资源列表sql语句**](https://gitee.com/ninghongkang/honghe-finance/commit/b2176f8d6b68fe3770a05ceb2f59d56f224d2b3f)

# 系统资源管理

资源说明：

在这个项目中就是我们后端api接口，我们后端所有的api接口地址保存在数据库中，每个角色可以绑定不同的资源访问权限（方便控制角色的资源，后续我们只需要在角色中绑定对应的资源就可以达到控制访问权限的效果）

## 接口设计

| **模块** | **页面** | **接口** | **说明** |
| -------- | -------- | ------------ | ------------------------------------------------------------ |
| 管理后台 | 资源管理 | 查询资源列表 | 1、根据资源名称和资源路径模糊查询资源列表 2、列表返回资源名称，资源路径 3、上级资源有子资源的不显示删除按钮（按钮显示由前端处理） 4、子资源不显示新增按钮（按钮显示由前端处理） |
| | 菜单管理 | 创建资源 | 1、上级资源只能是没有或者是一级资源 2、一级资源路径必须以/\*结尾 3、二级资源路径前面必须包含上级资源路径/*前面的内容 |
| | | 修改资源 | 1、上级资源不可修改（前端不显示按钮，后端仍需要校验） 2、一级资源路径必须以/\*结尾 3、二级资源路径前面必须包含上级资源路径/*前面的内容 |
| | | 获取资源详情 | 修改资源界面需要使用（修改资源时表单回显） |
| | | 删除资源 | 1、逻辑删除 2、一级资源有子资源的不能删除（前端不显示按钮，后端仍需要校验） |

## 表设计

```mysql
create table sys_resource
(
    id               int auto_increment primary key,
    pid              int          default 0                 not null comment '父id',
    name             varchar(50)  default ''                not null comment '资源名称',
    path             varchar(200) default ''                not null comment '资源路径',
    sort             int          default 0                 not null comment '排序',
    create_time      datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    member_id        bigint       default 0                 not null comment '用户id',
    update_member_id bigint       default 0                 not null comment '修改用户id',
    del_flag         tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除',
    disable          tinyint(1)   default 0                 not null comment '是否禁用',
    node_path        int          default 0                 not null comment '节点深度',
    constraint sys_resource_path_uindex unique (path)
)
    comment '系统资源';
```

## CRUD开发

参考：

[**feat：系统资源管理CRUD**](https://gitee.com/ninghongkang/honghe-finance/commit/829d36b98daeec93930108de02796bb00f0a0824)

[**docs；新增资源接口新增注释**](https://gitee.com/ninghongkang/honghe-finance/commit/e6f251902e6dc0579331de8811004db95b251265)

[**fix；修复查询资源明细接口**](https://gitee.com/ninghongkang/honghe-finance/commit/be44598ee14135fb1faf0b110d048cf2670dc75b)

[**docs: 修改资源接口新增注释**](https://gitee.com/ninghongkang/honghe-finance/commit/4b09eb61c03ec68c0178b1bd921ac2de966eaf4b)

[**docs: 获取资源vo修改注释**](https://gitee.com/ninghongkang/honghe-finance/commit/7bde863fda7b8952c558f10c88dd2f321e415344)

[**fix: 修复根据id查询资源列表逻辑错误**](https://gitee.com/ninghongkang/honghe-finance/commit/020f28394d42adf08a60ec747c3799337db053f9)

[**update: 更新根据id查询菜单列表、根据id查询资源列表sql语句**](https://gitee.com/ninghongkang/honghe-finance/commit/b2176f8d6b68fe3770a05ceb2f59d56f224d2b3f)

# 角色管理

说明:

我们需要为用户分配相应的角色，每个角色可以拥有不同的菜单和资源权限，这样就可以使得每个用户可以显示不同的菜单和访问不同的资源

## 接口设计

| **模块** | **页面** | **接口** | **说明** |
| -------- | -------- | ------------ | ------------------------------------------------------------ |
| 管理后台 | 角色管理 | 查询角色列表 | 1、根据角色名称模糊查询角色列表 2、根据禁用状态查询角色列表 3、返回角色名称和禁用状态 4、支持分页查询 |
| | | 创建角色 | |
| | | 修改角色 | |
| | | 获取角色详情 | 修改角色界面需要使用（修改角色时表单回显） |
| | | 删除角色 | 1、逻辑删除 |
| | | 禁用启用角色 | |

## 表设计

```mysql
create table sys_role
(
    id               int auto_increment primary key,
    role_name        varchar(200) default ''                not null comment '角色名称',
    member_id        bigint       default 0                 not null comment '用户id',
    update_member_id bigint       default 0                 not null comment '修改用户id',
    disable          tinyint(1)   default 0                 not null comment '是否禁用',
    create_time      datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
) comment '系统角色';
```

## CRUD开发

参考：

[**feat：角色管理CRUD**](https://gitee.com/ninghongkang/honghe-finance/commit/cd13f8ca3e54f15fb3770902cc6202d950d8a1ec)

[**fix: 修复查询角色列表接口**](https://gitee.com/ninghongkang/honghe-finance/commit/1853b68a3184018f7389bb791cd04309f1a37352)

[**fix: 修复禁用或启用角色接口**](https://gitee.com/ninghongkang/honghe-finance/commit/72935453e559263aa5a894b27645825d93150dee)

[**refactor: 重构查询角色列表接口查询逻辑**](https://gitee.com/ninghongkang/honghe-finance/commit/9bf3919bbac838e93f8fbfa56d7933438717fbc6)

[**fix: 解决 where id in () 括号中为空导致的sql错误**](https://gitee.com/ninghongkang/honghe-finance/commit/6ab591f4fdb5a76c6ea7965c6c10daf5dad8c527)

[**fix: 修复禁用或启用角色接口sql错误**](https://gitee.com/ninghongkang/honghe-finance/commit/5e7c5f6d5f01a8369eb45416e1a1ee642377cc3e)

[**update: 更新修改角色DTO**](https://gitee.com/ninghongkang/honghe-finance/commit/89ce0acd17a4daa65f46f8aa478de37d6c4dd569)

# 角色绑定菜单

功能需求：

-   根据当前登录用户所拥有的角色所绑定的菜单，用于左侧菜单栏的显示与否
    -   根据角色id，只显示绑定的菜单
    -   由于菜单查询比较频繁，可以使用缓存优化
-   角色绑定的菜单，可以根据复选框的选中状态决定菜单是否绑定到角色中
    -   选中，角色绑定菜单（还可以存入缓存）
    -   未选中，角色取消绑定菜单
-   -   
-   查询某个角色可以访问的菜单

## 接口设计

| **模块** | **页面** | **接口** | **说明** |
| -------- | -------------- | ---------------------------- | ------------------------------------------------------------ |
| 管理后台 | 左侧菜单导航栏 | 查询菜单列表（以树形返回） | 1、根据当前登录用户所拥有的角色所绑定的菜单来显示菜单信息 2、由于菜单查询比较频繁，所以可以走缓存中查询菜单 |
| | | 查询某个角色绑定的菜单id列表 | 1、返回角色绑定的菜单id列表 |
| | | 角色绑定菜单（可绑定、解绑） | 1、传入绑定的菜单id列表 2、传入解绑的菜单id列表 |

## 表设计

```mysql
create table sys_role_bind_menu
(
    id               int auto_increment primary key,
    sys_role_id      int        default 0                 not null comment '角色id',
    sys_menu_id      int        default 0                 not null comment '系统菜单id',
    member_id        bigint     default 0                 not null comment '用户id',
    update_member_id bigint     default 0                 not null comment '修改用户id',
    disable          tinyint(1) default 0                 not null comment '是否禁用',
    create_time      datetime   default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime   default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1) default 0                 not null comment '是否删除，0：删除，1：未删除'
) comment '系统角色绑定菜单';
```

## 角色绑定菜单

[**feat: 角色绑定菜单功能**](https://gitee.com/ninghongkang/honghe-finance/commit/3b7da8515a2a51928bd4f0520945f31366ca462f)

[**fix: 修复角色绑定菜单-取消绑定sql语句错误**](https://gitee.com/ninghongkang/honghe-finance/commit/b0baf268c3898238469518e9a6ac6b0d6fd0fd03)

## 查询某个角色绑定的菜单id列表

[**feat: 查看角色绑定的菜单id列表**](https://gitee.com/ninghongkang/honghe-finance/commit/b3d554c593d8f4f0bf3440d3a7c17fdb580898e3)

## 查询当前登录用户角色绑定的菜单列表

[**feat: 查看当前登录用户角色绑定的菜单列表（用户绑定的角色可能有很多）**](https://gitee.com/ninghongkang/honghe-finance/commit/d0161b41c4591ab01c8bea2e4cc33551fa59bb6e)

[fix: 修复mapstruct映射问题（List sysMenuList中name字段无法映射到 List<ListTreeSelectMenuVO>中的title字段，原因是mapstruct编译机制的问题）](https://gitee.com/ninghongkang/honghe-finance/commit/934154ab0e384650a18a42093a0b51505ec44b9b)

## 缓存优化

左侧菜单缓存优化，即对”查询当前登录用户角色绑定的菜单列表“这一接口进行优化

角色绑定菜单优化

禁用、启用角色优化

删除角色优化

[**feat: 角色绑定菜单缓存优化**](https://gitee.com/ninghongkang/honghe-finance/commit/65adfec9806f09c726c1c407e418ef1f4844a868)

### 缓存设计

使用hash表存储角色绑定的菜单

-   **key**：ROLE_MENU_PERMISSIONS:
-   **hashKey 或者 filed**：角色id
-   **value**：菜单列表

角色绑定的菜单缓存内容示例

```json
[
    "java.util.ArrayList",
    [
        {
            "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
            "id": 2,
            "name": "凭证",
            "icon": "FileProtectOutlined",
            "path": "1",
            "layout": null,
            "component": "",
            "redirect": "",
            "hideInMenu": false,
            "routes": [
                "java.util.ArrayList",
                [
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 3,
                        "name": "新增凭证",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 4,
                        "name": "查看凭证",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 5,
                        "name": "查看凭证",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    }
                ]
            ]
        },
        {
            "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
            "id": 6,
            "name": "资金",
            "icon": "TransactionOutlined",
            "path": "1",
            "layout": null,
            "component": "",
            "redirect": "",
            "hideInMenu": false,
            "routes": [
                "java.util.ArrayList",
                [
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 7,
                        "name": "现金日记账",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 8,
                        "name": "银行日记账",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 9,
                        "name": "内部转账",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 10,
                        "name": "票据管理",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 11,
                        "name": "资金报表",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 12,
                        "name": "核对总账",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 13,
                        "name": "收支类别",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 14,
                        "name": "银企互联",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 15,
                        "name": "账号设置",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    }
                ]
            ]
        },
        {
            "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
            "id": 17,
            "name": "工资",
            "icon": "CreditCardOutlined",
            "path": "1",
            "layout": null,
            "component": "",
            "redirect": "",
            "hideInMenu": false,
            "routes": [
                "java.util.ArrayList",
                [
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 18,
                        "name": "工资管理",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 19,
                        "name": "员工信息",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 20,
                        "name": "五险一金设置",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    }
                ]
            ]
        },
        {
            "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
            "id": 21,
            "name": "固定资产",
            "icon": "BankOutlined",
            "path": "1",
            "layout": null,
            "component": "",
            "redirect": "",
            "hideInMenu": false,
            "routes": [
                "java.util.ArrayList",
                [
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 22,
                        "name": "固定资产管理",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 23,
                        "name": "折旧明细表",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 24,
                        "name": "固定资产汇总",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 25,
                        "name": "固定资产类别设置",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    },
                    {
                        "@class": "net.mysass.finance.biz.dto.vo.MenuDataItemVo",
                        "id": 26,
                        "name": "固定资产核对总账",
                        "icon": "",
                        "path": "1",
                        "layout": null,
                        "component": "",
                        "redirect": "",
                        "hideInMenu": false,
                        "routes": null
                    }
                ]
            ]
        }
]
```

# 角色绑定资源

角色绑定资源的类似于角色绑定菜单

功能需求：

-   为每个角色分配可以访问的资源，一个资源对应一个接口，绑定了某个资源就具有某个资源的访问权限

-   角色绑定的资源，可以根据复选框的选中状态决定资源是否绑定到角色中
    -   选中，角色绑定资源（还可以存入缓存）
    -   未选中，角色取消绑定资源
-   查询某个角色可以访问的资源
    -   返回角色绑定的资源id列表

## 接口设计

| **模块** | **页面** | **接口** | **说明** |
| -------- | ------------------------- | ---------------------- | -------------------------------------------------- |
| 管理后台 | 角色管理-弹出绑定资源弹框 | 查询某个角色绑定的资源 | 返回角色绑定的资源id列表 |
| | | 角色绑定资源 | 1、传入绑定的资源id列表 2、传入解绑的资源id列表 |

与角色绑定菜单类似，依旧也可以使用缓存优化

## 表设计

```mysql
create table sys_role_bind_resource
(
    id               int auto_increment primary key,
    sys_role_id      int        default 0                 not null comment '角色id',
    sys_resource_id  int        default 0                 not null comment '资源id',
    member_id        bigint     default 0                 not null comment '用户id',
    update_member_id bigint     default 0                 not null comment '修改用户id',
    disable          tinyint(1) default 0                 not null comment '是否禁用',
    create_time      datetime   default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime   default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1) default 0                 not null comment '是否删除，0：删除，1：未删除'
) comment '系统角色绑定资源资源';
```

## 角色绑定资源

[**feat: 角色绑定资源功能**](https://gitee.com/ninghongkang/honghe-finance/commit/36183dfdb69bec8017be20130c02e878142b4b4d)

[**fix: 修复角色绑定资源-取消绑定sql语句错误**](https://gitee.com/ninghongkang/honghe-finance/commit/1ea5d845dc6e19634c66cb0cae30c3c80725da6e)

## 查询某个角色绑定的资源

[**feat: 查询角色绑定的资源id列表**](https://gitee.com/ninghongkang/honghe-finance/commit/9f87bca8910d5d3aef8b63e1176a24f22ee391f7)

## 缓存优化

角色绑定资源缓存优化 [**feat: 角色绑定资源功能**](https://gitee.com/ninghongkang/honghe-finance/commit/36183dfdb69bec8017be20130c02e878142b4b4d)

角色管理优化 [**feat: 角色管理缓存优化**](https://gitee.com/ninghongkang/honghe-finance/commit/7154417c5057f4a97fb8f8b0fa58d1b75bcad0f2)

### 缓存设计

使用hash表存储角色绑定的菜单

-   **key**：ROLE_RESOURCE_PERMISSIONS:
-   **hashKey 或者 filed**：角色id
-   **value**：资源列表

角色绑定的资源缓存内容示例

```json
[
    "java.util.HashSet",
    [
        "/sysResource/**",
        "/sysResource/del",
        "/sysResource/create",
        "/user/*",
        "/accountBook/*"
    ]
]
```

# 引入分布式任务调度平台XXL-JOB

项目中使用到xxl-job的地方：

-   微信公众号token需要定期更新，定期更新token到Redis中
-   角色绑定的菜单列表，定时将角色绑定菜单列表刷入Redis中
-   角色绑定的资源列表，定时将角色绑定资源列表刷入Redis中
-   ....

XXL-JOB官网：https://www.xuxueli.com/xxl-job/

XXL-JOB管理后台：https://github.com/xuxueli/xxl-job/releases

## 快速入门

快速入门：https://www.xuxueli.com/xxl-job/#%E4%BA%8C%E3%80%81%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8

### 1、初始化“调度数据库”

请下载项目源码并解压，获取 “调度数据库初始化SQL脚本” 并执行即可。

“调度数据库初始化SQL脚本” 位置为:

```shell
/xxl-job/doc/db/tables_xxl_job.sql
```

调度中心支持集群部署，集群情况下各节点务必连接同一个mysql实例;

如果mysql做主从,调度中心集群节点务必强制走主库;

### 2、 编译源码

XXL-JOB源码结构：

```shell
xxl-job-admin：调度中心
xxl-job-core：公共依赖
xxl-job-executor-samples：执行器Sample示例（选择合适的版本执行器，可直接使用，也可以参考其并将现有项目改造成执行器）
    ：xxl-job-executor-sample-springboot：Springboot版本，通过Springboot管理执行器，推荐这种方式；
    ：xxl-job-executor-sample-frameless：无框架版本；
```

### 3、配置部署“调度中心”

```shell
调度中心项目：xxl-job-admin
作用：统一管理任务调度平台上调度任务，负责触发调度执行，并且提供任务管理平台。
```

#### 步骤一：调度中心配置：

调度中心配置文件地址：

```
/xxl-job/xxl-job-admin/src/main/resources/application.properties
```

调度中心配置内容说明：

```properties
### 调度中心JDBC链接：链接地址请保持和 2.1章节 所创建的调度数据库的地址一致
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root_pwd
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

### 报警邮箱
spring.mail.host=smtp.qq.com
spring.mail.port=25
spring.mail.username=xxx@qq.com
spring.mail.password=xxx
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true
spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory

### 调度中心通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=

### 调度中心国际化配置 [必填]： 默认为 "zh_CN"/中文简体, 可选范围为 "zh_CN"/中文简体, "zh_TC"/中文繁体 and "en"/英文；
xxl.job.i18n=zh_CN

## 调度线程池最大线程配置【必填】
xxl.job.triggerpool.fast.max=200
xxl.job.triggerpool.slow.max=100

### 调度中心日志表数据保存天数 [必填]：过期日志自动清理；限制大于等于7时生效，否则, 如-1，关闭自动清理功能；
xxl.job.logretentiondays=30
```

#### 步骤二：部署项目：

如果已经正确进行上述配置，可将项目编译打包部署。

调度中心访问地址：<http://localhost:8080/xxl-job-admin> (该地址执行器将会使用到，作为回调地址)

默认登录账号 “admin/123456”, 登录后运行界面如下图所示。

![1723798840785](assets/xxl-job/1723798840785.png)

至此“调度中心”项目已经部署成功。

#### 步骤三：调度中心集群（可选）：

调度中心支持集群部署，提升调度系统容灾和可用性。

调度中心集群部署时，几点要求和建议：

-   DB配置保持一致；
-   集群机器时钟保持一致（单机集群忽视）；
-   建议：推荐通过nginx为调度中心集群做负载均衡，分配域名。调度中心访问、执行器回调配置、调用API服务等操作均通过该域名进行。

#### 其他：Docker 镜像方式搭建调度中心：

-   下载镜像

```shell
// Docker地址：https://hub.docker.com/r/xuxueli/xxl-job-admin/     (建议指定版本号)
docker pull xuxueli/xxl-job-admin
```

-   创建容器并运行

```shell
/**
* 如需自定义 mysql 等配置，可通过 "-e PARAMS" 指定，参数格式 PARAMS="--key=value  --key2=value2" ；
* 配置项参考文件：/xxl-job/xxl-job-admin/src/main/resources/application.properties
* 如需自定义 JVM内存参数 等配置，可通过 "-e JAVA_OPTS" 指定，参数格式 JAVA_OPTS="-Xmx512m" ；
*/
docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai" -p 8080:8080 -v /tmp:/data/applogs --name xxl-job-admin  -d xuxueli/xxl-job-admin:{指定版本}
```

### 4、配置部署“执行器项目”

```shell
“执行器”项目：xxl-job-executor-sample-springboot (提供多种版本执行器供选择，现以 springboot 版本为例，可直接使用，也可以参考其并将现有项目改造成执行器)
作用：负责接收“调度中心”的调度并执行；可直接部署执行器，也可以将执行器集成到现有业务项目中。
```

#### 步骤一：maven依赖

确认pom文件中引入了 “xxl-job-core” 的maven依赖；

#### 步骤二：执行器配置

执行器配置，配置文件地址：

```
/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/resources/application.properties
```

执行器配置，配置内容说明：

```shell
### 调度中心部署根地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

### 执行器通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=

### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
xxl.job.executor.appname=xxl-job-executor-sample
### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
xxl.job.executor.address=
### 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
xxl.job.executor.ip=
### 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
xxl.job.executor.port=9999
### 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
### 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
xxl.job.executor.logretentiondays=30
```

补充：

如果accessToken需要使用，则后续使用执行器的项目，accessToken都必须与xxl-job admin（调度中心）中配置的一致

#### 步骤三：执行器组件配置

执行器组件，配置文件地址：

```
/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/java/com/xxl/job/executor/core/config/XxlJobConfig.java
```

执行器组件，配置内容说明：

```
@Beanpublic XxlJobSpringExecutor xxlJobExecutor() {    logger.info(">>>>>>>>>>> xxl-job config init.");    XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();    xxlJobSpringExecutor.setAdminAddresses(adminAddresses);    xxlJobSpringExecutor.setAppname(appname);    xxlJobSpringExecutor.setIp(ip);    xxlJobSpringExecutor.setPort(port);    xxlJobSpringExecutor.setAccessToken(accessToken);    xxlJobSpringExecutor.setLogPath(logPath);    xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);    return xxlJobSpringExecutor;}
```

#### 步骤四：部署执行器项目：

如果已经正确进行上述配置，可将执行器项目编译打部署，系统提供多种执行器Sample示例项目，选择其中一个即可，各自的部署方式如下。

```
xxl-job-executor-sample-springboot：项目编译打包成springboot类型的可执行JAR包，命令启动即可；xxl-job-executor-sample-frameless：项目编译打包成JAR包，命令启动即可；
```

至此“执行器”项目已经部署结束。

更多使用，參考：快速入门：https://www.xuxueli.com/xxl-job/#%E4%BA%8C%E3%80%81%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8

## 定期更新token到Redis中

### 1、创建执行器

配置執行器參考文檔：https://www.xuxueli.com/xxl-job/#4.1%20%E9%85%8D%E7%BD%AE%E6%89%A7%E8%A1%8C%E5%99%A8

添加执行器

![1723799894745](assets/xxl-job/1723799894745.png)

配置执行器名称

![1723800057351](assets/xxl-job/1723800057351.png)

### 2、新建任务

创建定时任务

![1723799828996](assets/xxl-job/1723799828996.png)

![1723800714990](assets/xxl-job/1723800714990.png)

### 3、项目整合XXL-JOB依赖

确认pom文件中引入了 “xxl-job-core” 的maven依赖；

honghe-finance

```xml
</properties>
	<xxl-job.version>2.4.1</xxl-job.version>
</properties>

<dependency>
 <groupId>com.xuxueli</groupId>
 <artifactId>xxl-job-core</artifactId>
 <version>${xxl-job.version}</version>
 </dependency>

</dependencies>
</dependencyManagement>
```

honghe-finance-common

```xml
<dependencies> 
 <dependency>
 <groupId>com.xuxueli</groupId>
 <artifactId>xxl-job-core</artifactId>
 </dependency>
</dependencies>
```

### 4、配置类（执行器组件配置）

从samples中copy即可

```shell
/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/java/com/xxl/job/executor/core/config/XxlJobConfig.java
```

```java
package com.clear.honghefinance.common.config.xxlJob;

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;

/**
 * xxl-job config
 *
 * @author xuxueli 2017-04-28
 */
@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

@Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

@Value("${xxl.job.accessToken}")
    private String accessToken;

@Value("${xxl.job.executor.appname}")
    private String appname;

@Value("${xxl.job.executor.address}")
    private String address;

@Value("${xxl.job.executor.ip}")
    private String ip;

@Value("${xxl.job.executor.port}")
    private int port;

@Value("${xxl.job.executor.logpath}")
    private String logPath;

@Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;

@Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

return xxlJobSpringExecutor;
    }

/**
 * 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
 *
 * 1、引入依赖：
 * <dependency>
 * <groupId>org.springframework.cloud</groupId>
 * <artifactId>spring-cloud-commons</artifactId>
 * <version>${version}</version>
 * </dependency>
 *
 * 2、配置文件，或者容器启动变量
 * spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
 *
 * 3、获取IP
 * String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
 */
}
```

### 5、执行器配置，配置文件

配置文件copy路径：https://www.xuxueli.com/xxl-job/#%E6%AD%A5%E9%AA%A4%E4%BA%8C%EF%BC%9A%E6%89%A7%E8%A1%8C%E5%99%A8%E9%85%8D%E7%BD%AE

application.yml

```yaml
# xxl-job
xxl:
  job:
    ### 调度中心部署根地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
    admin:
      addresses: http://127.0.0.1:8080/xxl-job-admin
    ### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
    executor:
      appname: ${spring.application.name}
      ### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
      address:
      ### 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
      ip:
      ### 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
      port: 9999
      ### 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
      logpath: /honghe-finance/applogs/xxl-job/jobhandler
      ### 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
      logretentiondays: 30
    ### 执行器通讯TOKEN [选填]：非空时启用；
    accessToken: 504e3c5d01fd4e4b828acfe47c7137d9
```

application-local.yml

```yml
# xxl-job
xxl:
  job:
    admin:
      ### 调度中心部署跟地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
      addresses: http://localhost:8080/xxl-job-admin
    ### 执行器通讯TOKEN [选填]：非空时启用；
    accessToken: 504e3c5d01fd4e4b828acfe47c7137d9
```

### 6、设置微信公众号token缓存

```java
package com.clear.honghefinance.wechat.service.impl;

@Service
@Slf4j
public class WechatServiceImpl implements WechatService {

private final String MP_TOKEN_REDIS_CACHE_KEY = "mp_token_redis_cache_key";
	
    // 省略其他。。

/**
     * 从缓存中获取公众号token
     *
     * @param appid
     * @return
     */
    @Override
    public AccessTokenVO getMpAccessTokenByCache(String appid) {
        String cacheKey = redisUtil.buildKey(MP_TOKEN_REDIS_CACHE_KEY, appid);
        String result = redisUtil.get(cacheKey);
        return new Gson().fromJson(result, AccessTokenVO.class);
    }

/**
     * 设置公众号token信息到缓存中
     *
     * @param appid  appid 第三方用户唯一凭证
     * @param secret secret 第三方用户唯一凭证密钥，即appsecret
     */
    @Override
    public void setMpAccessTokenCache(String appid, String secret) {
        AccessTokenVO accessTokenVO = getMpAccessToken(appid, secret);
        String cacheKey = redisUtil.buildKey(MP_TOKEN_REDIS_CACHE_KEY, appid);
        redisUtil.set(cacheKey, new Gson().toJson(accessTokenVO));
    }
}
```

### 7、获取公众号二维码代码优化

由原来的WebClient请求优化为查缓存

```java
package com.clear.honghefinance.biz.service.impl;

@Service
@Slf4j
public class MemberRegServiceImpl implements IMemberRegisterService {
    // 省略其他。。

/**
     * 生成微信公众号二维码（关注微信公众号注册）
     *
     * @param clientId
     * @return
     */
    @Override
    public GenerateMpRegCodeVO generateMpRegCode(String clientId) {
        // 获取微信公众号Access Token
        //        AccessTokenVO mpAccessTokenVO = wechatService.getMpAccessToken(wechatConfig.getMp().getAppId(), wechatConfig.getMp().getSecret());
        // == 获取微信公众号Access Token 查缓存 ==
        AccessTokenVO mpAccessTokenVO = wechatService.getMpAccessTokenByCache(wechatConfig.getMp().getAppId());

// 省略其他。。
    }

}
```

### 8、定时任务获取token

从simple中提供的示例中copy

```shell
/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/java/com/xxl/job/executor/service/jobhandler/SampleXxlJob.java
```

盖吧盖吧，如下：

```java
package com.clear.honghefinance.biz.job;

import com.clear.honghefinance.wechat.config.wechat.WechatConfig;
import com.clear.honghefinance.wechat.service.WechatService;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class WechatJobService {

@Resource
    private WechatService wechatService;
    @Resource
    private WechatConfig wechatConfig;

/**
 * 设置微信公众号token缓存（Bean模式）
 */
 @XxlJob("setMpAccessTokenCacheJobHandler")
 public ReturnT<String> setMpAccessTokenCacheJobHandler() throws Exception {
 XxlJobHelper.log("XXL-JOB, setMpAccessTokenCacheJobHandler -> begin");

try {
            XxlJobHelper.log("更新微信公众号token缓存...");
            wechatService.setMpAccessTokenCache(wechatConfig.getMp().getAppId(), wechatConfig.getMp().getSecret());
            XxlJobHelper.log("微信公众号token缓存更新成功...");
        } catch (Exception e) {
            XxlJobHelper.log("微信公众号token缓存更新失败...");
            return ReturnT.FAIL;
        }
        return ReturnT.SUCCESS;
    }

}
```

参考：

[**feat docs: xxl-job定时获取微信公众号token**](https://gitee.com/ninghongkang/honghe-finance/commit/50f9e075fde838211f909db0efa45b5af5b3f54b)

[**fix: 解决xxl-job报错msg=The access token is wrong（执行器token与调度中心token不一致导致）**](https://gitee.com/ninghongkang/honghe-finance/commit/30fa7a2d6229376f45e94a48edf1aec11656736b)

## 定时将角色绑定菜单列表刷入Redis中

## 1、新建任务

每20分钟更新一次

![1723810977723](assets/xxl-job/1723810977723.png)

## 2、定时任务

[**feat: xxl-job定时将角色绑定菜单列表刷入Redis中**](https://gitee.com/ninghongkang/honghe-finance/commit/6e8c9b4e11989726af5f2769558049173d71e78d)

## 定时将角色绑定资源列表刷入Redis中

## 1、新建任务

每20分钟更新一次

![1723811835991](assets/xxl-job/1723811835991.png)

## 2、定时任务

[**feat: xxl-job定时将角色绑定资源列表刷入Redis中**](https://gitee.com/ninghongkang/honghe-finance/commit/5e3243fc253c42bd1b605f63bf66b0112b7da738)

# 数据字典管理

目前先将 行业 和 会计准则下拉列表 相关数据放入数据字典

![1724149524821](assets/1724149524821.png)

## 功能需求

-   读取行业列表数据
-   读取会计准则列表数据

## 接口设计

| **模块** | **页面**                                       | **接口**     | **说明**         |
| -------- | ---------------------------------------------- | ------------ | ---------------- |
| 管理后台 | 财务设置-账套-编辑账套、财务设置-账套-查看账套 | 行业列表     | 从数据字典中查询 |
|          |                                                | 会计准则列表 | 从数据字典中查询 |

## 表设计

```mysql
create table data_dictionary
(
  id             bigint auto_increment
  primary key,
  data_code_cate varchar(100) default ''                not null comment '数据类型分类编码',
  data_code      varchar(100) default ''                not null comment '数据编码',
  data_value     varchar(200) default ''                not null comment '数据值',
  data_sort      int          default 0                 not null comment '数据字典顺序',
  disable        tinyint(1)   default 0                 not null comment '是否禁用',
  create_time    datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
  update_time    datetime     default CURRENT_TIMESTAMP not null comment '修改时间'
)
    comment '数据字典';
```

## 查询行业数据列表接口

[**feat: 数据字典——查看行业数据字典列表接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/e017bdc49164231f99ee60192b03c7547f5096a8)

## 查询会计准则数据字典列表接口

[**feat: 数据字典——查看会计准则数据字典列表接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/4c0a50d3a373ece832e878c7a81631a058290996)

# 账套管理

**账套是什么？**

在财务软件中，账套是指一组完整的、相对独立的财务账簿和相关的财务信息处理体系。它是财务管理系统中的一个基本概念，用于区分不同企业或组织的财务数据和业务信息。

>   百度百科定义：
>
>   	账套是指存放会计核算对象的所有[会计业务](https://baike.baidu.com/item/会计业务/12715228?fromModule=lemma_inlink)[数据文件](https://baike.baidu.com/item/数据文件/110490?fromModule=lemma_inlink)的总称，账套中包含的文件有[会计科目](https://baike.baidu.com/item/会计科目/4796743?fromModule=lemma_inlink)、[记账凭证](https://baike.baidu.com/item/记账凭证/10836682?fromModule=lemma_inlink)、[会计账簿](https://baike.baidu.com/item/会计账簿/10664357?fromModule=lemma_inlink)、[会计报表](https://baike.baidu.com/item/会计报表/1377515?fromModule=lemma_inlink)等。这个核算对象可以是企业的一个分部，也可以是整个企业集团

具体来说，一个账套通常包含以下内容：

-   1、**总账**： 记录企业的所有财务交易，包括资产、负债、所有者权益、收入和支出等。

-   2、**明细账**： 对总账中的各个账户进行详细的分类和记录，例如，现金账户、银行账户、应收账款、应付账款等。

-   3、**科目设置**： 对财务科目进行设置和管理，包括资产、负债、费用、收入等科目。

-   4、**凭证管理**： 记录每一笔财务交易的凭证，包括借方和贷方金额。

-   5、**报表生成**： 根据账套中的财务数据生成各种财务报表，如资产负债表、利润表、现金流量表等。

一个企业可以有多个账套，每个账套对应一个独立的财务体系。不同的账套之间相互独立，互不影响。企业可能会选择建立多个账套的原因有很多，例如，分支机构的财务数据独立管理、不同业务部门的独立核算等。

总体来说，账套在财务软件中起到了组织、管理和记录财务信息的作用，有助于企业实现财务数据的规范化和系统化管理。

## 功能需求

-   1、根据公司名称和是否禁用来**查询账套列表**（条件查询）
-   2、可以在账套列表中对账套进行**启用**、**禁用**操作
-   3、可以在账套列表对账套进行**编辑**和**删除**操作
-   4、可以**新增**账套

## 接口设计

| **模块** | **页面**                                       | **接口**         | **说明**                                               |
| -------- | ---------------------------------------------- | ---------------- | ------------------------------------------------------ |
| 管理后台 | 财务设置-账套                                  | 账套列表         | 根据公司名称和禁用状态分页查询账套列表公司名称模糊查询 |
|          |                                                | 禁用、启用账套   |                                                        |
|          |                                                | 删除账套         |                                                        |
|          | 财务设置-账套-编辑账套、财务设置-账套-查看账套 | 查看账套（详情） |                                                        |
|          | 财务设置-账套-创建账套                         | 创建账套         |                                                        |
|          |                                                | 行业列表         | 从数据字典中查询                                       |
|          |                                                | 会计准则列表     | 从数据字典中查询                                       |
|          | 财务设置-账套-编辑账套                         | 编辑修改账套     |                                                        |

## 表设计

```mysql
create table account_book
( 
    id                         bigint auto_increment primary key,
    company_name               varchar(200) default ''                not null comment '公司名称',
    unified_social_credit_code varchar(50)  default ''                not null comment '统一社会信用代码',
    industry_id                int          default 0                 not null comment '行业代码id（取数据字典）',
    value_added_tax_cate       tinyint      default 0                 not null comment '增值税种类[0：小规模纳税人；1：一般纳税人]',
    enable_voucher_verify      tinyint(1)   default 0                 not null comment '凭证是否审核[0：不审核；1：审核]',
    start_time                 datetime     default CURRENT_TIMESTAMP not null comment '账套启用年月',
    accounting_standard        tinyint      default 0                 not null comment '会计准则[0：小企业会计准则；1：企业会计准则；2：民间非盈利组织会计制度；3：农民专业合作社财务会计制度]',
    enable_fixed_assets        tinyint(1)   default 0                 not null comment '是否启用固定资产模块[0：不启用；1：启用]',
    enable_capital             tinyint(1)   default 0                 not null comment '是否启用资金模块[0：不启用；1：启用]',
    enable_psi                 tinyint(1)   default 0                 not null comment '是否启用进销存[0：不启用；1：启用]',
    tenant_id                  bigint       default 0                 not null comment '租户id',
    member_id                  bigint       default 0                 not null comment '用户id',
    update_member_id           bigint       default 0                 not null comment '修改用户id',
    disable                    tinyint(1)   default 0                 not null comment '是否禁用',
    create_time                datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                   tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
) comment '账套';
```

说明：

enable_psi 字段目前暂未使用

## 创建账套接口

功能需求：

-   输入公司名称
-   输入统一社会信用代码（每个公司唯一，不重复）
-   选择行业（由数据字典提供）
-   选择增值税种类
    -   小规模纳税人
    -   一般纳税人
-   账套启用的年月
-   选择会计准则（由数据字典提供）
-   选择凭证是否需要审核
-   选择是否启用固定资产模块
-   选择资金模块

[**feat: 创建账套接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/f3e31034090f0a7721356a7372f389fdfffdd195)

[**refactor: 优化AccountBookService创建账套的冗余代码**](https://gitee.com/ninghongkang/honghe-finance/commit/ac05ed165c3a51c8ab6d9069b6f68ade9883fc06)

## 编辑账套接口

前提：

-   获取账套详情接口

功能需求：

-   根据获取账套详情接口回显的数据，对其进行一定的更改
-   规定：统一社会信用代码、账套启用的年月、会计准则不能修改
    -   前端通过表单控件的方式禁用修改（防君子不防小人）
    -   后端没有进行太大限制
-   对账套进行修改后，提交保存即可

[**feat: 编辑账套接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/5796f76d39f8ec3b82662f704ad49a497ed75944)

[**refactor: 重构AccountBookService修改账套代码**](https://gitee.com/ninghongkang/honghe-finance/commit/8d05083080158bb21e1f84cd454c23ef7a6c02e4)

## 禁用启用账套接口

[**feat: 禁用启用账套接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/2883e5024dd627956e078d8621d132abd80508bc)

[**refactor: 重构AccountBookService禁用启动账套代码**](https://gitee.com/ninghongkang/honghe-finance/commit/3af53e907fa79ec6cde172c09ec37aaaefdd5a64)

## 删除账套接口

[**feat: 删除账套接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/95b439b7c096e8f4c2bcccb9dd84894854e38942)

[**fix: 修复AccountBookService删除账套**](https://gitee.com/ninghongkang/honghe-finance/commit/71d612bffd0a02ee4877929508ad77318a287924)

## 查询账套列表接口

[**feat: 查询账套列表接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/06aae1baebce6d9ad1b83e01dce156cc729da7d6)

[**refactor: 调整AccountBookService查询账套列表**](https://gitee.com/ninghongkang/honghe-finance/commit/3c67b7d60419edb06e6b4ec329a424e8057828a0)

## 获取账套详情接口

[**feat: 获取账套详情接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/bcb334b7894e943521f30fa92e0076e8a0f1d491)

# 币别管理

币别管理是财务管理中的一个重要组成部分，特别是在涉及多币种业务的企业中。币别管理主要用于管理和维护不同货币的信息，确保企业在处理跨国交易、汇率转换和财务报表编制时能够准确地处理各种货币。

在财务系统中，**本位币**（也称为基准货币）是指一个公司或组织用于报告其财务状况和业务交易的主要货币单位。本位币通常是公司所在国家的法定货币，但在跨国公司或国际组织中，本位币可能是任何一种货币，通常是公司或组织的运营地或总部所在国家的货币。

本项目规定：

-   一个租户只能设置一个本位币。

## 功能要求

-   每个租户默认会初始化一条本位币数据
-   查询所有币别，无需分页（因为不可能有很多个币种，全世界大概170种）
    -   关于排序，本位币排第一个，然后按编码升序排序
-   创建币别（一个租户只能使用一个编码，编码唯一）
-   删除币别
    -   删除需要判断使用状态，若被使用则不允许删除
-   修改币别（一个租户只能使用一个编码，编码唯一）

补充：

创建和修改币别时，需要对币别编码进行唯一性校验，确保系统中不存在相同编码的币别

## 接口设计

| **模块** | **页面**               | **接口**         | **说明**                                               |
| -------- | ---------------------- | ---------------- | ------------------------------------------------------ |
| 管理后台 | 财务设置-币别          | 币别列表         |                                                        |
|          | 财务设置-币别          | 删除币别         |                                                        |
|          | 财务设置-币别-创建币别 | 创建币别         |                                                        |
|          | 财务设置-币别-币别详情 | 修改币别         |                                                        |
|          | 财务设置-币别-币别详情 | 查询币别详情     |                                                        |
|          | 【内部方法】           | 增加币别使用计数 | 在有使用币别的地方增加使用次数（用于提升查询性能）     |
|          | 【内部方法】           | 扣减币别使用计数 | 在移除不使用币别的地方减少使用次数（用于提升查询性能） |

## CRUD

[**feat: 币别管理CURD**](https://gitee.com/ninghongkang/honghe-finance/commit/6d2c66ecc7dacb301a26a50b57f1e3f28d9ee389)

[**feat: 币别管理——新增增加币别使用计数、减少币别使用计数方法（未暴露接口）**](https://gitee.com/ninghongkang/honghe-finance/commit/3c36c1dc80f980aa260177d3ac891d86031c2aac)

[**feat: 币别管理——新增根据ids查询币别列表方法（未暴露接口）**](https://gitee.com/ninghongkang/honghe-finance/commit/dccd4d5ed51143b25db2b3603b55bf502afbd702)

# 凭证字管理

凭证字管理通常指的是在会计软件中对于不同类型的会计凭证进行分类和标识的过程。凭证字是指在会计凭证上用来表示凭证性质的文字，比如“收”、“付”、“转”、“记”等，用以区分不同的业务类型。

-   “收款凭证”通常使用“收”作为凭证字，它主要用于记录收取现金或银行存款的交易。
-   “付款凭证”则使用“付”作为凭证字，用于记录支付现金或银行存款的交易。
-   “转账凭证”的凭证字是“转”，它用于记录不涉及现金或银行存款的转账交易。
-   “记款凭证”或“记账凭证”则使用“记”作为凭证字，用于一般的记账操作。

这些凭证字在财务处理过程中起到了重要的作用，帮助会计人员快速、准确地识别和处理不同类型的交易。同时，通过合理设置和使用凭证字，可以加强财务管理的规范性和准确性，提高会计工作的效率。

请注意，不同的财务软件或系统可能会有不同的凭证字设置和使用规则，因此在实际应用中需要参考具体的软件或系统说明进行操作。此外，凭证字的填写和管理也需要遵循相关的会计准则和规定，以确保财务信息的真实、准确和完整。

## 功能需求

-   查询凭证字列表（数据量不大无需分页）
-   创建凭证字（默认是非默认）
-   修改凭证字
-   删除凭证字（未使用才能删除）
-   设置默认凭证字（只能有一个默认）

## 接口设计

| **模块** | **页面**            | **接口**           | **说明**                                   |
| -------- | ------------------- | ------------------ | ------------------------------------------ |
| 管理后台 | 财务设置-凭证字列表 | 查询凭证字列表     |                                            |
|          |                     | 删除凭证字         | 已使用的凭证字不能删除                     |
|          |                     | 设置默认凭证字     | 设置某个为默认凭证字时，其他的修改为非默认 |
|          | 财务设置-新增凭证字 | 创建凭证字         | 凭证字必须唯一                             |
|          | 财务设置-编辑凭证字 | 编辑凭证字         | 凭证字必须唯一                             |
|          | 财务设置-编辑凭证字 | 查询凭证字详情     |                                            |
|          | 【内部方法】        | 增加凭证字引用计数 | 提供外部模块调用，未暴露接口               |
|          | 【内部方法】        | 扣减凭证字引用计数 | 提供外部模块调用，未暴露接口               |

## 表设计

```mysql
create table voucher_word_config
(
    id               bigint auto_increment primary key,
    voucher_word     varchar(50) default ''                not null comment '凭证字',
    print_title      varchar(50) default ''                not null comment '打印标题',
    default_flag     tinyint(1)  default 0                 not null comment '是否是默认[0:否，1：默认]',
    tenant_id        bigint      default 0                 not null comment '租户id',
    use_count        int         default 0                 not null comment '使用计数',
    disable          tinyint(1)  default 0                 not null comment '是否禁用',
    member_id        bigint      default 0                 not null comment '用户id',
    update_member_id bigint      default 0                 not null comment '修改用户id',
    create_time      datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除',
    constraint voucher_word_config_tenant_id_voucher_word_uindex
        unique (tenant_id, voucher_word)
)
    comment '凭证字配置';
```

## CRUD

[**feat: 凭证字管理——创建凭证字接口**](https://gitee.com/ninghongkang/honghe-finance/commit/d2258e7f77cc4f89930322b6383dd325938c1443)

[**feat: 凭证字管理——修改凭证字接口**](https://gitee.com/ninghongkang/honghe-finance/commit/2aa392f033cd14fd97a84e1d6f3419bd28840ef5)

[**feat: 凭证字管理——修改默认凭证字接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/398a18a2f8c570a42d5861b9099b2d8bb9f68ba1)

[**feat: 凭证字管理——删除凭证字接口**](https://gitee.com/ninghongkang/honghe-finance/commit/2e4b6bbe98e9d24b827d5929d9ae92a893467312)

[**feat: 凭证字管理——查询凭证字接口、查询凭证字明细接口开发**](https://gitee.com/ninghongkang/honghe-finance/commit/6a89df9307b69ca99619b3ae847f68b4a6186157)

# 辅助核算类别管理

**辅助核算是给科目用的**。辅助核算是财务处理的一种补充，一般通过核算项目来实现，包括数量核算、部门核算等。辅助核算的设置可以使会计科目进行更为明细的核算，它相当于会计科目的延伸，并且具有更加灵活方便的特性。一个辅助核算可以在多个科目下使用，一个会计科目也可以设置单一或多个辅助核算。

具体来说，一些常见的会计科目，如应收账款、应付账款、预收账款、预付账款、其他应收款、其他应付款等，都可能需要根据企业的实际情况设置辅助核算。例如，当企业的供应商或客户较多时，应付账款或应收账款科目可以设置辅助核算，以更详细地记录和跟踪与这些供应商或客户的交易。

使用辅助核算后，当录入凭证时，不仅会有相关科目的总分类账、明细账等正式账簿，还会生成辅助核算账簿，方便用户分析特定的数据报表。这对于企业来说，可以更好地满足其管理和决策的需要，提高财务管理的效率和准确性。

因此，辅助核算确实是针对科目来设置的，它有助于实现更广泛的账务处理，使企业的财务管理更加精细化和高效化。

辅助核算类别是对辅助核算进行归类有系统内置的和自定义的类别

## 功能需求

-   系统内置的辅助核算类别不可删除和编辑
-   已被其他模块使用的类别不可删除
-   可创建自定义辅助核算类别，类别的字段可以自定义，最多8个自定义字段
-   查询所有类别，无需分页

## 接口设计

| **模块** | **页面**                               | **接口**               | **说明**                                                     |
| -------- | -------------------------------------- | ---------------------- | ------------------------------------------------------------ |
| 管理后台 | 辅助核算-辅助核算类别列表              | 查询辅助核算类别列表   |                                                              |
|          |                                        | 删除自定义辅助核算类别 | 只能删除自定义的，内置的辅助核算类别不可删除，已经被使用的辅助核算类别不可删除 |
|          | 辅助核算-辅助核算类别列表-创建类别弹窗 | 创建自定义辅助核算类别 | 可以自定义字段                                               |
|          | 辅助核算-辅助核算类别列表-编辑类别弹窗 | 编辑自定义辅助核算类别 | 可以自定义字段                                               |
|          |                                        | 查看自定义辅助核算类别 |                                                              |
|          | 【内部方法】                           | 增加使用计数           | 未暴露接口                                                   |
|          | 【内部方法】                           | 减少使用计数           | 未暴露接口                                                   |

## 表设计

```mysql
create table assist_calculate_cate
(
    id               bigint auto_increment primary key,
    name             varchar(50) default ''                not null comment '辅助核算类别名称',
    level            int         default 0                 not null comment '辅助核算类别[0：系统，不能删除，1：自定义，可自行删除]',
    code             varchar(50) default ''                not null comment '类别编码',
    customer_column  json                                  null comment '自定义列,columnName表示字段名称，column_alias字段别名，["columnName":"c1","columnAlias":"客户编码"]',
    sort             int         default 0                 not null comment '排序',
    tenant_id        bigint      default 0                 not null comment '租户id',
    member_id        bigint      default 0                 not null comment '用户id',
    update_member_id bigint      default 0                 not null comment '修改用户id',
    disable          tinyint(1)  default 0                 not null comment '是否禁用',
    create_time      datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    use_count        int         default 0                 not null comment '使用计数',
    del_flag         tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算类别';
```

## CRUD

[**feat: 辅助核算类别管理CRUD**](https://gitee.com/ninghongkang/honghe-finance/commit/91b1af76e605c4f9038f3e3ddd4cea3120dc588b)

[**feat: 辅助核算类别管理——新增增加辅助核算类别使用计数、减少辅助核算类别使用计数方法（未暴露接口）**](https://gitee.com/ninghongkang/honghe-finance/commit/f7f004ff8cb8c236f16f8d39820cb873f071cc7a)

[**feat: 辅助核算类别管理——新增根据ids查询辅助核算类别列表方法（未暴露接口）**](https://gitee.com/ninghongkang/honghe-finance/commit/fe23bf751d0a384da4ee0bd12c6c9055000165cf)

[**feat: 辅助核算类别管理——新增新增增加辅助核算类别使用计数、减少辅助核算类别使用计数方法（未暴露接口）**](https://gitee.com/ninghongkang/honghe-finance/commit/31d5e36c7847497efaa2219cdb454147510b7698)

# 辅助核算管理（引入工厂+策略模式）

每个辅助核算类别下面都对应的辅助核算数据，每类数据都有编码、名称、助记码、备注、辅助核算类别id（用于标识是哪类辅助核算），然后是每类的差异字段。

## 功能要求

-   将公共字段抽离出来统一存放在一张主表中，方便使用编码和名称对所有表进行搜索
-   所有分类创建和保存时都会存主表和分类表中
-   所有类别辅助核算在分页查询时都是通过编码或名称就行搜索的，由于不提倡联表操作，先进行主表筛选，然后通过id关联分类表数据
-   删除、禁用启用都是在主表进行操作
-   列表数据显示的字段是根据辅助核算分类所配置的自定义字段来显示（自定义类别）
-   详情页显示的字段是根据辅助核算分类所配置的自定义字段来显示（自定义类别）

## 接口设计

| **模块** | **页面**                  | **接口**         | **说明**                                               |
| -------- | ------------------------- | ---------------- | ------------------------------------------------------ |
| 管理后台 | 辅助核算-客户弹窗         | 查询客户列表     | 分页查询                                               |
|          |                           | 新建客户         |                                                        |
|          |                           | 编辑客户         |                                                        |
|          |                           | 查看客户详情     |                                                        |
|          | 辅助核算-供应商弹窗       | 查询供应商列表   |                                                        |
|          |                           | 新建供应商       |                                                        |
|          |                           | 编辑供应商       |                                                        |
|          |                           | 查询供应商详情   |                                                        |
|          | 辅助核算-职员弹窗         | 查看职员列表     |                                                        |
|          |                           | 创建职员         |                                                        |
|          |                           | 编辑职员         |                                                        |
|          |                           | 查询职员详情     |                                                        |
|          | 辅助核算-部门弹窗         | 查询部门列表     |                                                        |
|          |                           | 新建部门         |                                                        |
|          |                           | 编辑部门         |                                                        |
|          |                           | 查询部门详情     |                                                        |
|          | 辅助核算-项目弹窗         | 查询项目列表     |                                                        |
|          |                           | 新建项目         |                                                        |
|          |                           | 编辑项目         |                                                        |
|          |                           | 查看项目详情     |                                                        |
|          | 辅助核算-现金流弹窗       | 查看现金流列表   |                                                        |
|          |                           | 新建现金流       | 暂未实现                                               |
|          |                           | 编辑现金流       | 暂未实现                                               |
|          |                           | 查看现金流详情   | 暂未实现                                               |
|          | 辅助核算-所有类别辅助核算 | 删除辅助核算     | 内置辅助核算不能删除，被其他模块引用的辅助核算不能删除 |
|          | 辅助核算-所有类别辅助核算 | 禁用启用辅助核算 |                                                        |

## 表设计

### 辅助核算汇总表（主表）

```mysql
create table assist_calculate_summary
(
    id                         bigint auto_increment primary key,
    name                       varchar(50)  default ''                not null comment '辅助核算名称',
    code                       varchar(50)  default ''                not null comment '编码',
    disable                    tinyint(1)   default 0                 not null comment '是否禁用',
    member_id                  bigint       default 0                 not null comment '用户id',
    update_member_id           bigint       default 0                 not null comment '修改用户id',
    del_flag                   tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除',
    mnemonic_code              varchar(50)  default ''                not null comment '助记码',
    assist_calculate_cate_id   bigint       default 0                 not null comment '辅助核算类别id',
    tenant_id                  bigint       default 0                 not null comment '租户id',
    assist_calculate_cate_code varchar(50)  default ''                not null comment '辅助核算类别编码',
    notes                      varchar(200) default ''                not null comment '备注',
    use_count                  int          default 0                 not null comment '使用计数',
    create_time                datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    constraint assist_calculate_summary_idx1
        unique (tenant_id, assist_calculate_cate_id, code)
)
    comment '辅助核算汇总表（所有类别）';
```

### 辅助核算自定义表

```mysql
create table assist_calculate_custom
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint       default 0                 not null comment '辅助核算id',
    tenant_id                   bigint       default 0                 not null comment '租户id',
    c1                          varchar(200) default ''                not null comment '自定义字段1',
    c2                          varchar(200) default ''                not null comment '自定义字段2',
    c3                          varchar(200) default ''                not null comment '自定义字段3',
    c4                          varchar(200) default ''                not null comment '自定义字段4',
    c5                          varchar(200) default ''                not null comment '自定义字段5',
    c6                          varchar(200) default ''                not null comment '自定义字段6',
    c7                          varchar(200) default ''                not null comment '自定义字段7',
    c8                          varchar(200) default ''                not null comment '自定义字段8',
    c9                          varchar(200) default ''                not null comment '自定义字段9',
    c10                         varchar(200) default ''                not null comment '自定义字段10',
    disable                     tinyint(1)   default 0                 not null comment '是否禁用',
    member_id                   bigint       default 0                 not null comment '用户id',
    update_member_id            bigint       default 0                 not null comment '修改用户id',
    create_time                 datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算自定义表';
```

### 客户辅助核算表

```mysql
create table assist_calculate_customer
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint       default 0                 not null comment '辅助核算id',
    tenant_id                   bigint       default 0                 not null comment '租户id',
    customer_cate               varchar(200) default ''                not null comment '客户类别',
    address                     varchar(200) default ''                not null comment '详细地址',
    contacts                    varchar(50)  default ''                not null comment '联系人',
    phone                       varchar(20)  default ''                not null comment '手机',
    unified_social_credit_code  varchar(50)  default ''                not null comment '统一社会信用代码',
    province_code               varchar(50)  default ''                not null comment '省份编码',
    city_code                   varchar(50)  default ''                not null comment '城市编码',
    county_code                 varchar(50)  default ''                not null comment '县级编码',
    disable                     tinyint(1)   default 0                 not null comment '是否禁用',
    member_id                   bigint       default 0                 not null comment '用户id',
    update_member_id            bigint       default 0                 not null comment '修改用户id',
    create_time                 datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算客户表';
```

### 部门辅助核算表

```mysql
create table assist_calculate_department
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint      default 0                 not null comment '辅助核算id',
    tenant_id                   bigint      default 0                 not null comment '租户id',
    manager                     varchar(50) default ''                not null comment '部门负责人',
    phone                       varchar(20) default ''                not null comment '手机',
    start_date                  datetime                              null comment '入职日期',
    revoke_date                 datetime                              null comment '撤销日期',
    disable                     tinyint(1)  default 0                 not null comment '是否禁用',
    member_id                   bigint      default 0                 not null comment '用户id',
    update_member_id            bigint      default 0                 not null comment '修改用户id',
    create_time                 datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算部门表';
```

### 职员辅助核算表

```mysql
create table assist_calculate_employee
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint      default 0                 not null comment '辅助核算id',
    tenant_id                   bigint      default 0                 not null comment '租户id',
    sex                         tinyint     default 0                 not null comment '0：未知，1：男，2：女',
    department_code             varchar(50) default ''                not null comment '部门编码',
    department_name             varchar(50) default ''                not null comment '部门名称',
    position                    varchar(50) default ''                not null comment '职务',
    job                         varchar(50) default ''                not null comment '岗位',
    phone                       varchar(20) default ''                not null comment '手机',
    birthday                    datetime                              null comment '生日',
    start_date                  datetime                              null comment '入职日期',
    departure_date              datetime                              null comment '离职日期',
    disable                     tinyint(1)  default 0                 not null comment '是否禁用',
    member_id                   bigint      default 0                 not null comment '用户id',
    update_member_id            bigint      default 0                 not null comment '修改用户id',
    create_time                 datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算职员表';
```

### 存货辅助核算表

```mysql
create table assist_calculate_inventory
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint      default 0                 not null comment '辅助核算id',
    tenant_id                   bigint      default 0                 not null comment '租户id',
    specifications              varchar(50) default ''                not null comment '规格型号',
    inventory_cate              varchar(50) default ''                not null comment '存货类别',
    units                       varchar(10) default ''                not null comment '计量单位',
    start_date                  datetime                              null comment '启用日期',
    end_date                    datetime                              null comment '停用日期',
    disable                     tinyint(1)  default 0                 not null comment '是否禁用',
    member_id                   bigint      default 0                 not null comment '用户id',
    update_member_id            bigint      default 0                 not null comment '修改用户id',
    create_time                 datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算存货表';
```

### 项目辅助核算表

```mysql
create table assist_calculate_project
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint      default 0                 not null comment '辅助核算id',
    tenant_id                   bigint      default 0                 not null comment '租户id',
    responsible_department      varchar(50) default ''                not null comment '负责部门',
    responsible_person          varchar(50) default ''                not null comment '责任人',
    phone                       varchar(20) default ''                not null comment '手机',
    start_date                  datetime                              null comment '开始日期',
    end_date                    datetime                              null comment '结束日期',
    disable                     tinyint(1)  default 0                 not null comment '是否禁用',
    member_id                   bigint      default 0                 not null comment '用户id',
    update_member_id            bigint      default 0                 not null comment '修改用户id',
    create_time                 datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算项目表';
```

### 供应商辅助核算表

```mysql
create table assist_calculate_supplier
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint       default 0                 not null comment '辅助核算id',
    tenant_id                   bigint       default 0                 not null comment '租户id',
    supplier_cate               varchar(200) default ''                not null comment '供应商类别',
    address                     varchar(200) default ''                not null comment '详细地址',
    contacts                    varchar(50)  default ''                not null comment '联系人',
    phone                       varchar(20)  default ''                not null comment '手机',
    disable                     tinyint(1)   default 0                 not null comment '是否禁用',
    unified_social_credit_code  varchar(50)  default ''                not null comment '统一社会信用代码',
    province_code               varchar(50)  default ''                not null comment '省份编码',
    city_code                   varchar(50)  default ''                not null comment '城市编码',
    county_code                 varchar(50)  default ''                not null comment '县级编码',
    member_id                   bigint       default 0                 not null comment '用户id',
    update_member_id            bigint       default 0                 not null comment '修改用户id',
    create_time                 datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算供应商表';
```

### 现金流辅助核算表

```mysql
create table assist_calculate_cash_flow
(
    id                          bigint auto_increment primary key,
    assist_calculate_summary_id bigint       default 0                 not null comment '辅助核算id',
    tenant_id                   bigint       default 0                 not null comment '租户id',
    cash_flow_cate              varchar(50)  default ''                not null comment '现金流类别',
    notes                       varchar(200) default ''                not null comment '备注',
    disable                     tinyint(1)   default 0                 not null comment '是否禁用',
    member_id                   bigint       default 0                 not null comment '用户id',
    update_member_id            bigint       default 0                 not null comment '修改用户id',
    create_time                 datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time                 datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag                    tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '辅助核算现金流表';
```

## CRUD

看git提交记录

# 租户系统配置

## 功能需求

-   获取科目编码长度配置（一级编码长度+二级编码长度+三级编码长度+四级编码长度）
-   4 3 2 2
-   1001 001 01 01

## 接口设计

| **模块** | **页面**               | **接口**         | **说明**                                                     |
| -------- | ---------------------- | ---------------- | ------------------------------------------------------------ |
| 管理后台 | 【内部方法】未暴露接口 | 获取科目长度配置 | 获取科目编码长度配置（一级编码长度+二级编码长度+三级编码长度+四级编码长度 |

## 表设计

```mysql
create table tenant_sys_config
(
    id               bigint auto_increment   primary key,
    tenant_id        bigint       default 0                 not null comment '租户id',
    config_name      varchar(200) default ''                not null comment '配置名称',
    config_key       varchar(50)  default ''                not null comment '配置key',
    config_value     json                                   not null comment '配置内容',
    disable          tinyint(1)   default 0                 not null comment '是否禁用',
    member_id        bigint       default 0                 not null comment '用户id',
    update_member_id bigint       default 0                 not null comment '修改用户id',
    create_time      datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除',
    constraint tenant_sys_config_tenant_id_config_key_uindex  unique (tenant_id, config_key)
)
    comment '租户系统配置';
```

## 方法实现

[**feat: 租户系统配置——获取科目长度配置（未暴露接口）**](https://gitee.com/ninghongkang/honghe-finance/commit/db01f2c363ddf2b98cbc348ff710afa5c3ed1e22)

# 科目管理

财务软件中的科目，也称为会计科目，是会计体系中必不可少的一环，用于分类和记录企业的各项经济业务和财务活动。这些科目是财务软件进行自动化财务记录和管理的基础，通过它们，企业可以高效地管理财务，确保财务报表的准确性和及时性。

一般来说，财务软件中的科目主要包括以下几类：

1.  资产账户：主要用来记录企业的资产情况，包括货币账户和非货币账户。货币账户记录的是现金、银行存款等货币资金的收支情况，非货币账户则记录的是存货、固定资产等非货币性资产的增减变动。
2.  负债账户：用于记录企业的负债情况，包括短期和长期贷款、应付账款、预收账款等。这些科目反映了企业应当支付给他人的款项。
3.  权益账户：主要用来记录企业的权益变动情况，如股东投入的资本、留存收益等。这些科目反映了企业的所有者权益状况。
4.  损益账户：用来记录企业的收入和费用，以及最终的净利润。这个账户可以帮助企业了解自身的盈利状况。
5.  一般性账户：用于记录其他一般性的财务活动，如工资支出、借款利息收入、手续费等。

除了上述常见的科目外，财务软件还可以根据企业的特定需求添加其他科目，如固定资产、借款、利息、投资、捐赠、报销、成本、现金流、税务等。这些科目的设置和使用，使得企业可以更加全面和详细地记录和管理财务活动。

在使用财务软件时，会计人员可以根据需要新增、修改或删除科目，以满足企业的实际管理需求。同时，财务软件还可以自动计算各类财务报表，帮助管理者快速准确地了解企业的财务状况，从而做出正确的决策。

总的来说，财务软件中的科目是企业进行财务管理和决策的重要工具，它们的有效使用可以提高财务管理的效率和准确性，有助于企业的发展。

## 功能需求

-   系统内置的科目不可删除，不能修改科目编码、名称、上级科目、科目类别，余额方向、助记码。
-   被使用的科目不能修改科目编码、名称，余额方向、余额方向、数量核算、辅助核算、外币核算。
-   创建或修改子科目时子科目继承上级科目已经设置的数量核算、辅助核算、外币核算，上级科目已经设置过的则子科目不能修改，没有设置的可以修改。
-   每个科目下面可以增加子科目，科目层级不超过4层
-   科目编码不能重复（每个租户下面科目编码不能重复）
-   根据科目类别查询科目列表
-   已使用的科目不能删除
-   科目停用时则下面所有的子科目也跟着停用

## 接口设计

| **模块** | **页面** | **接口** | **说明** |
| -------- | ------------- | ------------ | ------------------------------------------------------------ |
| 管理后台 | 科目-科目列表 | 查询科目列表 | 查询（根据科目类别） |
| | | 导出科目 | 根据科目类别导出科目 |
| | | 禁用、启用 | 禁用时下级所有科目都得禁用 |
| | | 删除 | 科目被使用时不能删除 |
| | 科目-创建科目 | 创建科目 | 只能创建系统科目下的子科目，最多创建4级子科目 ，创建子科目时子科目继承已经设置的数量核算、 辅助核算、外币核算，上级科目已经设置过的则 子科目不能修改，没有设置的可以修改。 |
| | 科目-编辑科目 | 编辑科目 | 系统内置科目：不能修改科目编码、名称、上级科目、 科目类别，余额方向、助记码。自定义科目： 不能修改上级科目，科目类别，修改子科目时 子科目继承上级科目已经设置的数量核算、 辅助核算、外币核算，上级科目已经设置过的则子科目不能修改，没有设置的可以修改。 |
| | | | |
| | 【内部方法】 | 增加使用计数 | 未暴露接口 |
| | 【内部方法】 | 减少使用计数 | 未暴露接口 |

## 表设计

```mysql
create table subject
(
    id                      bigint auto_increment primary key,
    pid                     bigint       default 0                 not null comment '父类id',
    tenant_id               bigint       default 0                 not null comment '租户id',
    code                    varchar(50)  default ''                not null comment '科目编码',
    sort                    int          default 0                 not null comment '排序',
    name                    varchar(50)  default ''                not null comment '科目名称',
    mnemonic_code           varchar(50)  default ''                not null comment '助记码',
    balance_direction       tinyint      default 0                 not null comment '余额方向[1：借，2：贷]',
    level                   int          default 0                 not null comment '科目层级',
    calculate_config        json                                   not null comment '核算配置[数量核算，辅助核算，外币核算]',
    del_flag                tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除',
    subject_cate            int          default 0                 not null comment '科目类别：1：资产，2：负债，3：权益，4：成本，5：损益',
    node_depth              int          default 0                 not null comment '节点深度',
    depth_code_length_one   int          default 0                 not null comment '一级节点编码长度',
    depth_code_length_two   int          default 0                 not null comment '二级节点编码长度',
    depth_code_length_three int          default 0                 not null comment '三级编码长度',
    depth_code_length_four  int          default 0                 not null comment '四级编码长度',
    subject_type            tinyint      default 0                 not null comment '科目类型[0：系统科目，不能删除，1：自定义科目，可自行删除]',
    use_count               int          default 0                 not null comment '使用计数',
    parent_subject_disable  tinyint(1)   default 0                 not null comment '上级科目禁用启用状态',
    pid_path                varchar(250) default ''                not null comment '父节点全路径，比如/1/2/3',
    disable                 tinyint(1)   default 0                 not null comment '是否禁用',
    member_id               bigint       default 0                 not null comment '用户id',
    update_member_id        bigint       default 0                 not null comment '修改用户id',
    create_time             datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time             datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    constraint subject_tenant_id_code_uindex
        unique (tenant_id, code)
) comment '科目';
```

## CRUD

# 凭证管理

凭证是记录公司或个人在进行交易或资金往来等财务活动时所生成的一种凭据。它主要包括收款凭证、付款凭证、转账凭证等，用于记录交易和业务活动，是企业业务活动进行记录和凭证化的重要方式，也是进行会计核算、编制财务报表的基础。

凭证在财务软件中起到记录财务信息的作用，方便对账和查询历史记录。通过填写凭证信息，财务人员可以记录每次交易的具体信息，例如客户的姓名、付款时间以及金额等，从而更加清楚地了解企业的经济状况。此外，凭证还可以记录基本的会计科目信息，有助于财务人员对日后的记录和审核工作。

财务软件的凭证主要有两种形式：一种是手工填制的记账凭证，即日常业务中的借方必有现金和银存的收款凭证、贷方必有现金和银存的付款凭证、借贷双方都必无现金和银存的转账凭证，这种凭证可以修改和删除；另一种是计算机自动生成的机制凭证，对于格式和涵义比较固定的转账凭证，财务软件可以自动生成，用户需要审核和记账处理，但不可修改和删除。

总的来说，财务软件的凭证是企业日常财务管理的重要依据，它提高了工作效率，减少了繁琐的手工操作，并且可以通过自动存储和备份减少纸质凭证的管理成本和风险。

# 会计电子档案——文件夹管理

会计电子档案是对会计档案实施电子化管理，避免整理汇总难，信息存储无索引关联，检索效率低，查阅调用难，存在丢失、篡改等安全隐患，而且纸质文件归档成本高，匹配、贴票、装订占用大量人力和时间，不利于长期保存，档案保管占用大量物理空间。

## 功能需求

-   为提升查询性能，每次只查询节点的一级子目录
-   创建目录
-   修改目录
-   删除目录（没有子目录，或者当前目录没有文件才能被删除）

## 接口设计

| **模块** | **页面**     | **接口**       | **说明**                                                     |
| -------- | ------------ | -------------- | ------------------------------------------------------------ |
| 管理后台 | 会计电子档案 | 文件夹列表     | 查询文件夹列表根据父id查询该父节点的所有1级子节点根据sort排序 |
|          |              | 创建文件夹     | 创建子目录                                                   |
|          |              | 修改文件夹     | 修改文件夹名称修改sort顺序                                   |
|          |              | 获取文件夹详情 | 查询文件夹名称，顺序，父级目录名称                           |
|          |              | 删除文件夹     | 删除条件：1、没有子目录2、当前目录没有文件                   |

## 表设计

```mysql
create table folder
(
    id               bigint auto_increment primary key,
    pid              bigint      default 0                 not null comment 'pid',
    name             varchar(50) default ''                not null comment '文件夹名称',
    sort             int         default 0                 not null comment '顺序',
    tenant_id        bigint      default 0                 not null comment '租户id',
    disable          tinyint(1)  default 0                 not null comment '是否禁用',
    member_id        bigint      default 0                 not null comment '用户id',
    update_member_id bigint      default 0                 not null comment '修改用户id',
    create_time      datetime    default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime    default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1)  default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '文件夹';
```

## CRUD

# 会计电子档案-文件管理

会计电子档案是对会计档案实施电子化管理，避免整理汇总难，信息存储无索引关联，检索效率低，查阅调用难，存在丢失、篡改等安全隐患，而且纸质文件归档成本高，匹配、贴票、装订占用大量人力和时间，不利于长期保存，档案保管占用大量物理空间

## 功能需求

-   分页查询文件列表（文件支持缩略图模式和列表模式）
-   可预览图片
-   图片需生成安全连接
-   删除文件
-   上传文件（支持大文件分片上传）

## 接口设计

| **模块** | **页面**     | **接口**     | **说明**                                                     |
| -------- | ------------ | ------------ | ------------------------------------------------------------ |
| 管理后台 | 会计电子档案 | 文件列表     | 可搜索文件支持按文件夹搜索支持缩略图模式和列表模式           |
|          |              | 上传文件     | 1、支持小文件上传（5M以内）2、支持大文件分片上传（5M以上）3、分片上传的文件需要合并，合并完成之后需要删除分片 |
|          |              | 删除文件     |                                                              |
|          |              | 合并文件     | 将上传的分片进行合并（合并完成之后需要删除分片）             |
|          |              | 获取文件地址 | 生成临时的文件地址                                           |
|          |              | 获取文件列表 | 根据文件id                                                   |

表设计

```mysql
create table file
(
    id               bigint auto_increment primary key,
    folder_id        bigint       default 0                 not null comment '文件夹id',
    name             varchar(100) default ''                not null comment '文件名称',
    path             varchar(200) default ''                not null comment '文件路径',
    extension        varchar(20)  default ''                not null comment '文件后缀',
    size             bigint       default 0                 not null comment '文件大小，单位b',
    tenant_id        bigint       default 0                 not null comment '租户id',
    disable          tinyint(1)   default 0                 not null comment '是否禁用',
    member_id        bigint       default 0                 not null comment '用户id',
    update_member_id bigint       default 0                 not null comment '修改用户id',
    create_time      datetime     default CURRENT_TIMESTAMP not null comment '创建时间',
    update_time      datetime     default CURRENT_TIMESTAMP not null comment '修改时间',
    del_flag         tinyint(1)   default 0                 not null comment '是否删除，0：删除，1：未删除'
)
    comment '文件';
```

## CRUD

# 封装MinIO Starter

# 常见错误

## 引入Spring Security导致接口报错401Unauthorized

本项目中，我们并未使用Spring Security进行鉴权，我们在密码加密中用到了，因此需要在SpringBoot启动类中排除Spring Security的自动配置

解决：在你的主配置类上，使用@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})来排除Spring Security的自动配置。

```java
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})  // 完全禁用Spring Security的自动配置
```

这种方法是最直接的，它会完全禁用Spring Security的自动配置，从而避免任何安全相关的默认行为。

注意：

-   确保你使用的Spring Boot和Spring Security版本兼容上述配置。

-   如果你使用的是Spring Security的较新版本，确保使用相应的API和配置方式。

-   在生产环境中禁用安全配置可能会带来安全隐患，请谨慎操作。

## Mp分页不生效问题——引入分页插件解决

Mp分页不生效问题表现为：

1、返回中的pages=0，total=0

2、且查看日志发现，sql语句中并未出现limit关键字，证明sql并未分页查询

解决如下：引入MP分页插件即可

```java
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisPlusConfig {

/**
 * 添加分页插件
 * <div>说明：在未引入分页插件的情况下，MybatisPlus是不支持分页功能的，IService和BaseMapper中的分页方法都无法正常起效</div>
 */
 @Bean
 public MybatisPlusInterceptor mybatisPlusInterceptor() {
 // 初始化核心插件
 MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
 // 添加分页插件
 PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
 paginationInnerInterceptor.setMaxLimit(1000L); // 设置分页上限
 interceptor.addInnerInterceptor(paginationInnerInterceptor);
 return interceptor;
 }
}
```

[**feat fix: 引入mp分页插件解决分页不生效问题（sql中出现LIMIT ?，json中total、pages不为0）**](https://gitee.com/ninghongkang/honghe-finance/commit/d8ec44e690af8f4d3bcf1a635c41645d86ce9d00)

ninghongkang/HongheFinance

简介

发行版

贡献者

近期动态

ninghongkang/HongheFinance .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

ninghongkang/HongheFinance