白糖的记事本

Cube 开发踩坑实录（一）：别样的苹果螺旋现象

Tue, 16 Sep 2025 16:48:00 GMT

前言#

精弘存储立方（简称 Cube）是我们内部自研的对象存储中间件，支持对传统文件系统和 AWS S3 进行连接和操作，为我们其他项目提供了高效统一的对象存储服务。在此之外，我们也根据实际业务需求提供了许多针对图片的特殊功能，例如 Webp 转码存储和缩略图功能等。

然而在开发这些图片功能的过程中，踩过的坑真是数不胜数，正好写两篇博客分享一下这些有趣的问题和最终的解决方法。

发现问题#

在测试项目上线后，一位用户在发布广东美食相关的帖子时，所显示的图片方向与预期不符，用户需要旋转自己的脖子才能看到正确的图像。

奇异搞笑的图片方向

在经过一轮测试后，我们发现这个问题只会出现在苹果设备拍摄的照片上，而在其他设备上则没有问题。于是我们把这种现象形象地称为 “苹果螺旋现象”。

一开始我只以为是 iOS 相机拍摄时的方向策略有问题，所以并没有太放在心上，毕竟图片上传的逻辑就是将文件原样上传到项目服务端，然后送到 Cube 进行转码存储，不应该会在这上面出问题。

直到技术面试那天我和毛衣闲聊时，偶然提到图片元数据这个点，才想起问题出在哪：

iOS 相机拍照后会把图像朝向信息存储在 EXIF 元数据中，而 Golang 官方的 image 库进行解码时只会读取像素信息，并不会根据元数据进行相应的方向旋转处理。

尝试保留元数据#

发现问题后，我脑袋中立刻想到的第一个解决方法就是在编码图片时保留 EXIF 元数据。

然而经过一番尝试后，我发现这条路行不通。

首先，我们在 Cube 中使用 github.com/chai2010/webp 库进行 Webp 编码，而这个库只对 libwebp 的基础编码接口进行了 Golang 封装，并没有暴露 EXIF 的写入接口，这意味着我们只能自己提取元数据，然后手动封装成 EXIF chunk 并插入到 RIFF 容器中。

其次，保留元数据也不利于后续的图像处理，例如在对图片进行缩略图生成时，又要重新进行一遍上述操作，来把元数据封装到 JPEG 缩略图中。

所以最终我还是选择了另一个简单粗暴的方案：直接在上传图片时就对图片进行方向修正，然后再进行编码。

方向修正#

方向修正的实现也比较简单，先读取 EXIF 元数据，然后根据 Orientation 标签的值对图像进行旋转处理即可。

读取元数据可以用 github.com/rwcarlsen/goexif/exif 这个库，将文件读取为 io.Reader 后传入解码器即可。

1
x, err := exif.Decode(exifData)
2
if err != nil {
3
  return nil, err
4
}
5

6
// 读取 Orientation 标签的值
7
tag, err := x.Get(exif.Orientation)
8
if err != nil {
9
  return nil, err
10
}
11

12
// 转换为整数
13
orientation, err := tag.Int(0)
14
if err != nil {
15
  return nil, err
16
}

展开收起

旋转图片的操作可以用 Golang 官方的 image 库进行，不过需要手动映射像素，比较麻烦。

我们可以使用 github.com/disintegration/imaging 这个库，它封装了 FlipH、FlipV、Rotate180 等常用的旋转操作。

以下是根据不同 Orientation 值进行旋转的代码：

1
// applyOrientation 根据 EXIF Orientation 调整图像方向
2
func applyOrientation(img image.Image, orientation int) image.Image {
3
  switch orientation {
4
  case 1: // 正常
5
    return img
6
  case 2: // 水平翻转
7
    return imaging.FlipH(img)
8
  case 3: // 旋转 180°
9
    return imaging.Rotate180(img)
10
  case 4: // 垂直翻转
11
    return imaging.FlipV(img)
12
  case 5: // 顺时针 90° + 水平翻转
13
    return imaging.FlipH(imaging.Rotate270(img))
14
  case 6: // 顺时针 90°
15
    return imaging.Rotate270(img)
16
  case 7: // 顺时针 90° + 垂直翻转
17
    return imaging.FlipV(imaging.Rotate270(img))
18
  case 8: // 逆时针 90°
19
    return imaging.Rotate90(img)
20
  default:
21
    return img
22
  }
23
}

展开收起

最后在执行 webp.Encode 函数前调用 applyOrientation 函数即可。

坐现成的轮椅#

既然已经引入了 imaging 这个库，那它还能帮我们简化更多操作吗？

当然可以，其实 imaging 库内置的解码函数已经提供了自动处理方向的选项，可以直接替换掉 image 库的解码函数。

1
// Before
2
img, _, err := image.Decode(reader)
3
if err != nil {
4
  return nil, err
5
}
6
// 此处省略 20 行读取 orientation 的代码
7
img = applyOrientation(img, orientation)
8

9
// After
10
img, err := imaging.Decode(reader, imaging.AutoOrientation(true))
11
if err != nil {
12
  return nil, err
13
}

此外，缩略图的自动缩放逻辑也能直接用现成的 imaging.Fit 替代。

1
// Before
2
func resizeIfNeeded(img image.Image, targetLongSide int) image.Image {
3
  b := img.Bounds()
4
  w, h := b.Dx(), b.Dy()
5
  longSide, shortSide := max(w, h), min(w, h)
6

7
  if longSide <= targetLongSide {
8
    return img
9
  }
10
  scale := float64(targetLongSide) / float64(longSide)
11
  targetShort := int(float64(shortSide) * scale)
12

13
  var tw, th int
14
  if w > h {
15
    tw, th = targetLongSide, targetShort
16
  } else {
17
    tw, th = targetShort, targetLongSide
18
  }
19

20
  dst := image.NewRGBA(image.Rect(0, 0, tw, th))
21
  draw.Lanczos.Scale(dst, dst.Rect, img, b, draw.Over, nil)
22
  return dst
23
}
24

25
// After
26
func resizeIfNeeded(img image.Image, targetLongSide int) image.Image {
27
  return imaging.Fit(img, targetLongSide, targetLongSide, imaging.Lanczos)
28
}

展开收起

由此可见，image 库自带的处理函数功能较为精简，只提供了最基础的操作和绘图函数，而 imaging 库则提供了完善的封装和更多高级功能，简直是超级轮椅般的存在。

问题解决#

将修复后的版本上线到生产环境后，iPhone 用户拍的照片方向终于恢复正常了。

正着的鲨鱼.jpg

在 Windows 下应用 Git 官方汉化

Sat, 23 Aug 2025 04:46:00 GMT

前言#

今天水群的时候，看到一群友在 Windows 下吃上了中文 Git

群友吃上了中文 Git

与其讨论后得知 Git 官方提供了中文语言包，但是 Git for Windows 并没有打包国际化文件，导致在 Windows 下使用 Git 时默认只能使用英文

于是心血来潮，写篇博客记录下如何在 Windows 下应用 Git 官方汉化

构建翻译文件#

打开 Git 官方仓库，找到 po 目录，可以看到里面有各个语言的翻译文件

.po 文件是 Portable Object 文件，主要用于软件国际化（i18n）和本地化（l10n），它是 GNU gettext 使用的标准格式

要将 .po 文件转换为软件能读取的 .mo 文件，需要使用 msgfmt 命令进行构建

为了方便大家使用，我已经创建了一个构建仓库，每天早上 8 点 Github Action 会自动从上游获取 Git 最新语言文件，如果有更新则自动构建出 .mo 文件并上传到 Release

当然，如果您有 Linux 环境，也可以通过下面的命令来手动构建

Terminal window

1
# 安装 gettext 工具
2
sudo apt-get update && sudo apt-get install -y gettext
3

4
# 构建 zh_CN.mo 文件
5
msgfmt zh_CN.po -o zh_CN.mo

应用翻译文件#

获取构建好的 zh_CN.mo 文件后，将文件名改为 git.mo

打开 C:\Program Files\Git\mingw64\share\locale\zh_CN\LC_MESSAGES，其中 C:\Program Files\Git 是你的 Git 安装目录

如果子目录不存在，则需要手动创建文件夹来补全

然后将 git.mo 文件复制到该目录下

复制到该目录下

最后，新建环境变量 LANG=zh_CN.UTF-8

添加环境变量1

添加环境变量2

效果#

重新打开你的终端，输入 git 命令，享受中文！

效果

精弘网络 Java 后端微课 - EP3 异常捕获与日志记录

Wed, 13 Aug 2025 14:30:00 GMT

接口日志记录#

1
@Slf4j
2
@Component
3
public class AccessLogFilter implements Filter {
4

5
    static {
6
        AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS);
7
    }
8

9
    private static AnsiColor getStatusColor(int status) {
10
        return switch (status / 100) {
11
            case 2 -> AnsiColor.GREEN;
12
            case 4 -> AnsiColor.YELLOW;
13
            case 5 -> AnsiColor.RED;
14
            default -> AnsiColor.DEFAULT;
15
        };
16
    }
17

18
    private static AnsiColor getMethodColor(String method) {
19
        return switch (method) {
20
            case "GET" -> AnsiColor.BLUE;
21
            case "POST" -> AnsiColor.CYAN;
22
            case "PUT" -> AnsiColor.YELLOW;
23
            case "DELETE" -> AnsiColor.RED;
24
            default -> AnsiColor.MAGENTA;
25
        };
26
    }
27

28
    private static String getRemoteAddr(HttpServletRequest request) {
29
        String ip = request.getHeader("x-forwarded-for");
30
        return ip == null ? request.getRemoteAddr() : ip;
31
    }
32

33
    @Override
34
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
35
            throws IOException, ServletException {
36

37
        if (!(request instanceof HttpServletRequest req) || !(response instanceof HttpServletResponse res)) {
38
            chain.doFilter(request, response);
39
            return;
40
        }
41

42
        Instant start = Instant.now();
43
        chain.doFilter(request, response);
44
        Instant end = Instant.now();
45
        long durationMs = Duration.between(start, end).toMillis();
46

47
        int status = res.getStatus();
48
        String method = req.getMethod();
49
        String uri = req.getRequestURI();
50
        String query = req.getQueryString();
51
        String ip = getRemoteAddr(req);
52

53
        // 彩色状态码
54
        String colorStatus = AnsiOutput.toString(
55
                getStatusColor(status),
56
                status,
57
                AnsiColor.DEFAULT
58
        );
59

60
        // 彩色方法
61
        String colorMethod = AnsiOutput.toString(
62
                getMethodColor(method),
63
                method,
64
                AnsiColor.DEFAULT
65
        );
66

67
        log.info("{} | {}ms | {} {} | IP: {}",
68
                colorStatus,
69
                durationMs,
70
                String.format("%-6s", colorMethod),
71
                uri + (query != null ? "?" + query : ""),
72
                ip
73
        );
74
    }
75
}

展开收起

自定义错误类型与错误码聚合#

1
@Getter
2
public class ApiException extends RuntimeException {
3
    private final Integer errorCode;
4
    private final String errorMsg;
5

6
    public ApiException(Integer errorCode, String errorMsg) {
7
        super(errorMsg);
8
        this.errorCode = errorCode;
9
        this.errorMsg = errorMsg;
10
    }
11

12
    public ApiException(Integer errorCode, String errorMsg, Throwable cause) {
13
        super(errorMsg, cause);
14
        this.errorCode = errorCode;
15
        this.errorMsg = errorMsg;
16
    }
17
}

展开收起

1
@Getter
2
public enum ExceptionEnum {
3
    INVALID_PARAMETER(200000, "参数错误"),
4
    RESOURCE_NOT_FOUND(200001, "资源不存在"),
5
    WRONG_USERNAME_OR_PASSWORD(200002, "用户名或密码错误"),
6
    PERMISSION_NOT_ALLOWED(200003, "权限不足"),
7

8
    NOT_FOUND_ERROR(200404, HttpStatus.NOT_FOUND.getReasonPhrase()),
9
    SERVER_ERROR(200500, "系统错误, 请稍后重试"),
10
    ;
11

12
    private final Integer errorCode;
13
    private final String errorMsg;
14

15
    ExceptionEnum(Integer errorCode, String errorMsg) {
16
        this.errorCode = errorCode;
17
        this.errorMsg = errorMsg;
18
    }
19
}

展开收起

错误捕获#

1
@ControllerAdvice
2
@Order(1000)
3
public class GlobalExceptionHandler {
4
    @ExceptionHandler(Exception.class)
5
    @ResponseBody
6
    public AjaxResult<Object> handleGlobalException(Exception e) {
7
        HandlerUtils.logException(e);
8
        return AjaxResult.fail(ExceptionEnum.SERVER_ERROR);
9
    }
10
}

常见参数校验异常：

MethodArgumentNotValidException 参数校验错误
JsonMappingException Json解析失败
HttpMessageNotReadableException Json格式错误
ServletRequestBindingException Query参数错误

常见 404 异常：

NoResourceFoundException 路径不存在
HttpRequestMethodNotSupportedException 请求方法不支持

课外拓展#

这边列出一些可以课外研究研究的方面，以便你对 Spring 框架有更深的理解。

注意：这些教程可能与最新的 Spring 版本有所出入，有疑问可以多上网上搜搜，或者问 Qwen、Deepseek 等大语言模型。

精弘网络 Java 后端微课 - EP2 业务分层与数据库操作

Sun, 10 Aug 2025 06:30:00 GMT

数据库基本概念#

1. 数据库（Database）

存放数据的地方，比如 MySQL、PostgreSQL 就是常见的数据库软件。

2. 表（Table）

数据是按表来存的，就像 Excel 的工作表，每一行是一条记录，每一列是一个字段。

3. 字段（Column）

表里的列，比如 name、age，用来描述数据的属性。

4. 记录 / 行（Row / Record）

表中的一行数据，比如一个用户的信息就是一条记录。

5. 主键（Primary Key）

表中唯一标识一条记录的字段，比如 id。

6. 常见操作（CRUD）

Create：插入数据（INSERT）
Read：查询数据（SELECT）
Update：修改数据（UPDATE）
Delete：删除数据（DELETE）

7. SQL

操作数据库的语言（Structured Query Language），比如：

1
SELECT * FROM user WHERE id = 1;

Mybatis-Plus#

简介#

MyBatis-Plus 是一款 Java ORM（Object Relational Mapping，对象关系映射）框架。

它将数据库表与 Java 类、字段与类属性一一映射，实现数据与对象的自动转换，大幅减少手写 SQL 的工作量。

Mybatis-Plus 官网

它具备以下实用特性：

基于 MyBatis 框架的增强，无需编写 XML 配置文件
内置很多常用的 CRUD 方法
支持条件构造器，写复杂查询不必手写 SQL
提供分页插件、代码生成器等工具，提升开发效率

安装#

1
<dependencyManagement>
2
    <dependencies>
3
        <dependency>
4
            <groupId>com.baomidou</groupId>
5
            <artifactId>mybatis-plus-bom</artifactId>
6
            <version>3.5.12</version>
7
            <type>pom</type>
8
            <scope>import</scope>
9
        </dependency>
10
    </dependencies>
11
</dependencyManagement>
12

13
<dependency>
14
    <groupId>com.baomidou</groupId>
15
    <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
16
</dependency>
17

18
<dependency>
19
    <groupId>com.baomidou</groupId>
20
    <artifactId>mybatis-plus-jsqlparser</artifactId>
21
</dependency>

展开收起

配置数据源#

1
spring:
2
  datasource:
3
    driver-class-name: com.mysql.cj.jdbc.Driver
4
    url: jdbc:mysql://localhost:3306/forum_db?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf-8
5
    username: root
6
    password: 123456

建表并生成实体类#

Mybatis X 插件

业务分层#

分层架构帮助我们组织代码，让每个部分各司其职，提高代码的可维护性和可扩展性

控制器（Controller）：处理 HTTP 请求，调用服务层处理业务逻辑，返回响应结果。
服务层（Service）：定义业务逻辑接口，实现业务逻辑，调用数据访问层操作数据库。
数据访问层（Mapper）：定义数据库操作接口，提供 CRUD 方法操作数据库。
实体类（Entity）：表示数据库表的 Java 类。

持久层接口

条件构造器#

条件构造器

逻辑删除#

逻辑删除支持

自动填充字段#

自动填充字段

1
@Component
2
public class AutoFillHandler implements MetaObjectHandler {
3
    @Override
4
    public void insertFill(MetaObject metaObject) {
5
        this.setFieldValByName("createdAt", LocalDateTime.now(), metaObject);
6
        this.setFieldValByName("updatedAt", LocalDateTime.now(), metaObject);
7
    }
8

9
    @Override
10
    public void updateFill(MetaObject metaObject) {
11
        this.setFieldValByName("updatedAt", LocalDateTime.now(), metaObject);
12
    }
13
}

课外拓展#

身份鉴权#

使用用户ID进行身份鉴权会不会产生安全问题？尝试使用 JWT 或 Session 对登录和鉴权流程进行优化，可自行搜索相关库和技术博客进行学习

Cookie、Session、Token究竟区别在哪？如何进行身份认证，保持用户登录状态？

分页查询#

如果数据量很大，一次性查询所有数据会导致性能问题，尝试学习使用 Mybatis-Plus 提供的分页插件

事务管理#

如果在业务逻辑中需要对多个表进行更新操作，如何确保这些操作要么全部成功，要么全部失败？可以自行搜索了解如何使用 SpringBoot 中的事务管理机制

精弘网络 Java 后端微课 - EP1.5 巧用 Lombok 简化样板代码

Mon, 04 Aug 2025 06:31:00 GMT

导入 Lombok#

1
<dependency>
2
  <groupId>org.projectlombok</groupId>
3
  <artifactId>lombok</artifactId>
4
  <version>1.18.38</version>
5
  <scope>provided</scope>
6
</dependency>

原理简析#

Java 的编译过程可以分成三个阶段：

把所有源文件解析成语法树
调用注解处理器，如果产生了新的源文件则再次编译
分析语法树并转化成类文件

Lombok 会在上述的第二阶段，执行 lombok.core.AnnotationProcessor，它所做的工作就是修改语法树，并将注解对应需要生成的内容全部添加到类文件中。

这样，我们即使没有在源代码中编写的内容，也会存在于生成出来的 class 文件中。

常用注解#

@Getter 和 @Setter#

可以打在字段或者类上，作用是生成对应的 get 和 set 方法。

注意布尔值的命名规则：

1
@Getter
2
public class User {
3
    private boolean bar;    // isBar()
4
    private boolean isBar;  // isBar()
5
    private Boolean foo;    // getFoo()
6
    private Boolean isFoo;  // getIsFoo()
7
}

构造函数相关#

@AllArgsConstructor 生成全参构造函数
@NoArgsConstructor 生成无参构造函数
@RequiredArgsConstructor 生成需要初始化的参数的构造函数

@ToString#

自动生成类的 toString 方法，默认输出类名和所有字段名和值。

@EqualsAndHashCode#

自动生成类属性的比较方法以及对应的 HashCode 计算

1
Account a1 = new Account(1, "小明", 18);
2
Account a2 = new Account(1, "小明", 18);
3
log.info(a1.equals(a2));

@Data#

集大成者，包含了 @Getter、@Setter、@ToString、@EqualsAndHashCode、@RequiredArgsConstructor

@Builder#

生成 Builder 模式的代码，用于创建对象。

@Slf4j#

Simple Logging Facade for Java（简称 SLF4J） 是一个 Java 日志门面（facade）库，其主要作用是为各种日志框架提供统一的日志 API 接口

Spring Boot 默认使用 slf4j-api 作为日志 API，logback-classic 作为默认实现

Lombok 的 @Slf4j 注解会自动生成一个 SLF4J 日志对象，其等效于

1
private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(class);

拓展阅读#

Lombok 官方文档

柏码知识库 - Lombok 极速上手

精弘网络 Java 后端微课 - EP1 控制器的编写和数据绑定

Mon, 04 Aug 2025 06:30:00 GMT

新建工程#

若无法连接到官方 Spring Initializr，可更换到国内站点 https://start.springboot.io/

Spring Web
Spring Validation
MySQL Driver
Lombok

1
<maven.compiler.source>17</maven.compiler.source>
2
<maven.compiler.target>17</maven.compiler.target>
3
<parameters>true</parameters>
4
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
5
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

编写一个控制器#

什么是“控制器”（Controller）#

在 Spring Boot 中，控制器是处理用户请求的入口。

你可以把它想象成一个网站或接口的“接待员”： 👉 用户发来请求，控制器接收、处理，然后返回响应。

@RestController 是什么#

1
@RestController = @Controller + @ResponseBody

用来告诉 Spring 这个类是一个控制器（用来接收 Web 请求），并且返回的是 JSON 数据（而不是 HTML 页面）

@RequestMapping 是什么#

告诉 Spring，这个类负责处理哪个 URL 请求

常用方法：加在类上，定义“公共前缀”

数据绑定#

Query 参数绑定#

1
@GetMapping("/get")
2
public String get(@RequestParam("name") String name) {
3
    return name;
4
}

路径参数绑定#

1
@GetMapping("/get/{name}")
2
public String get(@PathVariable("name") String name) {
3
    return name;
4
}

绑定 Query 或表单到对象#

1
@Data
2
public class User {
3
    private String name;
4
    private Integer age;
5
}
6

7
@GetMapping("/get")
8
public String get(User user) {
9
    return user.toString();
10
}

绑定 JSON 到对象#

1
@Data
2
public class User {
3
    @JsonProperty("first_name")
4
    private String firstName;
5
    private Integer age;
6
}
7

8
@PostMapping("/post")
9
public String post(@RequestBody User user) {
10
    return user.toString();
11
}

参数校验#

1
@NotNull、@NotEmpty、@NotBlank
2

3
@Size、@Email
4

5
@Min、@Max

统一 JSON 响应体#

1
@Data
2
@AllArgsConstructor
3
public class AjaxResult<T> {
4
    public static final String SUCCESS_MSG = "OK";
5
    private Integer code;
6
    private String msg;
7
    private T data;
8

9
    public static <N> AjaxResult<N> success() {
10
        return new AjaxResult<>(HttpStatus.OK.value(), SUCCESS_MSG, null);
11
    }
12

13
    public static <N> AjaxResult<N> success(N data) {
14
        return new AjaxResult<>(HttpStatus.OK.value(), SUCCESS_MSG, data);
15
    }
16

17
    public static <N> AjaxResult<N> fail(Integer code, String msg) {
18
        return new AjaxResult<>(code, msg, null);
19
    }
20
}

展开收起

精弘网络 Java 后端微课 - EP0 前置准备与环境搭建

Mon, 04 Aug 2025 06:29:00 GMT

课程引入#

使用框架：SpringBoot3 + MybatisPlus

Web开发前置知识

需要有 Java 语法基础，参考文档

如果觉得 Java 难度太高，可以选择 Golang 方向：Golang语法课、Gin、Gorm、Viper

技术大作业访问密码: zjutjh2025

环境准备#

基于 WebSocket 协议打造简易聊天服务端

Tue, 11 Mar 2025 10:18:29 GMT

前言#

在本次寒假软件竞赛中，我们决定为系统添加用户间的实时聊天功能。经过综合考量性能、开发难度以及用户体验等因素，我们最终选择基于 WebSocket 协议来实现这一功能。

为什么是 WebSocket？#

WebSocket 是一种基于 TCP 的通信协议，它通过建立一个单一的、持久的连接，实现了客户端与服务器之间的全双工实时通信。相较于传统的 HTTP 协议，WebSocket 在实时通信场景下具有显著优势：

实时双向通信：WebSocket 允许服务器主动向客户端推送消息，而不仅仅是等待客户端的请求。这消除了传统 HTTP 轮询（Polling）方式带来的延迟，使得消息能够即时送达。
高效资源利用：WebSocket 使用单一的、长时间保持的连接，避免了 HTTP 协议每次请求都需要建立和断开连接的开销。这能减少不必要的握手过程，降低服务器的资源消耗，并显著节省带宽。
灵活格式支持：WebSocket 协议本身不对消息格式进行限制，开发者可以根据实际需求选择合适的数据格式，例如 JSON、XML 或 Protobuf 等。

项目实践#

为了在 Golang 中处理 WebSocket 协议的请求，我们首先需要引入一个强大的第三方库 gorilla/websocket。这个库为我们提供了便捷的 WebSocket 操作接口，极大地简化了开发过程。

Terminal window

1
go get github.com/gorilla/websocket

升级 WebSocket 连接#

为了把 HTTP 连接升级到 WS ，我们需要初始化一个 Upgrader 实例。它的用法非常简单，直接传入 HTTP Writer 和 Request 即可。

此处缓冲区我简单设置成 1024 字节，生产环境中如果遇到性能瓶颈可以适当调整。

跨域检测这里直接返回 true，因为路由端已经进行了处理。

1
var upgrader = websocket.Upgrader{
2
  ReadBufferSize:  1024,
3
  WriteBufferSize: 1024,
4
  CheckOrigin: func(_ *http.Request) bool {
5
    return true
6
  },
7
}
8

9
// 用法：将 HTTP 请求升级为 WebSocket 连接
10
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)

构造连接管理器#

1
type ConnectionManager struct {
2
  connections map[uint]*websocket.Conn // 存储连接信息
3
    msgChannel  chan models.Message      // 消息队列，用于异步处理消息
4
  mutex       sync.RWMutex             // 读写锁，保护 connections 的并发访问
5
  stop        atomic.Bool              // 停止标记
6
}

为了让这个管理器能管理连接，我们编写两个方法，一个用于注册 WS 连接，一个用于移除已断开的连接。

1
// registerConnection 注册连接
2
func (cm *ConnectionManager) registerConnection(conn *websocket.Conn, uid uint) {
3
  // 获取历史消息
4
  messages, err := messageService.GetMessagesByUser(uid)
5
  if err != nil {
6
    // ...
7
  }
8

9
  // 注册连接并推送历史消息
10
  cm.mutex.Lock()
11
  cm.connections[uid] = conn
12
  cm.mutex.Unlock()
13
  for _, msg := range messages {
14
    if err := conn.WriteJSON(msg); err != nil {
15
      // ...
16
    }
17
  }
18
}
19

20
// unregisterConnection 移除连接
21
func (cm *ConnectionManager) unregisterConnection(uid uint) {
22
  cm.mutex.Lock()
23
  delete(cm.connections, uid)
24
  cm.mutex.Unlock()
25
}

展开收起

接着，我们编写一个消息处理函数。

首先将传入的消息保存到数据库，由于前端没有保存消息记录，所以我们再把消息推送给发送者和接受者。

1
func (cm *ConnectionManager) handleMessage(message *models.Message) {
2
  // 保存消息到数据库
3
  if err := messageService.CreateMessage(message); err != nil {
4
    zap.L().Warn("Error saving message to database", zap.Error(err))
5
    return
6
  }
7

8
  cm.mutex.RLock()
9
  receiverConn, exists := cm.connections[message.Receiver]
10
  senderConn, senderExists := cm.connections[message.Sender]
11
  cm.mutex.RUnlock()
12

13
  // 推送给接收人
14
  if exists {
15
    if err := receiverConn.WriteJSON(message); err != nil {
16
      // ...
17
    }
18
  }
19

20
  // 推送给发信人
21
  if senderExists {
22
    if err := senderConn.WriteJSON(message); err != nil {
23
      // ...
24
    }
25
  }
26
}

展开收起

在初始化函数中我们启动一个协程，从消息队列中取出消息并送入消息处理方法。

1
func Init() {
2
  go func() {
3
    for !cm.stop.Load() {
4
      msg := <-cm.userChannels
5
      cm.handleMessage(&msg)
6
    }
7
  }()
8
}

编写控制器#

为了接受前端的握手请求，我们像先前那样写一个控制器并挂载到路由上。

先调用 Upgrader 把请求升级到 WS 连接，然后调用连接管理器进行注册，最后通过循环源源不断地读取前端发来的消息，并送入消息队列。

1
func WebSocketController(c *gin.Context) {
2
    // 将 HTTP 请求升级为 WebSocket 连接
3
  conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
4
  if err != nil {
5
    response.AbortWithException(c, apiException.WebSocketError, err)
6
    return
7
  }
8
  defer conn.Close()
9

10
  cm.registerConnection(conn, uid)
11
  for {
12
    msgType, msg, err := conn.ReadMessage()
13
    if err != nil {
14
      cm.unregisterConnection(uid)
15
      break
16
    }
17

18
    if msgType == websocket.TextMessage {
19
            // 反序列化到结构体并送入消息队列
20
      var message models.Message
21
      if err := json.Unmarshal(msg, &message); err != nil {
22
        zap.L().Warn("Error unmarshaling message", zap.Error(err))
23
        continue
24
      }
25
      cm.msgChannel <- message
26
    }
27
  }
28
}

展开收起

至此，一个超级简单的 WebSocket 服务端就完成了。

小结#

这次对 WebSocket 的折腾十分有趣，全双工的通信方式带来的使用体验相比 HTTP 轮询有了质的飞跃。

当然，由于只是花两天时间草草搓的系统，所以项目中仍有许多地方可以改进，如支持发送图片，引入 asynq 等第三方库来完善消息队列等等。更多的探索，相信未来会有机会尝试的。

由于篇幅所限，本文删去了许多非核心代码，若你想参考我的实现，可以直接翻阅原项目代码。

C++ 盲点笔记（三）之指针

Fri, 03 Jan 2025 14:17:08 GMT

指针#

基本使用#

指针是用于存储变量地址的特殊变量。通过指针，可以间接访问或修改变量的值。

1
int num = 10;
2
int* p = &num;
3
*p = 20;

在上述代码中，num 的地址被存入指针 p 中，并通过 *p 进行解引用，间接给 num 赋值。

指针与数组#

数组名在大多数情况下会被解释为指向其第一个元素的指针。由于数组元素在内存中是连续的，因此可以通过指针遍历数组。

1
int arr[5] = {1, 2, 3, 4, 5};
2
int* p = arr; // 等价于 int* p = &arr[0];
3
for (int i = 0; i < 5; ++i) {
4
    cout << *(p + i) << " "; // *(p + i) 等价于 p[i]
5
}

你可以定义一个指针数组用来存储多个指针，或者声明一个数组指针来指向一个数组。

1
int arr[5] = {1, 2, 3, 4, 5};
2

3
// 定义一个指针数组，存储数组中每个元素的地址
4
int *p1[5] = {&arr[0], &arr[1], &arr[2], &arr[3], &arr[4]};
5

6
// 定义一个数组指针，指向整个数组
7
int (*p2)[] = &arr;

优先级：() > [] > *

对于 int *p1[5]，[] 的优先级高，p1 首先被解析为数组，数组中的元素类型为整型指针。

对于 int (*p2)[]，使用 () 提升优先级，强制将 p2 解析为指针。

多级指针#

多级指针是指向指针的指针，通过它我们可以间接访问多级嵌套的变量值。

1
int num = 10;
2
int* p1 = &num;
3
int** p2 = &p1; // p2 是指向 p1 的指针
4
cout << **p2 << endl; // 输出 10

指针与运算符#

指针与运算符经常用来组合出阴间题目，需要多加注意。

1
char s1[20]="123apple",*p=s1, **pp=&p;
2
cout << *pp + 3 << endl; // 输出 apple
3
cout << *p++ << endl; // 输出 1
4
cout << *++p << endl; // 输出 3
5
cout << *pp << endl; // 输出 3apple
6
cout << **pp << endl; // 输出 3

这段代码中：

*pp + 3 等价于 p + 3
*p++ 和 *++p 分别等价于 *(p++) 和 *(++p)
*pp 等价于 p，此时 p 指向 &s1[2]，故连续输出后面的字符串
**pp 等价于 *p，故输出 s1[2]，即为 3

动态内存分配#

在 C++ 中，可以使用 new 和 delete 运算符进行动态内存分配和释放。

1
int* p = new int(10); // 分配一个初始值为 10 的整数
2
delete p; // 释放内存
3

4
int n;
5
cin >> n;
6
int* arr = new int[n]; // 分配包含 n 个整数的数组
7
delete[] arr; // 释放数组内存

使用完动态分配的变量后一定记得调用 delete 或 delete[] 释放内存，否则会导致内存泄漏。

多级指针在动态分配二维数组时非常有用，因为二维数组本质上可以看作是指针的数组。

1
int rows, cols;
2
cin >> rows >> cols;
3

4
// 动态分配一个指针数组
5
int** arr = new int*[rows];
6

7
// 为数组分配每一行的空间
8
for (int i = 0; i < rows; ++i) {
9
    arr[i] = new int[cols];
10
}
11

12
// 释放内存
13
for (int i = 0; i < rows; ++i) {
14
    delete[] arr[i]; // 释放每行的内存
15
}
16
delete[] arr; // 释放指针数组的内存

展开收起

如果你不想使用多级指针，也可以使用上文提到的数组指针。

这种方式不太常见，并且写法有点反直觉。

1
int rows, cols;
2
cin >> rows >> cols;
3

4
// 动态分配一个连续的二维数组
5
int (*arr)[cols] = new int[rows][cols]; // 指向包含 cols 个整数的数组
6

7
// 释放内存
8
delete[] arr;

常量指针与指针常量#

常量指针 const int* p 或 int const *p：指针指向的值不可修改，但指针本身可以指向其他地址。
指针常量 int* const p：指针本身不可修改，但指向的值可以修改。
指向常量的指针常量 const int* const p：指针本身和指向的值都不可修改。

函数指针#

函数指针用于指向函数，可以通过它调用函数。

1
int add(int x, int y) {
2
    return x + y;
3
}
4

5
// 声明一个函数指针，指向 add 函数
6
int (*p)(int, int) = add;

函数指针常用于自定义排序条件，以下是一个冒泡排序示例，它通过传入函数指针来实现排序的灵活性。

1
#include <iostream>
2
using namespace std;
3

4
// 比较函数：降序
5
bool descending(int a, int b) {
6
    return a > b; // 如果 a > b，则不需要交换
7
}
8

9
// 比较函数：升序
10
bool ascending(int a, int b) {
11
    return a < b; // 如果 a < b，则不需要交换
12
}
13

14
// 冒泡排序函数
15
void bubbleSort(int arr[], int size, bool (*compare)(int, int)) {
16
    for (int i = 0; i < size - 1; ++i) {
17
        for (int j = 0; j < size - i - 1; ++j) {
18
            // 使用函数指针进行比较，若为 false 则交换元素
19
            if (!compare(arr[j], arr[j + 1])) {
20
                int temp = arr[j];
21
                arr[j] = arr[j + 1];
22
                arr[j + 1] = temp;
23
            }
24
        }
25
    }
26
}
27

28
int main() {
29
    int arr[] = {4, 2, 3, 5, 1};
30
    int size = sizeof(arr) / sizeof(int);
31

32
    // 使用冒泡排序（升序）
33
    bubbleSort(arr, size, ascending);
34
    for (int i = 0; i < size; ++i) { // 输出：1 2 3 4 5
35
        cout << arr[i] << " ";
36
    }
37
    cout << endl;
38

39
    // 使用冒泡排序（降序）
40
    bubbleSort(arr, size, descending);
41
    for (int i = 0; i < size; ++i) { // 输出：5 4 3 2 1
42
        cout << arr[i] << " ";
43
    }
44
    cout << endl;
45

46
    return 0;
47
}

展开收起

指针与结构体#

指针常用于操作结构体，特别是在动态内存分配时。

1
struct Person {
2
    string name;
3
    int age;
4
};
5
Person* p = new Person;
6
p->name = "Alice"; // 等价于 (*p).name = "Alice";
7
p->age = 30;
8
delete p;

浙工大第五届 CTF 迎新赛回顾

Sun, 22 Dec 2024 15:01:45 GMT

前言#

这次赛题感觉整体难度不高，不会或者不了解的地方上网搜搜很快就能学会，答出大部分题应该是足够了。

本文中使用的代码均为 ChatGPT 生成。

PWN#

welcome_pwn#

题面：“你听说过a[-1]吗”

下载附件后使用 IDA 进行反编译，发现 main 函数中有一个 10 次的循环。

1
int main() // 简化的 main() 函数
2
{
3
  init();
4
  puts("let us play a game!");
5
  for ( int i = 0; i <= 9; ++i )
6
    game();
7
  return 0;
8
}

进入 game 函数，可以看到程序判断对应数组下标的值是否正确，如正确则计数，如错误则赋值。然而要触发 sh 命令，需要计数大于 10，按正常逻辑无法做到。

1
void game() // 简化的 game() 函数
2
{
3
  int v1;
4
  int v2;
5
  puts("input the index");
6
  scanf("%d", &v1);
7
  puts("input the result");
8
  scanf("%d", &v2);
9
  if ( pp[v1] == v2 ) {
10
    puts("right!");
11
    ++coins;
12
  } else {
13
    puts("wrong!");
14
    pp[v1] = v2;
15
  }
16
  if ( coins > 10 )
17
  {
18
    puts("wow you are so good!");
19
    system("/bin/sh");
20
  }
21
  return;
22
}

展开收起

点击 pp 数组，发现其内存地址为 201040，而 coin 的地址为 20103C，刚好差距 4 字节。结合题面，我们不难想到通过 pp[-1] 修改 coin 的值，从而激活终端。

连接容器，输入 index 为 -1，result 为大于 10 的数，即可进入终端，输入 cat /flag 即可得到 flag.

ret2libc_32#

这题难度较高，可能是题库中最难的。

但是这题可以在网上搜到原题和题解，所以难度大大下降。

具体解法可参考下列链接，本文不再赘述。

pwn入门：基本栈溢出之ret2libc详解（以32位+64位程序为例）

CTFshow-PWN-栈溢出（pwn45）

Crypto#

水题#

密码题大部分送分，水题统一写这里。

简单签到题：摩斯密码
古典密码：W 型栅栏密码
真签到题：Ook 密码
caesar：凯撒密码
密码题：培根密码
Base 家族：Base64 解完再解 Base32

基本找个在线工具丢进去就出来了。

MiniRSA#

题目给出公钥 n = 15，e = 3，密文 c = 3.

丢给 GPT 算出明文 m = 12.

basicRSA#

1
from gmpy2 import gcd, invert, powmod
2
from Crypto.Util.number import bytes_to_long, long_to_bytes
3

4
# 已知参数 e p q c
5
e =
6
p =
7
q =
8
n = p * q
9
c =
10

11
# 计算 phi(n)
12
phi_n = (p - 1) * (q - 1)
13

14
# 计算私钥 d
15
d = invert(e, phi_n)
16

17
# 解密密文
18
m = powmod(c, d, n)
19

20
# 转换回 flag
21
flag = long_to_bytes(m)
22
print(flag)

展开收起

键盘加密#

1
74 81 43 62 41 32 73

打开手机九键键盘，每组第一个数字对应九键，第二个数字对应键中具体的字母。

得到 stinger 即为 flag.

真的是md5？#

1
剔除前：bci177a7a9c7udf69c248647b4dfc6fd84o
2
剔除后：bc177a7a9c7df69c248647b4dfc6fd84

题目给的密文包含 md5 以外的字符，先把这些字符剔除，然后反向查询明文。

得 666666666666 即为 flag.

RSA#

这题中 n 是一个素数，所以可以直接用 n-1 作为 phi(n).

1
from Crypto.Util.number import *
2
from sympy import mod_inverse
3

4
# 已知的参数
5
n =
6
e =
7
c =
8

9
# 计算私钥 d
10
d = mod_inverse(e, n - 1)
11

12
# 解密密文
13
m = pow(c, d, n)
14

15
# 转换为字节
16
flag = long_to_bytes(m)
17

18
print("Flag:", flag)

展开收起

Misc#

你真的看不见吗#

Word 文档隐写题。

忘了怎么做的了，好像随便输几个字然后改改属性就出来了。

压缩包怎么还要密码#

得到一个带密码的压缩包，题目提示密码是学长生日。

暴力破解，从 20000101 到 20240101，可得学长生日为 20040915.

GIF#

直接打开会发现图片显示不全，用 Stegsolve 打开就能看到二维码。

打开 Frame Browser，依次识别 18 张二维码，连起来即可得到 flag.

图片题#

使用十六进制编辑器打开，发现图片中藏了 XML 文本，格式化后即可找到 flag.

wireshark#

题目给出 Wireshark 抓包记录，打开后筛选 Http 层，搜索 POST 方法，查看内容即可看到密码。

图片好像不完整#

打开图片发现龙舟图片不完整，用 tweakPNG 打开提示 CRC 错误。

于是编写脚本从 CRC 反推图片大小。

1
import zlib
2
import struct
3
import itertools
4

5
bin_data = open("龙舟.png", 'rb').read()
6
original_crc32 = int(bin_data[29:33].hex(), 16) # 原始crc
7

8
for i, j in itertools.product(range(4095), range(4095)):
9
  data = bin_data[12:16] + struct.pack('>i', i) + struct.pack('>i', j) + bin_data[24:29]
10
  crc32 = zlib.crc32(data)
11
  if(crc32 == original_crc32): # 计算当图片大小为i:j时的CRC校验值，与图片中的CRC比较，当相同，则图片大小已经确定
12
    print(f"宽度: {i}, hex: {hex(i)}")
13
    print(f"高度: {j}, hex: {hex(j)}")
14
    exit(0)

运行脚本后得图片实际高度应为 500，用 tweakPNG 重新修改图片大小，打开即可得到 flag.

又是图片#

图片属性中有一串盲文，翻译后即可得 flag.

你使用过StegSolve吗？#

使用 StegSolve 打开图片，打开 Data Extract 窗口，

勾选 R0 B0 G0 三个通道，Bit Order 选择 LSB First，

提取数据，发现数据头有 PNG 字样，保存为 png 文件，可以发现是张二维码，解析即可得 flag.

图片怎么打不开#

用十六进制编辑器打开，发现文件尾有 GNP 字样，编写程序读取二进制数据并反转输出，打开图片即可得 flag.

1
#include <iostream>
2
#include <fstream>
3
#include <vector>
4
#include <algorithm>
5
using namespace std;
6
int main() {
7
    string inputFilename = "1.png";
8
    string outputFilename = "2.png";
9

10
    // 打开输入文件
11
    ifstream inputFile(inputFilename, ios::binary);
12
    if (!inputFile) {
13
        cerr << "Error: Could not open input file " << inputFilename << endl;
14
        return 1;
15
    }
16

17
    // 读取二进制数据到缓冲区
18
    vector<char> buffer((istreambuf_iterator<char>(inputFile)),
19
                        istreambuf_iterator<char>());
20
    inputFile.close();
21

22
    // 反转数据
23
    reverse(buffer.begin(), buffer.end());
24

25
    // 打开输出文件
26
    ofstream outputFile(outputFilename, ios::binary);
27
    if (!outputFile) {
28
        cerr << "Error: Could not open output file " << outputFilename << endl;
29
        return 1;
30
    }
31

32
    // 写入反转后的数据到输出文件
33
    outputFile.write(buffer.data(), buffer.size());
34
    outputFile.close();
35
    return 0;
36
}

展开收起

社工题#

将酒店图片左右翻转，在镜子反光中看到 Transcendence Resort 字样，百度搜索即可得到答案 青城山心越酒店。

明文攻击#

这题真有点绕，硬控了我两小时。

下载附件得到 ._none.zip 和 none.zip 两个文件，其中 ._none.zip 没什么用。

解压 none.zip，得到 woo.jpg 和 res.zip 两个文件，res.zip 被密码加密，其中有 flag.txt 和 secret.txt 两个文件。

用十六进制编辑器打开 woo.jpg，在文件尾部找到 Zip 文件尾 50 4B 05 06，向前搜索 03 04，发现前四位被 32 32 覆盖。

修改 32 32 03 04 为 50 4B 03 04，即可修复 Zip 文件头。

使用 binwalk 工具拆分文件，得到一个包含 flag.txt 的压缩包，并且这个压缩包没有密码。

查看 CRC 可以发现这个压缩包中的 flag.txt 与 res.zip 中的完全一致，故用明文攻击即可破解压缩包。

破解完打开 secret.txt 即可获得 flag.

Web#

easyweb1#

查看 HTML 源码即可得 flag.

easyweb2#

直接打开容器，未发现有效信息，HTML 源码提示我们寻找其他文件。

使用 dirsearch 工具进行扫描，发现根目录下有 robot.txt，用浏览器访问即可得 flag.

easyweb3#

进入容器可以看到 PHP 脚本，可知要绕过数字判断并使 $a == 404 成立。

1
<?php
2
highlight_file(__FILE__);
3

4
if(!isset($_GET['start'])) exit(0);
5

6
$a = $_GET['start'];
7
if (is_numeric($a)) {               //这里要怎么绕过呢？
8
    echo "can't be number</br>";
9
    exit(0);
10
}elseif ($a == 404) {
11
    echo "Right!</br>";
12
}
13

14
if(isset($_GET['password']) && $_GET['password']=="Stinger666"){
15
    if(isset($_POST['bash'])){
16
        system($_POST['bash']);
17
    }
18
}
19
?>

展开收起

设置 start 为 404\0，即可绕过判断，使用 curl 发送请求即可运行指令。

Terminal window

1
curl --location --request POST 'https://xxx.stinger.team/?start=404%00&password=Stinger666' --form 'bash="cat /flag"'

easyweb4#

没做出来，这个是真不会，

给 CTF 佬跪辣。

C++ 盲点笔记（二）之 C 字符串

Tue, 12 Nov 2024 11:16:29 GMT

C 字符串#

声明#

C 语言没有单独的字符串类型，字符串被当作字符数组，即char[].

字符串变量可以声明成一个字符数组，也可以声明成一个指针，指向一个字符数组。

所有字符串都以\0结束。

1
// 以下三种写法等价
2
char s1[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
3
char s2[6] = "Hello";
4
char s3[] = "Hello";
5

6
// 用指针指向字符数组常量
7
char* s4 = "Hello";

若字符数组长度大于字符串长度，则会用\0填充剩余的空间。

1
// 从 s[6] 到 s[9] 均为 '\0'
2
char s[10] = "Hello";

C 语言允许合并多个字符串字面量，如果这些字符串之间只有空格或换行，C 语言会将它们自动合并。

1
char greeting[50] = "Hello, "   "how are you "
2
    "today!";
3
// 等同于
4
char greeting[50] = "Hello, how are you today!";

对于已经定义的字符数组，我们不能直接使用赋值运算符进行整体赋值，而是必须使用 C 语言提供的strcpy()函数。

1
char str[10];
2
str = "Hello";  // 错误：数组名是常量指针，不能作为赋值操作的左值
3
strcpy(str, "Hello");  // 正确

若使用指针变量，则可以直接指向字符串常量或字符数组：

1
char* p;
2
p = "World"; // 指向字符串常量
3
*(p+3) = 'z';  // 错误：常量不能修改
4

5
char str[] = "Hello, world!";
6
p = str; // 指向现有的字符数组
7
*(p+3) = 'z'; // 合法，等价于 str[3] = 'z'

strlen() 函数#

strlen()函数返回字符串的字节长度，不包括末尾的空字符\0.

string.h

1
size_t strlen(const char* s);

它的参数是字符串变量，返回的是size_t类型的无符号整数，除非是极长的字符串，一般情况下当作int处理即可。

注意，字符串长度strlen()与字符数组长度sizeof()是两个不同的概念。

1
char s[50] = "hello\0world12";
2
cout << strlen(s) << endl; // 5
3
cout << strlen(s+6) << endl; // 7
4
cout << sizeof(s) << endl; // 50

strcpy() 函数#

strcpy()函数用于将一个字符串复制到一个字符数组中。

string.h

1
char* strcpy(char dest[], const char src[]);

strcpy()的返回值是一个字符串指针，指向第一个参数，故可以连续为多个字符数组赋值。

1
char str1[20] = "Hello, I'm C0dd1y";
2
char str2[20] = "C0dd1y";
3

4
strcpy(str2, strcpy(str1 + 11, "SugarMGP"));
5
cout << str1 << endl; // Hello, I'm SugarMGP
6
cout << str2 << endl; // SugarMGP

另外，不能使用strcpy()对没初始化的字符指针赋值。

1
char* str; // 未初始化，指向随机位置
2
strcpy(str, "hello world"); // 错误

程C老师给我们写的神金示例，好孩子千万不要这样写码哦：

1
char s[81]="apple***\0s1234567";
2
char s2[81]="abc";
3
cout << s << endl; // apple***
4
cout << s+9 << endl; // s1234567
5

6
strcpy(s,s2); // abc\0e***\0s1234567
7
cout << s << endl; // abc
8
cout << s+4 << endl; // e***
9
cout << s+9 << endl; // s1234567

strcat() 函数#

strcat()函数用于将一个字符串追加到另一个字符串的末尾。

string.h

1
char* strcat(char* s1, const char* s2);

strcat()的返回值是一个字符串指针，同样指向第一个参数。

1
char s1[30] = "hello";
2
char s2[20] = "world";
3
strcat(s1, strcat(s2, ", SugarMGP"));
4
puts(s1); // "helloworld, SugarMGP"

同样也举个神金示例：

1
char s[81]="apple***\0s1234567";
2
char s2[81]="abc";
3
cout << s << endl; // apple***
4
cout << s+9 << endl; // s1234567
5

6
strcat(s,s2); // apple***abc\034567\0
7
cout << s << endl; // apple***abc
8
cout << s+12 << endl; // 34567
9

10
strcat(s+12,s2); // apple***abc\034567abc\0
11
cout << s << endl; // apple***abc
12
cout << s+12 << endl; // 34567abc

strcmp() 函数#

strcmp()函数用于比较两个字符串的内容。

string.h

1
int strcmp(const char* s1, const char* s2);

按照字典顺序，若s1小于s2，则返回负值；若s1大于s2，则返回正值；若s1等于s2，则返回零。

1
// s1 = Happy New Year
2
// s2 = Happy New Year
3
// s3 = Happy Holidays
4
strcmp(s1, s2) // 0
5
strcmp(s1, s3) // 正值 ('N'>'H')

strchr() 和 strstr()#

strchr()函数用于在字符串中查找某个字符，并返回该字符第一次出现的位置。

strstr()函数用于在字符串中查找另一个字符串的第一次出现的位置。

1
char str[] = "Hello, world!";
2

3
char* p = strchr(str, 'l');
4
if (p != NULL) {
5
    cout << p - str << endl; // 得到'l'第一次出现的下标为 2
6
}
7

8
char* q = strstr(str, "world");
9
if (q != NULL) {
10
    cout << q - str << endl; // 得到'world'第一次出现的下标为 7
11
}

C++ 盲点笔记（一）

Thu, 07 Nov 2024 12:52:17 GMT

字符#

转义字符#

转义字符	含义	ASCII码值
\0	空字符（字符串的结束标志）	0
\a	响铃（错误音效）	7
\t	水平制表符	9
\n	换行符	10
\“	双引号	34
\‘	单引号	39
\\	反斜杠	92
\ddd	八进制表示的字符	*
\xhh	十六进制表示的字符	*

例：

1
'\043' -> 八进制为43的字符 -> 十进制为35的字符 -> '#'
2
'\x43' -> 十六进制为43的字符 -> 十进制为67的字符 -> 'C'

ASCII 码#

大致顺序：数字 -> 大写字母 -> 小写字母

‘0’ (48) - ‘9’ (57)

‘A’ (65) - ‘Z’ (90)

‘a’ (97) - ‘z’ (122)

完整码表请参考：ASCII 表

输入输出#

getchar() 函数#

getchar() 用于读取下一个可用的字符，并将其作为整数返回。

如果读到文件结束或者发生读取错误，则返回 EOF (-1).

常用方法：

1
char c;
2
while ((c = getchar()) != EOF) {
3
    // 一些操作
4
}

gets() 函数#

gets() 用于读取一行字符串，并将读取的字符存储到指定的字符数组中。

换行符 \n 不会被存储到数组中，但在读取过程中会被消耗掉。读取完成后，会在数组末尾添加一个空字符 \0 以终止字符串。

如果遇到文件结束符或读取错误，返回 NULL.

常用方法：

1
char str[100];
2
while (gets(str) != NULL) {
3
    // 一些操作
4
}

cin 语句#

cin 语句用于读取输入，并将其转换为指定类型的值。

若缓冲区中第一个字符是分隔符，cin 会将其忽略并清除，继续读取下一个字符，

但是如果读取成功，字符后面的分隔符是残留在缓冲区的，cin 不做处理。

常用方法：

1
int x;
2
while (cin >> x) {
3
    // 一些操作
4
}

cin.getline() 函数#

类似于gets().

常用方法：

1
char str[100];
2
cin.getline(str, 100); // 默认以'\0'为截止符
3
cin.getline(str, 100, 'a'); // 以'a'为截止符

cout 常用控制符#

控制符	功能
*dec	十进制输出
hex	十六进制输出
oct	八进制输出
setprecision(n)	设置实数的精度
setbase(n)	设置整数的基数(只能为 8, 10 或 16)
setfill(c)	设置填充字符
setw(n)	设置字段宽度
boolalpha	把 true 和 false 输出为字符串
*noboolalpha	把 true 和 false 输出为数字
left	左对齐输出
*right	右对齐输出
internal	内部对齐输出
fixed	固定小数位数输出
scientific	科学计数法输出
endl	换行并刷新缓冲区

注意：

带*的控制符表示默认生效。
setw 只对其后的第一个输出项有效。
internal 指符号位左对齐，数值右对齐，中间由填充字符填充。
setprecision 默认代表有效数字，在以 fixed 和 scientific 形式输出时代表小数位数。
endl 不是一个字符，它等价于 putchar('\n') 和 fflush(stdout).

使用 Zap 实现高性能日志记录

Thu, 24 Oct 2024 14:27:17 GMT

前言#

Zap 是一款由 uber-go 开发的开源日志库，它支持多种日志级别和结构化，并对性能和内存分配做了极致的优化。

试用期大作业的后端中我们使用了 Zap 来进行日志记录，今日探索日志滚动时顺带回顾了一下 Zap 的基本用法，于是决定水一篇博客（逃

项目地址：https://github.com/uber-go/zap

快速使用#

Terminal window

1
go get -u go.uber.org/zap

Zap 库的使用与其他的日志库非常相似，我们需要先创建一个日志记录器，然后调用相应的方法来记录不同级别的日志。

Zap 提供了两种日志记录器：Sugared Logger 和 Logger.

Sugared Logger 并重性能与易用性，支持结构化和 printf 风格的日志记录。
Logger 非常强调性能，不提供 printf 风格的 api，只支持强类型的、结构化的日志记录。

举例如下：

1
func main() {
2
    // Sugared Logger
3
    sugar := zap.NewExample().Sugar()
4
    sugar.Infof("hello! name:%s,age:%d", "xiaomin", 20) // printf 风格
5

6
    // Logger
7
    logger := zap.NewExample()
8
    logger.Info("hello!", zap.String("name", "xiaomin"), zap.Int("age", 20)) // 结构化
9
}

输出结果：

1
// output
2
{"level":"info","msg":"hello! name:xiaomin,age:20"}
3
{"level":"info","msg":"hello!","name":"xiaomin","age":20}

要创建一个 Logger，Zap 提供了三个默认配置：Example，Development，Production，分别对应测试环境、开发环境和生产环境。

1
func main() {
2
   // Example
3
   logger := zap.NewExample()
4
   logger.Info("Example")
5

6
   // Development
7
   logger, _ = zap.NewDevelopment()
8
   logger.Info("Development")
9

10
   // Production
11
   logger, _ = zap.NewProduction()
12
   logger.Info("Production")
13
}

相应的输出如下：

1
// Example
2
{"level":"info","msg":"Example"}
3

4
// Development
5
2024-10-24T22:52:16.544+0800    INFO    ConfessionWallServer/main.go:14 Development
6

7
// Production
8
{"level":"info","ts":1729781536.5583117,"caller":"ConfessionWallServer/main.go:18","msg":"Production"}

可以看到，日志等级，日志输出格式，默认字段都有所差异。

定制 Logger#

Zap 提供了丰富的配置选项。

使用自定义配置#

我们可以通过自己创建 Config 来配置 Logger 的行为。

1
func main() {
2
    // 定制 Config
3
    config := zap.Config{
4
        Level:       zap.NewAtomicLevelAt(zap.InfoLevel), // 最低日志等级
5
        Encoding:    "json", // 日志输出格式
6
        EncoderConfig: zap.EncoderConfig{
7
            TimeKey:        "time", // 时间字段名
8
            LevelKey:       "level", // 日志等级字段名
9
            NameKey:        "logger", // 日志名字段名
10
            CallerKey:      "caller", // 调用者字段名
11
            MessageKey:     "msg", // 消息字段名
12
            StacktraceKey:  "stacktrace", // 堆栈字段名
13
            LineEnding:     zapcore.DefaultLineEnding,
14
            EncodeLevel:    zapcore.LowercaseLevelEncoder,
15
            EncodeTime:     zapcore.ISO8601TimeEncoder,
16
            EncodeDuration: zapcore.SecondsDurationEncoder,
17
            EncodeCaller:   zapcore.ShortCallerEncoder,
18
        },
19
        OutputPaths:      []string{"stdout"}, // 日志输出路径
20
        ErrorOutputPaths: []string{"stderr"}, // 错误日志输出路径
21
    }
22

23
    // 通过 Config 构建 Logger
24
    logger, _ := config.Build()
25

26
    // 在程序结束时同步缓冲区
27
    defer logger.Sync()
28

29
    // 记录日志
30
    logger.Info("hello!", zap.String("name", "xiaomin"), zap.Int("age", 20))
31
}

展开收起

记录调用信息#

Zap 提供了 AddCaller() 方法，可以记录调用者的信息，包括文件名、函数名、行号。前提是必须设置 CallerKey 字段，因此 NewExample() 不能输出调用者信息。

1
func main() {
2
  logger, _ := zap.NewProduction(zap.AddCaller())
3
  defer logger.Sync()
4

5
  logger.Info("hello world")
6
}

输出结果：

1
{"level":"info","ts":1587740198.9508286,"caller":"caller/main.go:9","msg":"hello world"}

有时我们稍微封装了一下记录日志的方法，但是我们希望输出的文件名和行号是调用封装函数的位置，这时可以使用 zap.AddCallerSkip(skip int) 向上跳过：

1
func Output(msg string, fields ...zap.Field) {
2
  zap.L().Info(msg, fields...)
3
}
4

5
func main() {
6
  logger, _ := zap.NewProduction(zap.AddCaller(), zap.AddCallerSkip(1))
7
  defer logger.Sync()
8

9
  zap.ReplaceGlobals(logger)
10
  Output("hello world")
11
}

输出结果：

1
{"level":"info","ts":1587740501.5592482,"caller":"skip/main.go:15","msg":"hello world"}

记录堆栈信息#

Zap 提供了 AddStacktrace() 方法，可以记录堆栈信息。前提是必须设置 StacktraceKey 字段，因此 NewExample() 不能输出堆栈信息。

1
func f1() {
2
  f2("hello world")
3
}
4

5
func f2(msg string, fields ...zap.Field) {
6
  zap.L().Warn(msg, fields...)
7
}
8

9
func main() {
10
  logger, _ := zap.NewProduction(zap.AddStacktrace(zapcore.WarnLevel))
11
  defer logger.Sync()
12

13
  zap.ReplaceGlobals(logger)
14

15
  f1()
16
}

展开收起

将 zapcore.WarnLevel 传入 AddStacktrace()，之后 Warn 和 Error 级别的日志会输出堆栈，Debug 和 Info 则不会。

运行结果：

1
{"level":"warn","ts":1729783529.2137501,"caller":"ConfessionWallServer/main.go:13","msg":"hello world","stacktrace":"main.f2\n\tD:/07_Github/ConfessionWallServer/main.go:13\nmain.f1\n\tD:/07_Github/ConfessionWallServer/main.go:9\nmain.main\n\tD:/07_Github/ConfessionWallServer/main.go:22\nruntime.main\n\tC:/Program Files/Go/src/runtime/proc.go:272"}

将 stacktrace 单独拉出来看：

1
main.f2
2
D:/07_Github/ConfessionWallServer/main.go:13
3
    main.f1
4
    D:/07_Github/ConfessionWallServer/main.go:9
5
        main.main
6
        D:/07_Github/ConfessionWallServer/main.go:22
7
            runtime.main
8
            C:/Program Files/Go/src/runtime/proc.go:272

我们很清楚地看到调用路径。

预设日志字段#

有些时候我们需要在每条日志中添加一些预设字段，可以通过 zap.Fields(fs ...Field) 来实现。

1
func main() {
2
  logger := zap.NewExample(zap.Fields(
3
    zap.Int("serverId", 114514),
4
    zap.String("serverName", "ConfessionWallServer"),
5
  ))
6

7
  logger.Info("hello world")
8
}

输出：

1
{"level":"info","msg":"hello world","serverId":114514,"serverName":"ConfessionWallServer"}

设置全局 Logger#

为了方便使用，Zap 提供了 ReplaceGlobals(logger *Logger)，可以将一个 Logger 设置为全局的 Logger。 zap.L() 获取全局 Logger，zap.S() 获取全局 Sugared Logger。

1
func main() {
2
  logger := zap.NewExample()
3
  defer logger.Sync()
4

5
  zap.ReplaceGlobals(logger)
6
  zap.L().Info("Global Logger")
7
  zap.S().Infof("Global %s", "Sugared Logger")
8
}

输出：

1
{"level":"info","msg":"Global Logger"}
2
{"level":"info","msg":"Global Sugared Logger"}

注意：若没有设置全局 Logger，则调用 zap.L() 和 zap.S() 并不会有日志输出。

实现日志滚动#

lumberjack 是一个高效且易用的日志滚动包，它允许开发人员将日志写入自动滚动的文件中，从而使日志管理更加简单。

Terminal window

1
go get -u github.com/natefinch/lumberjack

lumberjack 提供了一个滚动记录器 logger，它实现了 io.Writer 和 io.Closer 接口，我们可以使用 zapcore.AddSync 来将其与 Zap 结合使用。

1
func main() {
2
    lumberJackLogger := &lumberjack.Logger{
3
        Filename:   filename,  // 文件路径
4
        MaxSize:    maxsize,   // 单个日志文件的最大大小（单位为MB）
5
        MaxAge:     maxAge,    // 保留旧文件的最大天数
6
        MaxBackups: maxBackup, // 保留旧文件的最大个数
7
        Compress:   false,     // 是否压缩/归档旧文件
8
    }
9

10
    core := zapcore.NewCore(
11
        zapcore.NewJSONEncoder(zap.NewDevelopmentEncoderConfig()),
12
        zapcore.AddSync(lumberJackLogger),
13
        zapcore.DebugLevel,
14
    )
15

16
    logger := zap.New(core)
17
}

展开收起

更多高级用法请参考 Github 项目文档，在此不多赘述。

使用 Vercel 部署 Hexo 博客

Sun, 20 Oct 2024 03:37:35 GMT

前言#

Hexo 是一个快速、简洁且高效的博客框架，可以通过 Markdown（或其他渲染引擎）解析文章并生成静态网页。

Vercel 是一家基于云的开发平台，提供免费的静态网站托管服务。

本文将介绍如何通过 Vercel 部署 Hexo 博客。

准备工作#

安装 Node.js 和 Git，修改 NPM 为淘宝镜像源（可选）.

Terminal window

1
# 修改 NPM 为淘宝镜像源
2
npm config set registry https://registry.npmmirror.com

然后登录你的 Github 账号并创建一个新的公开仓库。

打开终端，输入以下两行代码来配置你的 Git：

Terminal window

1
git config --global user.name "此处填写你的Github用户名"
2
git config --global user.email "此处填写你的Github绑定的邮箱"

安装 Hexo#

新建一个文件夹作为你的博客文件的存放位置，点进去打开终端输入以下命令：

Terminal window

1
# 安装 Hexo
2
npm install -g hexo-cli
3

4
# 安装部署插件
5
npm install hexo-deployer-git --save
6

7
# 初始化 Hexo 博客
8
hexo init
9

10
# 安装博客所需要的依赖文件
11
npm install

等待运行完成，输入以下命令：

Terminal window

1
hexo g
2
hexo s

如果配置正确则会得到以下提示：

打开浏览器访问 http://localhost:4000 即可看到你的 Hexo 博客页面，说明博客在本地运行成功。

上传到 Github#

我们已经完成了 Hexo 的本地运行，接下来我们将本地博客上传到 Github 仓库进行托管。

首先打开终端，输入以下命令生成 SSH 密钥：

Terminal window

1
# 输入后一直回车即可
2
ssh-keygen -t rsa -C "Github绑定的邮箱地址"

打开 %USERPROFILE%/.ssh 文件夹，找到 id_rsa.pub 文件。

打开这个文件并复制里面的内容，

然后打开 Github 的 SSH Keys 设置页，点击 New SSH Key 按钮，将刚才复制的内容粘贴到 Key，并随便输入一个标题。

回到终端输入ssh -T git@github.com，输入yes，出现You’ve successfully …的字样说明连接成功。

进入博客站点目录，打开_config.yml文件，找到deploy部分，修改成以下内容：

1
deploy:
2
  type: git
3
  repo: git@github.com:<Github用户名>/<仓库名>.git
4
  branch: main

在博客站点目录下打开终端，输入hexo g -d，即可自动生成静态网页并上传到 Github 仓库。

部署到 Vercel#

用 Github 账号登录 Vercel.

点击 Add New Project 按钮，选择刚才上传的 Github 仓库并点击 Import，点击 Deploy 按钮，等待部署完成。

打开新建的 Project，点击 Visit 按钮，即可看到你的 Hexo 博客页面。

域名设置#

打开 Project Settings，点击 Domains 按钮，进入域名设置页面。

Vercel 给你默认分配了一个域名，你可以点击 Edit 按钮修改它：

如果需要绑定自己的域名，你可以输入自己的域名并点击 Add 按钮，

并打开域名服务商的 DNS 管理页面，将域名的 CNAME 记录指向 vercel.cdn.yt-blog.top（一个公益 Vercel CDN）.

等待 DNS 解析生效，然后打开浏览器访问你的域名，即可看到你的 Hexo 博客页面。

博客配置#

博客的配置文件位于博客站点目录下的 _config.yml 文件，你可以根据自己的需求修改以下内容：

更多高级设置请参考 Hexo 官方文档。

Hello World

Sat, 19 Oct 2024 12:26:35 GMT

Hello World#

神说：「要有光！」于是就有了光。
望舒说：「要有博客！」于是我就搭建了一个博客

白糖的记事本

Cube 开发踩坑实录（一）：别样的苹果螺旋现象

前言#

发现问题#

尝试保留元数据#

方向修正#

坐现成的轮椅#

问题解决#

在 Windows 下应用 Git 官方汉化

前言#

构建翻译文件#

应用翻译文件#

效果#

精弘网络 Java 后端微课 - EP3 异常捕获与日志记录

接口日志记录#

自定义错误类型与错误码聚合#

错误捕获#

课外拓展#

精弘网络 Java 后端微课 - EP2 业务分层与数据库操作

数据库基本概念#

Mybatis-Plus#

简介#

安装#

配置数据源#

建表并生成实体类#

业务分层#

条件构造器#

逻辑删除#

自动填充字段#

课外拓展#

身份鉴权#

分页查询#

事务管理#

精弘网络 Java 后端微课 - EP1.5 巧用 Lombok 简化样板代码

导入 Lombok#

原理简析#

常用注解#

@Getter 和 @Setter#

构造函数相关#

@ToString#

@EqualsAndHashCode#

@Data#

@Builder#

@Slf4j#

拓展阅读#

精弘网络 Java 后端微课 - EP1 控制器的编写和数据绑定

新建工程#

编写一个控制器#

什么是“控制器”（Controller）#

@RestController 是什么#

@RequestMapping 是什么#

数据绑定#

Query 参数绑定#

路径参数绑定#

绑定 Query 或表单到对象#

绑定 JSON 到对象#

参数校验#

统一 JSON 响应体#

精弘网络 Java 后端微课 - EP0 前置准备与环境搭建

课程引入#

环境准备#

基于 WebSocket 协议打造简易聊天服务端

前言#

为什么是 WebSocket？#

项目实践#

升级 WebSocket 连接#

构造连接管理器#

编写控制器#

小结#

C++ 盲点笔记（三）之 指针

指针#

基本使用#

指针与数组#

多级指针#

指针与运算符#

动态内存分配#

常量指针与指针常量#

函数指针#

指针与结构体#

浙工大第五届 CTF 迎新赛回顾

C++ 盲点笔记（三）之指针