测试开发刚哥

Claude Skills 和 Prompts、Projects、MCP、Subagents 的区别

Tue, 03 Nov 2026 00:00:00 +0000

Anthropic 官方专门写了一篇文章来解释。看完之后你会发现，这几个概念不仅不重复，反而各有分工，组合起来才能发挥完整的 AI 能力。

从零开始编写你的第一个 Agent Skill

Mon, 02 Nov 2026 00:00:00 +0000

Agent Skills 的发展简史

Agent Skills 的出现，其实是 AI 能力组织方式自然演进的结果。

早期的大模型应用主要靠提示词工程，把任务规则、流程说明、输出格式全部写进 System Prompt。这种方式简单直接，但提示词越写越长，上下文窗口被大量占用，关键指令容易被淹没，而且很难在不同项目之间复用。

随后 Function Calling 和工具调用逐渐普及，模型开始能够调用搜索、代码执行、数据库查询等外部能力。但这更多解决的是"能不能调用工具"的问题，还没有很好地回答"应该按什么流程、遵循什么标准、产出什么格式"的问题。

2025 年 10 月，Anthropic 在 Claude Code 中首次推出 Agent Skills 能力，把可复用的任务流程封装成以 SKILL.md 为核心的文件夹结构。同年 12 月 18 日，Anthropic 将 Agent Skills 规范作为开放标准发布，并开源官方技能库，随后 OpenAI Codex、GitHub Copilot、VS Code、Cursor 等产品陆续跟进支持。到 2026 年，Agent Skills 已经从单一产品的功能扩展为跨平台的能力封装格式，公开可用的 Skills 数量逼近百万级，累计安装约 2.8 亿次。

从技术演进看，Agent Skills 标志着 AI 应用开发从"手搓提示词"走向"标准化技能工程"。它把专业知识、执行流程、脚本工具和验收标准打包在一起，让 Agent 不再只是会聊天，而是能稳定完成具体工作。

一个 Skill 长什么样

最简单的 Skill 只需要一个文件：

my-skill/
└── SKILL.md

完整结构可以包含这些目录：

my-skill/
├── SKILL.md          # 必需：元数据 + 指令
├── scripts/          # 可选：可执行脚本
├── references/       # 可选：参考文档
├── assets/           # 可选：模板、资源
└── ...

核心文件 SKILL.md 的结构

SKILL.md 由两部分组成：YAML Frontmatter（元数据） 和 Markdown 正文（指令），用 --- 分隔。

比pip快100倍的Python包安装工具

Thu, 05 Feb 2026 00:00:00 +0000

简介

uv是一款开源的Python包安装工具，GitHub star高达56k，以性能极快著称，具有以下特性（官方英文原文）：

🚀 A single tool to replace pip, pip-tools, pipx, poetry, pyenv, twine, virtualenv, and more.
⚡️ 10-100x faster than pip.
🗂️ Provides comprehensive project management, with a universal lockfile.
❇️ Runs scripts, with support for inline dependency metadata.
🐍 Installs and manages Python versions.
🛠️ Runs and installs tools published as Python packages.
🔩 Includes a pip-compatible interface for a performance boost with a familiar CLI.
🏢 Supports Cargo-style workspaces for scalable projects.
💾 Disk-space efficient, with a global cache for dependency deduplication.
⏬ Installable without Rust or Python via curl or pip.
🖥️ Supports macOS, Linux, and Windows.

在Python MCP SDK的介绍中，也出现了We recommend using uv to manage your Python projects的字样，说明uv已经是一款实用性极强的工具。

官网学习之控制流

Wed, 04 Feb 2026 00:00:00 +0000

if

if语句是最常见的控制流：

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
... 
More

for

for语句用来遍历：

## Create a sample collection
users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

## Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

## Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

range

range函数生成数字序列：

跟着官网学习Python系列

Tue, 03 Feb 2026 00:00:00 +0000

开篇

个人而言，Python是写起来最顺手、看起来最喜欢的编程语言，也是实际工作中使用最多的编程语言。从Python入门，到完全使用Java，再回归Python，编程语言本质上是工具，与Excel、XMind无异。对于测试开发来说，要学习的东西很多，Python是可以作为基础技术深入学习的。第1次通过菜鸟教程学习Python，第2次阅读《流畅的Python》学习Python，第3次跟着官网学习Python。该系列文章参考的是Python3.13版本官方教程，期望学习者具有一定编程基础。

Python解释器

终端使用uv安装Python3.13：

uv python install 3.13

查看安装位置：

which python3.13

进入Python解释器：

$ python3.13
Python 3.13 (default, April 4 2023, 09:25:04)
[GCC 10.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

计算器

平时我们基本不会这样来写Python，但是可以当做计算器来用：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

>>> 4 * 3.75 - 1
14.0

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _  # In interactive mode, the last printed expression is assigned to the variable _
113.0625
>>> round(_, 2)
113.06

Python也很适合用来学习算法，比如最简单的冒泡排序：

Python并发编程从入门到进阶

Mon, 02 Feb 2026 00:00:00 +0000

本文是Python进阶系列专题的最后一篇文章了，学习一下Python并发编程。懂得并发编程，就算是真正进阶了。

Python协程知多少

Sun, 01 Feb 2026 00:00:00 +0000

从概念上来说，我们都知道多进程和多线程，而协程其实是在单线程中实现多并发。从句法上看，协程与生成器类似，都是定义体中包含yield关键字的函数。区别在于协程的yield通常出现在表达式的右边：datum = yield。这一下就让初学者瞬间觉得yield关键字不香了，本来以为yield就是简简单单的暂停执行顺手返回个值，结果还能放右边？

Python上下文管理器

Sat, 31 Jan 2026 00:00:00 +0000

with语句会设置一个临时的上下文，交给上下文管理器对象控制，并且负责清理上下文。

长篇大论Python生成器

Fri, 30 Jan 2026 00:00:00 +0000

Python生成器是什么

一句话解释：包含了yield关键字的函数就是生成器，它的返回值是一个生成器对象。我简单画了个示意图：

yield相当于return。
函数遇到yield就暂停，保存当前信息，返回yield的值。
在下次执行next()时，从当前位置继续执行。

生成器函数的工作原理

先通过一个简单示例来说明生成器的行为：

## 定义一个生成器
>>> def gen_123():
...     yield 1
...     yield 2
...     yield 3
...

## 生成器本身是个函数
>>> gen_123
<function gen_123 at 0x0000019F60710790>

## 返回值是生成器对象
>>> gen_123()
<generator object gen_123 at 0x0000019F606AC040>

## 生成器也是迭代器
>>> for i in gen_123():
...     print(i)
...     
1
2
3

## 验证生成器也是迭代器，定义迭代器g
>>> g = gen_123()

## 可以通过next()获取yield生成的下一个元素
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
StopIteration

生成器的原理就是：

生成器函数会创建一个生成器对象。
把生成器传给next()函数时，生成器函数会执行函数定义体中的下一个yield语句，返回产出的值，并在当前位置暂停。
函数的定义体返回时，外层的生成器对象会抛出StopIteration异常

yield关键字一般是和for循环搭配使用的，在for循环中会隐式调用next()函数。

Python可迭代的对象与迭代器的对比

Thu, 29 Jan 2026 00:00:00 +0000

什么是迭代？迭代是指按需一次获取一个数据。是否可以迭代，可以通过是否可以使用for循环取值来进行简单的判断。更准确的判断是使用iter()函数，这是一个Python内置函数。

Python抽象基类的定义与使用

Wed, 28 Jan 2026 00:00:00 +0000

我们写Python基本不需要自己创建抽象基类，而是通过鸭子类型来解决大部分问题。《流畅的Python》作者使用了15年Python，但只在项目中创建过一个抽象基类。我们更多时候是创建现有抽象基类的子类，或者使用现有的抽象基类注册。本文的意义在于，了解抽象基类的定义与使用，可以帮助我们理解抽象基类是如何实现的，为我们以后学习后端语言（比如Java、Golang）打下基础。**毕竟抽象

Python中的接口协议和抽象基类

Tue, 27 Jan 2026 00:00:00 +0000

Python接口与协议

Python语言是没有interface关键字的，这也是动态类型语言的特点之一。Python的接口指的是类实现或继承的公开属性，包括数据或方法。比如Sequence的正式接口如下图所示：

这些都叫做Python接口。事实上，Python每个类都有接口，除了抽象基类。

接口是正式的，它定义了类具有哪些属性，协议是非正式的接口，只由文档和约定定义。比如只要类实现了__getitem__方法，按照序列协议的约定，Python就会支持这个类完成访问元素、迭代和使用in运算符等一系列操作。

猴子补丁

我们可以通过猴子补丁来进一步认识，Python中协议的约定是怎么回事。猴子补丁是这样一种技术：在运行时修改类或模块，而不改动源码。还是以序列协议来举例，比如：

>>> from random import shuffle
>>> from frenchdeck import FrenchDeck
>>> deck = FrenchDeck()
>>> shuffle(deck)

假设运行报错了：TypeError: 'FrenchDeck' object does not support item assignment，因为FrenchDeck类只有__getitem__方法，只实现了不可变的序列协议。为了解决这个报错，需要通过__setitem__方法实现可变的序列协议。

代码如下：

def set_card(deck, position, card):
    deck._cards[position] = card

FrenchDeck.__setitem__ = set_card
shuffle(deck)

这就是一段猴子补丁技术的实现代码，没有修改FrenchDeck类的源码，而是在运行时动态修改。

抽象基类

Python的抽象基类是指必须让继承它的子类去实现它所要求的方法的类。Python的collections.abc模块中就定义了很多抽象基类：

虽然我们在实际编程中并不会自己编写抽象基类（一般也不建议这样做，因为可能会导致意想不到的问题），但是了解抽象基类，可以帮助我们更好理解Python面向对象的继承等概念。

抛开枯燥的理论知识，我在书中找到了一处具有实践价值的片段：

「在一连串if/elif/elif中使用isinstance做检查，然后根据对象的类型执行不同的操作，通常是不好的做法；此时应该使用多态，即采用一定的方式定义类，让解释器把调用分派给正确的方法，而不使用if/elif/elif块硬编码分派逻辑。」

交流群和公司都有人问过我这个问题，写了太多的ifelse有没有更好的实现方式，我想这里已经给出了答案。

鸭子类型和白鹅类型

Python鸭子类型是指对象的类型无关紧要，只要实现了特定的协议即可。它的好处是避免过多的isinstance，如果遵守既定协议，能增加利用现有的标准库和第三方代码的可能性。示例：

class Animal(object):
    
    def run(self):
        print("The animal is running...")

class Dog(Animal):

    def run(self):
        print('The dog is running...')

class Cat(Animal):

    def run(self):
        print('The cat is running...')

def make_run(animal):
    animal.run()

dog = Dog()
cat = Cat()
make_run(dog)
make_run(cat)

对于 make_run() 函数来说，传入的参数并不一定需要是 Animal 类型的，只需要保证传入的对象有一个 run() 方法即可。

Python如何设计面向对象的类（下）

Mon, 26 Jan 2026 00:00:00 +0000

本文将在上篇文章二维向量Vector2d类的基础上，定义表示多维向量的Vector类。

Python如何设计面向对象的类（上）

Sun, 25 Jan 2026 00:00:00 +0000

Python是一门高级语言，支持面向对象设计，如何设计一个符合Python风格的面向对象的类，是一个比较复杂的问题，本文提供一个参考，表达一种思路，探究一层原理。

Python变量小秘密

Sat, 24 Jan 2026 00:00:00 +0000

变量全都是引用

跟其他编程语言不同，Python的变量不是盒子，不会存储数据，它们只是引用，就像标签一样，贴在对象上面。

比如：

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]
>>> b is a
True

a变量和b变量引用的是同一个列表[1, 2, 3]。b可以叫做a的别名。

比较来看：

>>> a = [1, 2, 3]
>>> c = [1, 2, 3]
>>> c == a
True
>>> c is a
False

c引用的是另外一个列表，虽然和a引用的列表的值相等，但是它们是不同的对象。

浅复制与深复制

浅复制是指只复制最外层容器，副本中的元素是源容器中元素的引用。如果所有元素都是不可变的，那么这样没有问题，还能节省内容。但是，如果有可变的元素，那么结果可能会出乎意料之外。构造方法或[:]做的都是浅复制。

示例：

>>> x1 = [3, [66, 55, 44], (7, 8, 9)]
## x2是x1的浅复制
>>> x2 = list(x1)

## 不可变元素没有影响
>>> x1.append(100)
>>> x1
[3, [66, 55, 44], (7, 8, 9), 100]
>>> x2
[3, [66, 55, 44], (7, 8, 9)]  

## x1[1]是列表，可变元素会影响x2
## 因为它们引用的是同一个对象
>>> x1[1].remove(55)
>>> x1
[3, [66, 44], (7, 8, 9), 100]
>>> x2
[3, [66, 44], (7, 8, 9)]  

## x2[1]也会反过来影响x1
>>> x2[1] += [33, 22]
>>> x1
[3, [66, 44, 33, 22], (7, 8, 9), 100]  
>>> x2
[3, [66, 44, 33, 22], (7, 8, 9)]

## 不可变元组也不会有影响
## +=运算符创建了一个新元组
>>> x2[2] += (10, 11)
>>> x1
[3, [66, 44, 33, 22], (7, 8, 9), 100]  
>>> x2
[3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]

深复制是指我们常规理解的复制，副本不共享内部对象的引用，是完全独立的一个副本。这可以借助copy.deepcopy来实现。

Python编解码问题与文本文件处理

Fri, 23 Jan 2026 00:00:00 +0000

编解码器

在字符与字节之间的转换过程称为编解码，Python自带了超过100种编解码器，比如：

ascii（英文体系）
gb2312（中文体系）
utf-8（全球通用）
latin1
utf-16

这些编解码器可以传给open()、str.encode()、bytes.decode()等函数的encoding参数。

UnicodeEncodeError

多数非UTF编解码器（比如cp437）只能处理Unicode字符的一小部分子集。把字符转换成字节时，如果目标编码中没有定义这个字符，那么就会抛出UnicodeEncodeError异常。

处理方式一：使用utf8编码。

处理方式二：添加errors参数：

## 忽略 如b'So Paulo'
city.encode("cp437", errors="ignore")
## 替换为? 如b'S?o Paulo'
city.encode("cp437", errors="replace")
## 替换为XML实体 如b'S&#227;o Paulo'
city.encode("cp437", errors="xmlcharrefreplace")

UnicodeDecodeError

把字节转换为字符时，遇到无法转换的字节时会抛出UnicodeDecodeError异常。这是因为不是每个字节都包含有效的ASCII字符，也不是每个字符都是有效的UTF-8。

处理方式也有两种，跟上面一样。

SyntaxError

Python3默认使用UTF-8编码源码。如果加载的.py模块中包含UTF-8之外的数据，而且没有声明编码，就会抛出SyntaxError异常。

处理方式是在文件顶部添加coding注释：

## coding: cp1252

但是这个办法并不好，最好还是找到这些报错字符，把它们转换为UTF-8。

处理文本文件

Unicode三明治：

在程序中尽量少接触二进制，把字节解码为字符，只处理字符串对象。比如在Django中，view应该输出Unicode字符串，Django会负责把响应数据编码成字节序列，而且默认使用UTF-8编码。

Python内置的open函数就是采用了这个原则，在读取文件时会做必要的解码，以文本模式写入文件时会做必要的编码。

文件乱码

Windows更容易遇到这个问题，因为Windows并不是统一的UTF-8编码，比如在Windows10中：

>>> open("cafe.txt", "w", encoding="utf8").write("café")
4
>>> open("cafe.txt").read()
'caf茅'

写入文件时指定了utf8，但是读取文件没有指定，Python就会使用系统默认编码：

>>> import locale
## 打开文件用这个
## 如果没有设置PYTHONENCODING环境变量，sys.stdout/stdin/stderr也用这个
>>> locale.getpreferredencoding()
'cp936'

cp936把最后一个字节解码成了茅而不是é。

>>> import sys
# 二进制数据和字符串之间转换用这个
>>> sys.getdefaultencoding()
'utf-8'

>>> import sys
# 文件名（不是文件内容）用这个
>>> sys.getfilesystemencoding()
'utf-8'

GNU/Linux或Mac OS X不会遇到这个问题，因为多年来它们的默认编码都是UTF-8。

Python字符与字节新编

Thu, 22 Jan 2026 00:00:00 +0000

字符

字符是一个信息单位，简单来讲就是一个字母、数字、标点符号、汉字等。

字符的最佳定义是Unicode字符：

它是一个全球化的标准，能表示世界上所有语言的字符。Unicode字符的标识（码位）是以4~6个十六进制数字表示的，并且加前缀U+。

字节

字节是计算机信息计量单位，一个字节代表八个比特，存储的数值范围为0~255。

字节是机器的，字符是人类的。

把人类字符转换为机器字节时使用的算法叫做编码，反之叫做解码。

算法不同，字节与字符的关系也不同：

bytes和bytearray

字节实际上是个二进制序列。不可变bytes类型和可变bytearray类型是用来存储二进制序列的，它们的示例如下：

>>> cafe = bytes("café", encoding="utf_8")
>>> cafe
b'caf\xc3\xa9'
>>> cafe[0]
99
>>> cafe[:1]
b'c'
>>> cafe_arr = bytearray(cafe)
>>> cafe_arr
bytearray(b'caf\xc3\xa9')
>>> cafe_arr[-1:]
bytearray(b'\xa9')

特别的是cafe[0]返回了整数，cafe[:1]返回了二进制序列，这是因为s[0] == s[:1]只对str类型成立，而对于其他类型来说，s[i]返回一个元素，s[i:i+1]返回一个相同类型的序列。

二进制序列实际上是整数序列。它们的字面量表示法包含ASCII字符（ASCII只能表示英文体系的字符），比如cafe的b'caf\xc3\xa9'，具体规则是：

从空格到~的字符直接使用ASCII字符
制表符\t、换行符\n、回车符\r、转义符\\
其他字符用十六进制转义序列，比如\x00空字节

构建bytes和bytearray对象的方式有以下几种：

一个str对象和一个encoding关键字参数
一个可迭代对象，数值在0~255
一个实现了缓冲协议的对象，如bytes、bytearray、memoryview、array.array

memoryview和struct

memoryview允许在二进制数据结构之间共享内存，struct能从序列中提取结构化信息。

示例如下，提取一个GIF图像的宽度和高度：

import struct

with open("filter.gif", "rb") as fp:
    img = memoryview(fp.read())

## 这里不会复制字节序列，因为用的memoryview
header = img[:10]
print(bytes(header))  # b'GIF89a+\x02\xe6\x00'

## <是小字节序，3s3s是两个3字节序列，HH是两个16位二进制整数
## 类型、版本、宽度、高度
struct.unpack("<3s3sHH", header)  # (b'GIF', b'89a', 555, 230)

## 删除引用，释放memoryview实例所占的内存
del header
del img

小结

本文介绍了字符和字节的概念以及它们之间的关系，一个字符对应一个或多个字节。字符是人类的，字节是机器的，编码就是人类字符转换为机器字节，反之叫做解码。然后分别介绍了二进制序列的类型bytes和bytearray，和二进制序列的工具memoryview和struct。

工作汇报流水账 vs 问题驱动的思想表达

Thu, 22 Jan 2026 00:00:00 +0000

一句话：前者在报进展，后者在讲思想。同样的素材，后者立意高一个身位。

Python函数装饰器高级用法

Wed, 21 Jan 2026 00:00:00 +0000

在了解了Python函数装饰器基础知识和闭包之后，开始正式学习函数装饰器。

单篇长文TestNG从入门到精通

Wed, 21 Jan 2026 00:00:00 +0000

简介

TestNG是Test Next Generation的缩写，它的灵感来自于JUnit和NUnit，在它们基础上增加了很多很牛的功能，比如说：

注解。
多线程，比如所有方法都在各自线程中，一个测试类一个线程等。
验证代码是否多线程安全。
灵活的测试配置。
支持数据驱动（@DataProvider）。
支持参数化。
强大的执行机制（不需要TestSuite）。
能跟各种工具结合（比如IDEA、Maven等）。
内嵌BeanShell。
提供运行时和日志的JDK函数（不需要添加dependencies）。
提供应用服务器测试依赖的方法。

一句话总结就是，TestNG强大到能覆盖所有测试类型：单元测试、功能测试、端到端测试、集成测试等等等。

一个简单的示例如下：

package example1;
 
import org.testng.annotations.*;
 
public class SimpleTest {
 
 @BeforeClass
 public void setUp() {
   // code that will be invoked when this test is instantiated
 }
 
 @Test(groups = { "fast" })
 public void aFastTest() {
   System.out.println("Fast test");
 }
 
 @Test(groups = { "slow" })
 public void aSlowTest() {
    System.out.println("Slow test");
 }
 
}

setUp()会在测试类创建后，测试方法执行前运行。
测试方法名字可以任意的，TestNG通过@Test注解来标识。
可以把测试方法按group分组。

然后使用xml来配置运行策略：

坚持自己写文章的意义

Wed, 21 Jan 2026 00:00:00 +0000

首先，思维深度。AI写作是快，自己写作是慢。在思考时，我们需要慢下来，就像冥想一样，很多事情是需要时间，慢慢想清楚的。在网上已经充斥着大量的AI一键生成文章，写的很严谨、很漂亮，但缺乏最重要的“人情味”。现在还有人认真看完一篇AI写的技术文章么？至少我是很难看完的。反而是人写的一些思考感受，我会逐字看完，这是AI永远无法替代的与人交流价值。自己写文章的过程，就是深度思考的过程，这样写出来的文字，更

Allure+Maven+JUnit5配置实践

Tue, 20 Jan 2026 00:00:00 +0000

为什么要用JUnit5？

关于Python闭包的一切

Tue, 20 Jan 2026 00:00:00 +0000

任何把函数当做一等对象的语言，它的设计者都要面对一个问题：作为一等对象的函数在某个作用域中定义，但是可能会在其他作用域中调用，如何处理自由变量？

老生常谈测试开发如何选择编程语言

Tue, 20 Jan 2026 00:00:00 +0000

这个话题，网上很多人讨论过很多次，我也曾经聊过3次。

fastjson知多少

Mon, 19 Jan 2026 00:00:00 +0000

fastjson介绍

fastjson是一个Java库，用来在Java对象和JSON之间相互转换。

fastjson的目标（官方原话）：

我翻译一下：

性能非常好；
封装非常高；
转换非常强；
泛型也支持；
自定义表示；
复杂也支持；

这6个目标，书读少的我理解起来费劲，看着这些字，视线开始模糊…突然这些字动了，不断变幻，凝聚成了两个字：“牛逼”。阿里巴巴也确实做到了，fastjson(24.9k star)作为国产原创库，PK掉了jackson(7.6k star)和gson(21.3k star)，在国内应用领域坐上了头把交椅。

安装fastsjon

Maven引入：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>VERSION_CODE</version>
</dependency>

版本可以在 https://mvnrepository.com/artifact/com.alibaba/fastjson 查找：

虽然2.0.x版本出来了，但是使用得多的还是1.2.x版本。至少得1.2.48以上，因为这以下的版本之前出过轰动全国的安全漏洞。

入门示例

Group.java

public class Group {

    private Long       id;
    private String     name;
    private List<User> users = new ArrayList<User>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public void addUser(User user) {
        users.add(user);
    }
}

User.java

Python处理接口数据，这个函数太香了

Mon, 19 Jan 2026 00:00:00 +0000

Python处理接口数据

接口数据通常是JSON格式，Python处理起来并不轻松。

方法一，json文件。额外编写代码读取文件，接口参数很多，文件变多，难维护。

方法二，字典。JSON可以直接粘贴到代码中，Python认作字典，但语法有差异，JSON的语法是true/false/null，Python的语法是True/False/None，不兼容。

这两种方法都有共同的缺点，需要编写表达式来定位某个节点。

比如：body["a"][0]["x"]["m"]

字符串与占位符

占位符是一种很常见的文本替换技术，在任何编程语言中都有广泛应用。

Python语法有个很特别的字符串，三引号字符串：

test_json = """
{
 "bool": true,
  "x": null,
  "customerId": "123456",
  "items": [
    {
      "productId": "987654",
      "quantity": 2,
      "price": 199.99
    }
  ],
  "shippingAddress": {
    "recipientName": "张三",
    "streetAddress": "北京市朝阳区某街道123号",
    "city": "北京",
    "state": "北京",
    "postalCode": "100000",
    "country": "中国"
  },
  "paymentMethod": {
    "type": "CreditCard",
    "cardNumber": "4111111111111111",
    "expiryDate": "12/25",
    "cvv": "123"
  },
  "orderNotes": "请尽快发货，谢谢！"
}
"""

基本思路是，把JSON写在三引号字符串中，这能保留原生JSON格式，就像很多测试平台的做法一样，然后再通过占位符，直接替换其中的节点值。占位符不用编写表达式定位节点，在JSON字符串标记即可。

Python函数装饰器基础知识

Mon, 19 Jan 2026 00:00:00 +0000

函数装饰器是Python语言最优秀的设计之一，它以非常简洁的方式增强了函数的行为，让崎岖不平之路变得平坦顺畅。

接口自动化，用例独立还是用例复用

Mon, 19 Jan 2026 00:00:00 +0000

用例独立。用例相互之间没有依赖，随便拉出一条用例就能执行。

Locust性能测试工具核心技术@task和@events

Sun, 18 Jan 2026 00:00:00 +0000

Tasks和Events是Locust性能测试工具的核心技术，有了它们，Locust才能称得上是一个性能工具。

Python设计模式知多少

Sun, 18 Jan 2026 00:00:00 +0000

设计模式

设计模式是前辈们经过相当长的一段时间的试验和错误总结出来的最佳实践。我找到的资料列举了以下这些设计模式：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式、适配器模式、桥接模式、过滤器模式、组合模式、装饰器模式、外观模式、享元模式、代理模式、责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、空对象模式、策略模式、模板模式、访问者模式、MVC模式、业务代表模式、组合实体模式、数据访问对象模式、前端控制器模式、拦截过滤器模式、服务定位器模式、传输对象模式，共33种。

这些设计模式在纯面向对象编程语言中使用最多。**Python拥有一等函数，既不需要使用某些设计模式，也减少了某些设计模式样板代码。**本文将使用一等函数实现策略模式和命令模式，研究Python代码是如何简化的。

策略模式

策略模式概述：“定义一系列算法，把它们一一封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。”

经典实现

示例，根据客户的属性或订单中的商品计算折扣，规则如下：

有1000或以上积分的客户，每个订单享5%折扣。
同一订单中，单个商品的数量达到20个或以上，享10%折扣。
订单中的不同商品达到10个或以上，享7%折扣。

这很适合用策略模式来做，UML类图设计如下：

上下文，集成算法的类，图中Order会根据不同的算法计算折扣。
策略，实现不同算法的组件的共同接口，图中Promotion是个抽象类。
具体策略，策略的具体子类，图中FidelityPromo、BulkItemPromo、LargeOrderPromo分别对应上面3条计算折扣规则。

代码实现如下：

from abc import ABC, abstractmethod
from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')


class LineItem:

    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price

    def total(self):
        return self.price * self.quantity


class Order:  # the Context

    def __init__(self, customer, cart, promotion=None):
        self.customer = customer
        self.cart = list(cart)
        self.promotion = promotion

    def total(self):
        if not hasattr(self, '__total'):
            self.__total = sum(item.total() for item in self.cart)
        return self.__total

    def due(self):
        if self.promotion is None:
            discount = 0
        else:
            discount = self.promotion.discount(self)
        return self.total() - discount

    def __repr__(self):
        fmt = '<Order total: {:.2f} due: {:.2f}>'
        return fmt.format(self.total(), self.due())


class Promotion(ABC):  # the Strategy: an Abstract Base Class

    @abstractmethod
    def discount(self, order):
        """Return discount as a positive dollar amount"""


class FidelityPromo(Promotion):  # first Concrete Strategy
    """5% discount for customers with 1000 or more fidelity points"""

    def discount(self, order):
        return order.total() * .05 if order.customer.fidelity >= 1000 else 0


class BulkItemPromo(Promotion):  # second Concrete Strategy
    """10% discount for each LineItem with 20 or more units"""

    def discount(self, order):
        discount = 0
        for item in order.cart:
            if item.quantity >= 20:
                discount += item.total() * .1
        return discount


class LargeOrderPromo(Promotion):  # third Concrete Strategy
    """7% discount for orders with 10 or more distinct items"""

    def discount(self, order):
        distinct_items = {item.product for item in order.cart}
        if len(distinct_items) >= 10:
            return order.total() * .07
        return 0

实现策略模式的关键代码是Promotion类，它是一个抽象基类，通过继承abc.ABC来定义。

二刷Java官方教程

Sun, 18 Jan 2026 00:00:00 +0000

第二次阅读Java官方教程，有些不一样的理解。内容比较散乱，个人意识流笔记。

年度大版本，tep3回归纯粹Python接口测试框架

Sun, 18 Jan 2026 00:00:00 +0000

回顾

tep是基于pytest开发的接口测试框架，上个版本从小工具升级为了关键字驱动框架，通过pystats发现最近半年仍然有4000+人次在安装使用tep。时隔1年后，我对tep进行了一次大版本改造，抛弃tep2的Java代码风格，重新回归到tep1的纯粹Python风格。

纯粹Python

所谓纯粹Python，体现在两个方面，一个方面是tep源码进行了重写，更加Pythonic，自动化用例写起来也更加简单易懂；另一方面是抛弃了依赖Java的Allure和依赖C++的loguru，分别使用Python技术栈的pytest-html和logging替代。

tep3版本

简介

tep是Try Easy Pytest的首字母缩写，帮你轻松上手pytest。

框架特点：

基于pytest封装，成熟、稳定且扩展性强。
框架完全由Python构建，没有混杂其他语言。
原生Python语法，学习Python，零成本使用框架。
HAR包转换pytest用例。

安装

支持Python3.8以上版本

创建虚拟环境：python -m venv venv

激活虚拟环境，Windows用户：activate.bat Mac用户：source venv/bin/activate

安装tep：pip install tep

验证安装成功：tep -V

目录结构

data
file
fixture
report
scripts
tests
.gitignore
conftest.py
pytest.ini
run.py

tep new demo就能快速创建项目名称为demo的项目脚手架。

用例示范

简单的请求：

from tep import request


def test():
    response = request("get", url="http://httpbin.org/status/200")
    assert response.status_code == 200

复杂的场景：

from tep import request
from tep import v

from data.global_data import GlobalData


class Data:
    v({
        "domain": GlobalData.domain,
        "skuNum": 2,
        "payAmount": 0.2
    })
    body_add_cart = '{"skuId":"${skuId}","skuNum":${skuNum}}'
    body_order = '{"skuId":"${skuId}","price":${skuPrice},"skuNum":${skuNum},"totalPrice":${totalPrice}}'
    body_pay = '{"orderId":"${orderId}","payAmount":${payAmount}}'


def test():
    url = v("${domain}/searchSku?skuName=book")
    response = request("get", url=url, headers=GlobalData.headers)
    assert response.status_code < 400
    v("skuId", response.jsonpath("$.skuId")[0])
    v("skuPrice", response.jsonpath("$.price")[0])

    url = v("${domain}/addCart")
    body = v(Data.body_add_cart)
    response = request("post", url=url, headers=GlobalData.headers, json=body)
    assert response.status_code < 400
    v("skuNum", response.jsonpath("$.skuNum")[0])
    v("totalPrice", response.jsonpath("$.totalPrice")[0])

    url = v("${domain}/order")
    body = v(Data.body_order)
    response = request("post", url=url, headers=GlobalData.headers, json=body)
    assert response.status_code < 400
    v("orderId", response.jsonpath("$.orderId")[0])

    url = v("${domain}/pay")
    body = v(Data.body_pay)
    response = request("post", url=url, headers=GlobalData.headers, json=body)
    assert response.status_code < 400
    assert response.jsonpath("$.success")[0] == "true"

用例和数据

数据怎么存放，这里给出了一个参考方案，在用例内定义class Data，然后通过类变量存放数据。不同的项目，不同的场景，不同的参数，可以考虑不一样的存放方式。

怎么给别人讲系统架构

Sun, 18 Jan 2026 00:00:00 +0000

系统架构是软件系统的结构化解决方案，它定义了：系统组件及其相互关系，组件与环境的关系，指导设计和演进的原则，技术标准和约束条件，质量属性实现方案，系统各层面的抽象描述，关键设计决策文档，系统演进路线图。

AI时代如何自我提升

Sat, 17 Jan 2026 00:00:00 +0000

如果你想自我提升却找不到合适方法，或者学习没有什么效果，希望这篇文章能给你带来些许启发。

Java官方笔记14流

Sat, 17 Jan 2026 00:00:00 +0000

Processing Data in Memory

The Stream API is probably the second most important feature added to Java SE 8, after the lambda expressions. In a nutshell, the Stream API is about providing an implementation of the well known map-filter-reduce algorithm to the JDK.

map-filter-reduce：

List<Sale> sales = ...; // this is the list of all the sales
int amountSoldInMarch = 0;
for (Sale sale: sales) {
    if (sale.getDate().getMonth() == Month.MARCH) {
        amountSoldInMarch += sale.getAmount();
    }
}
System.out.println("Amount sold in March: " + amountSoldInMarch);

map：通过get取值，将部分字段映射到新数据（select字段）

locustfile中的User类和HttpUser类

Sat, 17 Jan 2026 00:00:00 +0000

locustfile是什么？

locustfile是Locust性能测试工具的用户脚本，描述了单个用户的行为。

locustfile是个普通的Python模块，如果写作locustfile.py，那么路径切换到文件所在目录，直接执行命令就能运行：

$ locust

如果换个名字，那么只能通过-f参数指定文件名运行：

$ locust -f locust_files/my_locust_file.py

与一般Python模块不同的是：locustfile必须至少定义一个类，且继承自User类。

User类

User类表示性能测试的模拟用户，Locust会在运行时创建User类的实例。

wait_time属性

设置等待时间，默认值不等待，立即执行。

Locust支持4种方式设置wait_time属性。

constant函数，常量，任务执行完毕等待X秒开始下一任务。

def constant(wait_time):
    """
    Returns a function that just returns the number specified by the wait_time argument

    Example::

        class MyUser(User):
            wait_time = constant(3)
    """
    return lambda instance: wait_time

between函数，区间随机值，任务执行完毕等待X-Y秒（中间随机取值）开始下一任务。

def between(min_wait, max_wait):
    """
    Returns a function that will return a random number between min_wait and max_wait.

    Example::

        class MyUser(User):
            # wait between 3.0 and 10.5 seconds after each task
            wait_time = between(3.0, 10.5)
    """
    return lambda instance: min_wait + random.random() * (max_wait - min_wait)

constant_pacing函数，自适应，若任务耗时超过该时间，则任务结束后立即执行下一任务；若任务耗时不超过该时间，则等待达到该时间后执行下一任务。

def constant_pacing(wait_time):
    """
    Returns a function that will track the run time of the tasks, and for each time it's
    called it will return a wait time that will try to make the total time between task
    execution equal to the time specified by the wait_time argument.

    In the following example the task will always be executed once every second, no matter
    the task execution time::

        class MyUser(User):
            wait_time = constant_pacing(1)
            @task
            def my_task(self):
                time.sleep(random.random())

    If a task execution exceeds the specified wait_time, the wait will be 0 before starting
    the next task.
    """

    def wait_time_func(self):
        if not hasattr(self, "_cp_last_run"):
            self._cp_last_wait_time = wait_time
            self._cp_last_run = time()
            return wait_time
        else:
            run_time = time() - self._cp_last_run - self._cp_last_wait_time
            self._cp_last_wait_time = max(0, wait_time - run_time)
            self._cp_last_run = time()
            return self._cp_last_wait_time

    return wait_time_func

自定义wait_time方法，比如每次等待时间1秒2秒3秒递增：

class MyUser(User):
    last_wait_time = 0

    def wait_time(self):
        self.last_wait_time += 1
        return self.last_wait_time

    ...

Python函数参数和注解是什么

Sat, 17 Jan 2026 00:00:00 +0000

四种参数

Python函数func定义如下：

def func(first, *args, second="Hello World", **kwargs):
    print(first)
    print(args)
    print(second)
    print(kwargs)


func("dongfanger", "san", py="good")

运行后会输出：

dongfanger
('san',)
Hello World
{'py': 'good'}

它有四种参数：

first是定位参数，positional parameter，不可省略。
*args是可变参数，arguments，存入元组。
second是默认值参数，default argument values，可以省略。
**args是关键字参数，keyword arguments，存入字典。

func函数的调用方式有以下这些：

①传入单个定位参数。

func("dongfanger")

dongfanger
()
Hello World
{}

②第一个参数后的任意个参数会被*args捕获，存入一个元组。

func("dongfanger", "a", "b", "c")

dongfanger
('a', 'b', 'c')
Hello World
{}

③没有明确指定名称的关键字参数会被**kwargs捕获，存入一个字典。

func("dongfanger", j="1", k="2")

dongfanger
()
Hello World
{'j': '1', 'k': '2'}

④second只能作为关键字参数传入。

func("dongfanger", second="cool")

dongfanger
()
cool
{}

⑤定位函数也能作为关键字参数传入。

func(first="san")

san
()
Hello World
{}

⑥字典前加上**，其所有元素作为单个参数传入，同名键会绑定到对应具名参数上，余下的被**args捕获。

tep1.0.0教程

Sat, 17 Jan 2026 00:00:00 +0000

正式版教程： https://dongfanger.gitee.io/blog/tep.html

Java官方笔记13集合

Fri, 16 Jan 2026 00:00:00 +0000

Storing Data

The Collections Framework is the most widely used API of the JDK.

the Collections Framework is a set of interfaces that models different way of storing data in different types of containers. Then the Framework provides at least one implementation for each interface.

There are two main categories of interfaces in the Collections Framework: collections and maps.（所以我猜想Python也是基于这样的考虑，设计了List和Dict，并作为Python基本数据类型，实际编码中要用到的也主要是这两类）

That makes two main categories, Collection and Map, a subcategory, Queue, and a side category, Iterator.

Python技术栈性能测试工具Locust入门

Fri, 16 Jan 2026 00:00:00 +0000

Locust是一款Python技术栈的开源的性能测试工具。Locust直译为蝗虫，寓意着它能产生蝗虫般成千上万的并发用户：

当Pytest遇上MVC分层设计自动化用例就该这么写

Fri, 16 Jan 2026 00:00:00 +0000

引子

数据写在代码里，追求快速编写用例，是我设计tep的一个特点，这在个人编写时是一种非常良好的体验。但相比于HttpRunner、JMeter等来说，总觉得还差点意思。思考良久，总结为三个字：工程化。工程化是我近一年在学习Java并参与了2个测试平台模块开发，和写了几个小工具后，感受到的一种编程思想。而其中最明显的就是Spring的MVC分层设计。为了让tep更工程化，后续版本将以MVC模块编写用例为准，同时会兼容之前的脚本式快速编写。

示例

目录结构

测试用例都放在一个文件夹下：

test_case：用例主程序；

steps：测试步骤；

data：纯粹的json；

测试用例

test_case.py是测试用例，包含的只有测试步骤：

import allure

from examples.tests.LoginToPayFlow.steps.step_add_cart import step_add_cart
from examples.tests.LoginToPayFlow.steps.step_order import step_order
from examples.tests.LoginToPayFlow.steps.step_pay import step_pay
from examples.tests.LoginToPayFlow.steps.step_search_sku import step_search_sku
from utils.cache import TepCache
from utils.step import Step

"""
测试登录到下单流程，需要先运行utils/fastapi_mock.py
"""


@allure.title("从登录到下单支付")
def test(login, env_vars, case_vars):
    case_vars.put("token", login["token"])
    cache = TepCache(env_vars=env_vars, case_vars=case_vars)

    Step("搜索商品", step_search_sku, cache)
    Step("添加购物车", step_add_cart, cache)
    Step("下单", step_order, cache)
    Step("支付", step_pay, cache)

TepCache是“缓存”，包括global_vars、env_vars、case_vars三个级别的变量池。

Step是一个泛化调用类，作用是打日志，调用第二个参数对应的步骤函数。

测试步骤

from utils.cache import TepCache
from utils.func import data
from utils.http_client import request


def step_search_sku(cache: TepCache):
    url = cache.env_vars["domain"] + "/searchSku"
    headers = {"token": cache.case_vars.get("token")}
    body = data("查询SKU.json")

    response = request("get", url=url, headers=headers, params=body)
    assert response.status_code < 400

    cache.case_vars.put("skuId", response.jsonpath("$.skuId"))
    cache.case_vars.put("skuPrice", response.jsonpath("$.price"))

from utils.cache import TepCache
from utils.func import data
from utils.http_client import request


def step_add_cart(cache: TepCache):
    url = cache.env_vars["domain"] + "/addCart"
    headers = {"token": cache.case_vars.get("token")}
    body = data("添加购物车.json")
    body["skuId"] = cache.case_vars.get("skuId")

    response = request("post", url=url, headers=headers, json=body)
    assert response.status_code < 400

    cache.case_vars.put("skuNum", response.jsonpath("$.skuNum"))
    cache.case_vars.put("totalPrice", response.jsonpath("$.totalPrice"))

步骤函数以step开头，尤其注意的是cache借助Python Typing提示，可以在编写下面代码时，获得PyCharm语法提示，所以一定不要忘了加上: TepCache：

关于版本质量的思考V2.0

Fri, 16 Jan 2026 00:00:00 +0000

本文来聊一下缺陷逃逸率，上线后发现缺陷数 / 有效缺陷总数，也就是漏测分析。

原来Python函数只是个对象

Fri, 16 Jan 2026 00:00:00 +0000

写Python越多，写函数越多，于是乎有人觉得Python是函数式语言，其实不然，Python只是从函数式语言中借鉴了一些好的想法而已。

Java官方笔记12异常

Thu, 15 Jan 2026 00:00:00 +0000

Exception

Definition: An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program’s instructions.

the checked exception

比如，java.io.FileNotFoundException

the error

比如，java.io.IOError

the runtime exception

比如，NullPointerException

error和runtime exception又叫做unchecked exception

Catching and Handling Exceptions

try {
    code
}
catch and finally blocks . . .

try {

} catch (ExceptionType name) {

} catch (ExceptionType name) {

}

使用|catch多个：

tep支持pytest-xdist分布式执行用例及合并Allure报告

Thu, 15 Jan 2026 00:00:00 +0000

tep0.11.1版本升级内容：

1、pytest-xdist分布式执行用例，合并Allure报告；

2、global_vars全局变量配置；

分布式执行用例

借助于pytest-xdist，在命令行执行时添加参数-n auto：

pytest -n auto

pytest-xdist会自动根据本地机器硬件配置，设置最优并发，并分发用例，分布式执行。

测试时先运行main.py，然后在case100目录下执行pytest -n auto --tep-reports：

第一次串行，第二次xdist并行：

执行时间从50s一下降到5s，性能提升还是非常的明显。

合并Allure报告

pytest-xdist分布式执行，只要把allure源文件，也就是那一堆json文件，存到同一个目录下，报告的数据就是一体的，不需要单独合并。但是有个问题，tep封装了--tep-reports 命令行参数一键生成Allure报告，背后的逻辑是在pytest_sessionfinish hook函数里面实现的，分布式执行时，每个xdist的node都是一个单独的session，多个node就会生成多份报告：

10个node生成了11份报告，其中1份master节点生成的。pytest-xdist的原理如图所示：

master节点不运行任何测试，只是通过一小部分消息与节点通信。子节点执行后会通过workeroutput把数据回传给master节点。所以只需要通过是否有workeroutput属性来判断master节点：

def _is_master(config):
    """
    pytest-xdist分布式执行时，判断是主节点master还是子节点
    主节点没有workerinput属性
    """
    return not hasattr(config, 'workerinput')

然后只在主节点的pytest_sessionfinish，生成1次报告，就能避免生成多份报告。这样在xdist分布式执行模式下，--tep-reports也只会生成1份合并后的包含所有测试用例的Allure HTML报告。

完整实现代码：

import time
import shutil

import allure_commons
from allure_commons.logger import AllureFileLogger
from allure_pytest.listener import AllureListener
from allure_pytest.plugin import cleanup_factory

reports_path = os.path.join(Project.root_dir, "reports")
allure_source_dir_name = ".allure.source.temp"
allure_source_path = os.path.join(reports_path, allure_source_dir_name)


def _tep_reports(config):
    """
    --tep-reports命令行参数不能和allure命令行参数同时使用，否则可能出错
    """
    if config.getoption("--tep-reports") and not config.getoption("allure_report_dir"):
        return True
    return False


def _is_master(config):
    """
    pytest-xdist分布式执行时，判断是主节点master还是子节点
    主节点没有workerinput属性
    """
    return not hasattr(config, 'workerinput')


def pytest_addoption(parser):
    """
    allure测试报告 命令行参数
    """
    parser.addoption(
        "--tep-reports",
        action="store_const",
        const=True,
        help="Create tep allure HTML reports."
    )


def pytest_configure(config):
    """
    这段代码源自：https://github.com/allure-framework/allure-python/blob/master/allure-pytest/src/plugin.py
    目的是生成allure源文件，用于生成HTML报告
    """
    if _tep_reports(config):
        if os.path.exists(allure_source_path):
            shutil.rmtree(allure_source_path)
        test_listener = AllureListener(config)
        config.pluginmanager.register(test_listener)
        allure_commons.plugin_manager.register(test_listener)
        config.add_cleanup(cleanup_factory(test_listener))

        clean = config.option.clean_alluredir
        file_logger = AllureFileLogger(allure_source_path, clean)  # allure_source
        allure_commons.plugin_manager.register(file_logger)
        config.add_cleanup(cleanup_factory(file_logger))


def pytest_sessionfinish(session):
    """
    测试运行结束后生成allure报告
    """
    if _tep_reports(session.config):
        if _is_master(session.config):  # 只在master节点才生成报告
            # 最近一份报告的历史数据，填充allure趋势图
            if os.path.exists(reports_path):
                his_reports = os.listdir(reports_path)
                if allure_source_dir_name in his_reports:
                    his_reports.remove(allure_source_dir_name)
                if his_reports:
                    latest_report_history = os.path.join(reports_path, his_reports[-1], "history")
                    shutil.copytree(latest_report_history, os.path.join(allure_source_path, "history"))

            current_time = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime(time.time()))
            html_report_name = os.path.join(reports_path, "report-" + current_time)
            os.system(f"allure generate {allure_source_path} -o {html_report_name}  --clean")
            shutil.rmtree(allure_source_path)

global_vars全局变量

在使用环境变量模版时，有些变量需要在多个模版重复设置，tep新增了global_vars全局变量fixture，可以将重复设置的变量，定义在resources/global_vars.yaml：

深度剖析Python字典和集合（下）

Thu, 15 Jan 2026 00:00:00 +0000

集合

集合的字面量是{1}、{1, 2}，和字典有点像，不同的是集合只有值没有键。

set构造方法

set构造方法如下：

my_set = {1, 2, 3}
my_set = set([1, 2, 3])

前者比后者更快更易读，因为对于前者，Python会利用一个专门的叫做BUILD_SET的字节码来创建集合。而对于后者，Python必须先从set这个名字来查询构造方法，然后新建一个列表，最后再把这个列表传入到构造方法里。

集合也有集合推导：

>>> my_set = {x for x in range(1, 4)}
>>> my_set
{1, 2, 3}
>>> type(my_set)
<class 'set'>

集合还有个不可变类型叫做frozenset，如同元组之于列表，它的构造函数如下：

>>> frozenset(range(10))
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

集合的操作

集合的本质是许多唯一对象的聚集，它最常见的操作是用来去重：

>>> my_list = [1, 2, 2, 3]
>>> set(my_list)
{1, 2, 3}
>>> list(set(my_list))
[1, 2, 3]

除此之外，集合还能进行数学运算，比如求交集、并集、差集等。示例，求needles的元素在haystack里出现的次数，暴力解法：

found = 0
for n in needles:
    if n in haystack:
        found += 1

集合解法：

found = len(needles & haystack)

即使不是set也能先转换为set：

found = len(set(needles) & set(haystack))

## 另一种写法
found = len(set(needles).intersection(haystack))

集合支持的操作如下：

散列表揭秘

这一部分的内容略微有点硬，请注意提前喝点水！

从上篇的简介可以知道，散列表就是一张表，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录。散列表其实是一个稀疏数组（总是有空白元素的数组称为稀疏数组），散列表里的单元叫作表元，在dict的散列表中，每个键值对占用一个表元，每个表元有两个部分，一个是对键的引用，另一个是对值的引用，因为所有表元的大小一致，所以可以通过偏移量来读取某个表元。

为什么要用稀疏数组？举个例子，身份证号411697199702076425，如果把它作为键存储到数组中，虽然能用O(1)时间就找到，但是需要开辟一个999999999999999999大的空间。假如只有1的空间，就只能把最后一位作为键存储到数组中，多个身份证号的键就容易冲突，得多看n位才能找到，要用O(n)时间。空间既不能太大，也不能太小，需要结合时间，在两者之间产生一个平衡，即空间和时间的平衡，所以要用稀疏数组！

Python会设法保证大概还有三分之一的表元是空的，用空间换时间，提高散列表查询效率。如果剩余空间不足，原有的散列表会被复制到一个更大的空间里面。

散列表的键值，又称为散列值，Python中可以用hash()方法来计算所有内置类型对象的散列值。

如果两个对象在比较的时候是相等的，那么它们的散列值必须相等，否则散列表就不能正常运行了：

>>> a = 1
>>> b = 1
>>> a == b
True
>>> hash(a)
1
>>> hash(b)
1
>>> a = "x"
>>> b = "x"
>>> a == b
True
>>> hash(a)
706802421
>>> hash(b)
706802421

越是相似但不相等的对象，它们的散列值的差别越大：

性能测试指标TP99，比平均响应时间更需要关注

Thu, 15 Jan 2026 00:00:00 +0000

什么是TP99？

TP是Top Percentile的首字母缩写，TP99是指“前百分之九十九”，用来表示满足百分之九十九的网络请求所需的最低耗时。

该怎么理解？举个简单例子，下图是100次请求的响应时间走势图：

第23次请求的响应时间为600ms，其他请求的响应全部为1ms，这个走势图也就是常说的“尖刺”。我们来计算一下：

①平均响应时间

平均响应时间 = 所有请求响应时间之和 / 请求次数，等于6.99ms

②TP99

TP99 = 把响应时间从小到大排列，取第99%那个位置的值，等于1ms

为什么TP99更需要关注？

平均响应时间受极端值的影响较大，因为出现1个尖刺，平均响应时间几乎是TP99的7倍！

TP99更能反映大多数请求的情况，通过TP99为1ms可以知道，应用系统对于大多数请求，都能在1ms内响应，整体性能达标。而对于尖刺，我们可以通过走势图的MAX来发现，单独进行分析。

在JMeter的Aggregate Report中，有3个字段：90% Line、95% Line、99%Line

其实就是指TP90、TP95、TP99。此外，在实际工作中，我们还会关注TP999，三个九，也就是99.9%。关注TP多少，取决于我们对性能的要求怎么样，我们希望应用系统满足多少请求。如果对性能要求不高，关注TP90就够了，允许10%请求出现波动。如果对性能要求很高，则需要关注TP999，99.9%请求都能够快速响应。

知识卡片，在技术学习中的运用

Thu, 15 Jan 2026 00:00:00 +0000

一、引言

技术学习有个特点，看完就忘，再看再忘，还看还忘。艾宾浩斯遗忘曲线，解释了这一现象，学习后的20分钟内，记忆的遗忘速度最快。1个小时后，遗忘速度开始减慢。1天后，遗忘速度显著降低。一段时间后，记忆会变得相对稳定。

为了能够记忆技术知识点，我们可以尝试理解技术逻辑，定时复习，主动回忆。通常的做法是将原文摘抄下来，回顾时再读一遍。缺点在于，技术逻辑与文学不同，每次都要烧脑，无法唤醒记忆。

二、什么是知识卡片

知识卡片是我在《高效学习法》学到的笔记技巧。简单来说，知识卡片就是把知识“画”在一张卡片上，重点是“画”。

（图片来源于《高效学习法》）

三、为什么需要知识卡片

知识呈现形式，影响着阅读理解难度，图形>表格>文字。技术逻辑是一个思考过程，想通了以后，在我们脑海中会浮现出一副图像，可能是流程图、数据流、树状图等。如果每次复习都能看到这幅图像，那么复习效率将会显著提升。很有必要，将这幅图像刻画出来。

四、怎么制作知识卡片

我们可以找个本子，用笔进行绘画，但是相对于纸质笔记，我更推荐使用电子笔记，便于存储，多设备阅读和分享。

知识卡片，可以使用常见的办公软件来制作，PowerPoint，俗称PPT。

先做好知识卡片分类，将同一类知识卡片放在同一个文件里面，创建多张幻灯片。

画图时随意发挥，只要能把技术逻辑描绘出来，自己能看懂，方便理解即可。

五、我的知识卡片分享

①流量录制回放

②消息队列

③ Java

六、总结

知识卡片，是一种视觉化的笔记方法，便于理解和记忆。学而不思则罔，思而不学则殆。知识卡片特别适合技术学习，温故而知新。感兴趣的小伙伴，动手画起来吧。

AI安全

Wed, 14 Jan 2026 00:00:00 +0000

10.1 AI安全风险的来源和分类

系统风险：AI模型软件的供应链风险、暴露面风险以及算力劫持风险。

网络风险：面向公网的入侵攻击，以及内网的隔离风险。

身份风险：对非人类身份的管控，越权访问，身份冒充等。

数据风险：Agent模型训练时的数据投毒，以及输入/输出阶段的敏感信息泄露等。

模型风险：Agent模型输入输出内容的恶意诱导、提示词攻击等风险。

应用风险：当AI在线上提供服务时，会面临Web入侵、DDoS攻击导致服务不可用等风险。

10.2 保护应用安全

10.2.1 背景和挑战

攻击者不再需要直接寻找暴露在公网服务中的漏洞，他们只需操纵相关的AI Agent，就能让这些AI Agent代为攻击内外部的弱电服务。

服务器端请求伪造（SSRF）是引入AI Agent后最突出的威胁。攻击者仅需通过自然语言提示，即可诱导受信任的Agent向内部网络发起恶意请求，窃取云环境凭证或扫描内网资产。Agent也可能被攻击者诱导产生包含SQL注入或XSS等恶意载荷，攻击与之交互的后端服务。

10.3.2 新的攻击面

构造恶意的语言诱导，让AI Agent变为一个无节制的资源消耗工具，使其无法正常为其他用户提供服务。构造复杂度炸弹式的指令，诱使AI Agent陷入生成海量文本的陷阱，生成数万乃至数十万的Token，导致其自身的计算成本飙升。

攻击者也可以攻击AI Agent调用的外部API，高频或海量触发复杂或昂贵的API调用。攻击者还能将恶意指令隐藏在AI Agent将要处理的网页、表格、PDF等外部数据中，当AI Agent处理这些被污染的数据时，隐藏的指令就会被执行。

10.3.3 防护思路

沿用并强化传统的应用安全最佳实践，同时实施严格的资源治理策略，针对工作流劫持类攻击，则需要设计更加完善的上下文隔离机制。

10.3.4 解决建议

一方面，对在AI场景下输入输出做安全检测的AI安全护栏方案，以及相关AI应用开发平台和网关对AI安全护栏的集成。另一方面，由于AI Agent进一步打破了传统的攻击面和网络边界，要更加关注纵深防御、动态检测、运行时安全等多种安全措施的组合。

例如当AI Agent未经过WAF或防火墙直接在内网发起恶意请求时，可以通过RASP等运行时检测方案或VPC防火墙来做防护，当AI Agent在用各种方式泄露敏感数据时，可以通过API安全、NDR等流量安全方案，从敏感数据流转的角度去及时发现风险。

10.3 保护模型安全

10.3.1 背景与挑战

输入层威胁：包括对抗样本攻击（如通过微调图像/音频诱导多模态Agent误判）、提示词注入的变种攻击（如上下文分割攻击、语义混淆攻击），以及通过恶意文件（如PDF隐写术）触发供应链漏洞。

推理层威胁：涵盖模型越狱导致的伦理失控、RAG知识库的定向爬取引发的数据资产泄露，以及函数调用劫持（如篡改API参数执行未授权操作）。

输出层威胁：设计生成式钓鱼内容（如伪造银行通知）、模型幻觉在医疗/金融场景的致命误导，以及通过隐写术在AIGC内容中植入隐蔽指令。

10.3.2 防护机制

内容合规审核，提示词攻击防御，敏感信息防护，恶意文件检测，恶意URL拦截，提示词反爬机制，模型越狱检测，模型幻觉抑制，数字水印标识。

10.3.3 模型安全的未来

自定义检测Agent可满足不同行业客户的特定业务风险识别需求。它引入了专用算法模型，并支持多行业多场景灵活配置，从而实现从通用到专属的安全检测能力升级。

10.4 保护数据安全

10.4.1 背景和挑战

10.4.2 防护框架

打造“平台可靠、链路可信、数据可控、自主可选、操作可审、责任可追”的数据安全保障体系。

10.4.3 构建全数据全生命周期的安全保障

1、数据收集

（1）数据来源：用户上传类数据、模型文件和推理数据、运行日志类数据。

（2）数据分类：以阿里云数据安全中心为例，从数据价值、敏感性、数据合规和业务需求等多角度将数据分为4个安全级别：S1、S2、S3、S4。

（3）数据脱敏

（4）数据去毒：对自有的存储资源中多种违规内容（例如涉黄、涉政、暴力、违法等）进行实时监控、检测和拦截。

2、数据传输

（1）面向数据传输提供私有网络加密

Java持久层框架Mybatis入门

Wed, 14 Jan 2026 00:00:00 +0000

MyBatis是什么

MyBatis是Java的持久层框架，GitHub的star数高达15.8k，是Java技术栈中最热门的ORM框架之一。它支持自定义SQL、存储过程以及高级映射，可以通过XML或注解来配置和映射原始类型、接口和Java POJOs为数据库中的记录。

安装

Maven pom.xml：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>
</dependency>

SqlSessionFactory

SqlSessionFactory的实例是每个MyBatis应用的核心，通过SqlSessionFactoryBuilder创建，能基于XML配置，也能使用Configuration类。

基于XML配置：

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory =
  new SqlSessionFactoryBuilder().build(inputStream);

实际项目中不会手动设置XML文件路径，而是直接读取classpath去找XML。

使用Configuration类：

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory =
  new JdbcTransactionFactory();
Environment environment =
  new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(BlogMapper.class);
SqlSessionFactory sqlSessionFactory =
  new SqlSessionFactoryBuilder().build(configuration);

由于Java注解的一些限制以及某些MyBatis映射的复杂性，MyBatis会优先选择XML配置。在上面的示例中，MyBatis会根据classpath和BlogMapper.class去找BlogMapper.xml。

Java官方笔记11包

Wed, 14 Jan 2026 00:00:00 +0000

Packages

Definition: A package is a grouping of related types providing access protection and name space management. Note that types refers to classes, interfaces, enumerations, and annotation types. Enumerations and annotation types are special kinds of classes and interfaces, respectively, so types are often referred to in this section simply as classes and interfaces.

创建

//in the Draggable.java file
package graphics;
public interface Draggable {
    . . .
}

//in the Graphic.java file
package graphics;
public abstract class Graphic {
    . . .
}

//in the Circle.java file
package graphics;
public class Circle extends Graphic
    implements Draggable {
    . . .
}

//in the Rectangle.java file
package graphics;
public class Rectangle extends Graphic
    implements Draggable {
    . . .
}

//in the Point.java file
package graphics;
public class Point extends Graphic
    implements Draggable {
    . . .
}

//in the Line.java file
package graphics;
public class Line extends Graphic
    implements Draggable {
    . . .
}

文件顶部第一行，每个文件只能有1个package关键字。

tep时隔8个月迎来重大全新升级

Wed, 14 Jan 2026 00:00:00 +0000

tep此次更新，旨在从“工具”升级为“框架”，为此做了大量的代码整洁工作，重新设计了部分功能，项目脚手架也焕然一新。

持续学习的动力

Wed, 14 Jan 2026 00:00:00 +0000

大学，已经过去十年了。

你的下一个压测工具可以是nGrinder

Wed, 14 Jan 2026 00:00:00 +0000

nGrinder小众而实用

nGrinder在GitHub的star有1.6k，相比于JMeter6.4k来说，要少很多。在测试资料中，关于压测工具也是以JMeter居多，几乎没有专门针对nGrinder的学习资料。nGrinder既然这么小众，那为什么还要学它呢？因为听说咱们公司的压测平台，底层就是用的nGrinder，对于企业级应用来说，nGrinder还是很实用的，正如它的介绍：“Enterprise level performance testing solution based on The Grinder”。

nGrinder有以下特点：

我们编写压测脚本用到的就是第一个特点提到的Groovy脚本，跟Java语法类似，可以无成本切换。

设计理念

nGrinder架构

nGrinder系统架构如下：

nGrinder的底层是Grinder，基于Grinder的console和agent，nGrinder封装成了controller和agent：

controller 提供了Web页面创建测试脚本和配置运行策略，这是nGrinder比较突出的特色了。
agent 虚拟用户生成器，创建压测负载。

当用户创建test后，会先创建一个console，AgentControllerServer会根据console分配相应的agent，AgentControllerServer管理着agent pool，负责agent的创建和释放。然后console将test脚本和资源多个已分配的agent，并控制整个test flow直到测试结束。测试结束后，agent会回收至AgentControllerServer以便其他test使用，console也会回收至ConsoleManager。

nGrinder和Ginder最大的不同之处在于，nGrinder在controller中保留了多个console实例和agent。每个console都是跟其他console隔离的，能并发运行。

不像其他压测工具在测试时，会保留agent以确保用户执行test时agent是可用的，也就是“预占”agent。nGrinder只有在真正测试执行时，动态分配agent，这个方案是nGrinder最独特的架构设计。它保证了多个压测任务能并发执行，并发上限只取决于空闲的agent数量。

nGrinder3.1版本以前是单机架构的，如下图所示：

1、nGrinder使用SVNkit，即svn server，来管理脚本文件。svn仓库存放在${NGRINDER_HOME}目录。

2、nGrinder使用EhCache缓存，提升DB和SVN查询性能。

3、nGrinder使用Spring Security保证安全，并使用Atlassian支持扩展。

nGrinder3.1版本之后，支持集群：

1、集群中所有console共享同样的DB和文件系统，并指向NFS共享的同一个${NGRINDER_HOME}。

2、每个controller有它自己的${NGRINDER_EX_HOME}，存放特殊配置和日志。

3、所有controller相互复制EhCache，让某些数据在集群中都是可见的。

nGrinder技术栈

Client层

Bootstrap、Bootstrap-slider、Jquery、Jquery Validate、Datatables、Select2、JqPlot、CodeMirror。

Controller层

FreeMarker、Spring Security、Spring MVC、GSon、SVNKit Dav。

Service层

The Grinder、Atlassian Plugin Framework、Spring、EhCache。

Data层

Spring Data、H2、Cubrid、Liquibase、SVNKit。

快速入门

安装

在GitHub Release下载war包：

https://github.com/naver/ngrinder/releases

执行命令：

java -jar ngrinder-controller-{version}.war

访问http://localhost:8080/即可。

但是由于nGrinder需要占用大量内存，最好加上额外参数：

深度剖析Python字典和集合（上）

Wed, 14 Jan 2026 00:00:00 +0000

“字典这个数据结构活跃在所有Python程序的背后，即便你的源码里并没有直接用到它”，摘抄自《代码之美》第18章Python的字典类：如何打造全能战士。字典是Python语言的基石！在函数的关键字参数、实例的属性和模块的命名空间都能够看到它的身影，我们自己写代码时也经常会用到。

AI评估

Tue, 13 Jan 2026 00:00:00 +0000

9.1 基于评估降低AI应用的不确定性

9.1.1 从确定性到不确定性

传统软件在很大程度上是确定性的，而AI应用其行为本质上是非确定性和概率性的。不确定性，就意味着对于相同的输入，它们可能产生不同的输出。

传统的QA流程，专为可预测的、基于规则的系统而设计，已无法充分应对这些由数据驱动的、自适应系统的挑战。

9.1.2 幻觉和不确定性的根因

AI应用的核心功能是基于从海量数据中学到的统计模式，来预测序列中的下一个词，而非真正意义上的理解。这就导致了“幻觉”现象，即模型生成听起来合理但实际上不正确或无意义的输出。

产生幻觉和不确定性的根本原因错综复杂：数据导致的缺陷、架构与建模的产物、错位与不确定性。

9.1.3 AI评估的重要些

从服务客户上看，评估是构建信任的核心机制。从商业视角看，严格评估直接转化为竞争优势。

AI的非确定性催生了评估经济，这是一个由可观测性平台、持续监控、自动化评估与治理即服务构成的新生态。评估不再是阶段性任务，而是与开发并行的持续工程实践，标志着AI原生时代质量保障的新范式。

9.2 AI评估体系

9.2.1 评估方法的基础二分法

1、内在评估 vs 外在评估

内在评估：侧重于孤立地评估模型输出的固有质量，而不考虑其在特定任务中的应用效果。评估的维度通常包括流畅性、连贯性、语法正确性以及事实准确性。

外在评估：通过衡量模型在特定下游任务或应用中的表现来评估其质量。

2、自动化评估 vs 人工评估

自动化评估：利用计算指标或利用其他AI模型来对模型输出进行打分。

人工评估：依赖人类评估员的判断来评估AI系统的输出质量，特别是在衡量帮助性、创造力、用户满意度等主观维度时。

在实践中，最佳的评估策略通常是自动化和人工评估的混合模式，利用自动化的效率进行大规模初步筛选，并结合人工的深度洞察力对关键或模糊的案例进行精细评估。

9.2.2 从静态到动态评估的演进

静态基准：静态基准是固定的、预先定义的数据集和任务组成。

动态评估：动态评估旨在模拟真实世界场景的复杂性和不可预测性，通过变化的变量、意外的输入和演进的上下文来测试系统。主要的动态评估方法包括：基于模拟的测试、实时对抗性基准、程序化生成。

9.2.3 现代AI评估的多范式全景

6个主要的评估范式：基准测试范式、“Evals”范式、心理测量学范式、人机交互范式、形式化方法范式、社会技术范式。

一个组织的评估栈，即其选择、组合和优先排序不同评估范式的策略，深刻地揭示了该组织在性能、用户价值和风险规避之间的权衡。

9.2.4 构建一个整体性的评估体系

一个完整的评估体系应包含8个核心组件：

性能指标，包括准确率、精确率、召回率、F1分数等。
鲁棒性与泛化测试
偏见与公平性评估
可解释性
合理性与伦理考量
持续监控与模型飘移检测
决策框架
自动化与人在回路

9.3 基于LLM的自动化评估

9.3.1 传统指标的局限性

传统的自动化评估指标，其核心是基于词汇或短语的重叠度来计算分数，这种方法对于需要捕捉语义、风格、语气和创造力等细微差别的现代生成AI模型来说，存在根本性不足。

另一方面，虽然人工评估被视为评估质量的“黄金标准”，但其高昂的成本、漫长的周期和固有的主观性，使其难以适应AI技术快速迭代的开发节奏。

9.3.2 LLM-as-a-Judge范式介绍

LLM-as-a-Judge范式，利用一个功能强大的大型语言模型来扮演裁判的角色，对另一个AI模型或应用的输出进行评分、排序或选择。

核心应用场景：数据标注、实时验证、为模型优化提供反馈。

9.3.3 LLM裁判的评估模式

逐点评估：裁判独立地评估单个模型输出，并根据预定义的量表给出一个绝对分数。

成对比较：裁判会同时看到两个来自不同模型的、匿名的输出，并被要求判断哪一个更好，或者两者是否相当。这是聊天机器人竞技场这样的众包评估平台所采用的核心方法。

9.3.4 控制LLM裁判的负面影响

1、系统性偏见：位置偏见、冗长偏见、自我偏好偏见、情绪与语气偏见、评分粒度有限。

LLM裁判产生的定量分数看似是精确的、数据驱动的，但实际上它们是通过一个充满主观偏见的过程生成的。因此一个来自LLM裁判的排行榜分数，并非对模型质量的纯粹客观测量，而是对裁判模型内在偏好和价值取向的反映。

2、递归依赖：能力天花板、推理幻觉。

一个较弱的LLM裁判无法公正地评估一个比它更强的候选模型。随着AI模型变得越来越强大，在评估其安全性和可靠性时，对人类专家和红队演练的依赖将会增加，而不是减少。

9.3.5 提升裁判可靠性的缓解策略

1、提示工程技术：思维链与分布推理、少样本提示、清晰的评分指南。

Java官方笔记10注解

Tue, 13 Jan 2026 00:00:00 +0000

注解

注解的作用：

Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
Compile-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
Runtime processing — Some annotations are available to be examined at runtime.

注解格式，使用@：

@Entity

带key-value：

@Author(
   name = "Benjamin Franklin",
   date = "3/27/2003"
)
class MyClass { ... }

只有1个key时可以省略key：

JMeter扩展Java请求

Tue, 13 Jan 2026 00:00:00 +0000

本文将通过WebRTC本地音视频流压测脚本，来说明JMeter如何扩展Java请求。

跟着官方文档学Maven构建生命周期

Tue, 13 Jan 2026 00:00:00 +0000

在IntelliJ IDEA中，显示了Maven的Lifecycle：

技术型测试的优势

Tue, 13 Jan 2026 00:00:00 +0000

如何提高测试竞争力，这个话题原本是想写“测试核心竞争力”的，酝酿了30天，迟迟无法落笔。所谓测试核心竞争力，主要有业务、技术、质量3个方向，我本想强调测试核心竞争力是质量，不能太过于追求业务和技术，要回归到质量保障这件事来。但是我错了，这是测试岗位的核心职责，并非测试人员的核心竞争力。

接口自动化项目落地之HTTPBin网站

Tue, 13 Jan 2026 00:00:00 +0000

接口自动化项目落地系列

找个开源网站或开源项目，用tep实现整套pytest接口自动化项目落地，归档到电子书，作为tep完整教程的项目篇一部分。自从tep完整教程发布以后，tep被越来越多小伙伴了解。教程只是纯理论，是骡子是马，拉出来遛遛才知道。做接口自动化项目落地，一方面是为了让自己脑海中的构想实实在在的呈现出来，现实和理想存在多少差距，不断尝试去弥补和修缮；另一方面也是方便读者朋友们学习使用，借助实际项目来练习，才能在赛道中弯道超车。

HTTPBin网站

httpbin.org是一个简单的在线提供HTTP服务的网站：

它能够用来对HTTP进行在线测试。

测试报告

HTTPBin网站的接口自动化项目包含11个用例集：

67条测试用例：

自动化执行正确率98.5%，其中有1条错误结果，是我故意为之的，因为想展示下断言失败的效果。

环境配置

包含http和https两套环境，因为HTTPBin支持HTTP&HTTPS：

fixtures/fixture_env_vars.py

#!/usr/bin/python
## encoding=utf-8

from tep.fixture import *


@pytest.fixture(scope="session")
def env_vars(config):
    class Clazz(TepVars):
        env = config["env"]

        """变量定义开始"""
        # 环境变量
        mapping = {
            "http": {  # http环境
                "domain": "http://httpbin.org",
            },
            "https": {  # https环境
                "domain": "https://httpbin.org",
            }
            # 继续添加
        }
        # 定义类属性，敲代码时会自动补全
        domain = mapping[env]["domain"]
        """变量定义结束"""

    return Clazz()

配置默认为http环境：

conf.yaml

env: http

用例集

http-methods

import allure
from tep.client import request


@allure.title("get请求")
def test(env_vars):
    # 描述
    # 数据
    # 请求
    response = request(
        "get",
        url=env_vars.domain + "/get",
        headers={'Host': 'httpbin.org', 'Proxy-Connection': 'keep-alive', 'accept': 'application/json',
                 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.109 Safari/537.36',
                 'Referer': 'http://httpbin.org/', 'Accept-Encoding': 'gzip, deflate',
                 'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7'},
        params={}
    )
    # 提取
    # 断言
    assert response.status_code < 400

auth

序列赋值引发的Python列表陷进

Tue, 13 Jan 2026 00:00:00 +0000

序列赋值是Python默认操作，如果使用不当，有可能会掉入语法陷阱。

AI可观测

Mon, 12 Jan 2026 00:00:00 +0000

8.1 AI可观测

8.1.1 什么是AI可观测

AI应用具有非确定性，即便是相同的提示，在不同次的运行中也可能产生不同的输出。如果没有可观测，在发生幻觉虚假错误等严重问题时根本无从查起。相反，一个好用的可观测工具会记录每一次的提示与响应、追踪使用模式，并标记异常。AI可观测是确保AI应用高效稳定安全运行的基础能力。

8.1.2 可观测 vs 监控：从“是什么”到“为什么”

监控关注“什么”：比如API响应时间、错误率、请求吞吐量和Token使用量等指标。

可观测性探究“为什么”：比如一个聊天机器人的回答不正确且耗时过长，监控可能只会显示错误率上升或延迟过高，但可观测能揭示为什么：可能是一次长时间的RAG请求最终得到了错误的召回，导致模型给出不准确的答案。

AI应用的每一次请求，都可以被弯针的追溯，包括调用工具的出入参、发送给大模型的具体提示词、任何中间步骤（如调用数据库或其他API），以及最终收到的输出。可观测工具就可以提供极其丰富的排查数据和上下文，帮助定位问题的根因。

8.1.3 AI可观测应对的核心挑战

性能与可靠性问题：大模型是资源密集型的，延迟峰值和瓶颈时有发生。

成本问题：许多大模型服务按Token使用量收费，若无控制，成本可能意外飙升。

质量问题：大模型的可能输出从训练数据中继承偏见或有害内容，也很可能产生幻觉。

8.1.4 AI可观测解决方案的关键能力

端到端全链路追踪：提供端到端的日志采集和链路追踪，可视化请求在整个AI应用中的执行路径。

全栈可观测：包含应用、AI网关、推理引擎可观测3个维度。

自动化评估功能：通过引入评估Agent，对应用和模型的输入输出进行自动化的评估，检测幻觉、不一致或答案质量下降等问题。

8.2 端到端全链路追踪

一个典型的LLM应用架构可能包含用户终端、认证模块、会话管理、对话服务、大模型路由、流程编排等。需要具备3项可观测能力：标准化的数据语义规范、低成本高质量的数据采集、端到端全链路追踪。

8.2.1 端到端全链路追踪的实现方式

面向AI应用的领域化Trace语义

基于OpenTelemetry的高质量数据采集

标准化协议

8.2.2 核心技术路径

1、链路插桩技术

Python探针，Monkey Patch

Java探针，字节码增强技术。

Go探针，编译时插桩技术。

多语言兼容，其他语言通过OpenTelemetry开源框架支持。

2、链路采集与加工

数据采集策略

流式场景优化

3、LLM Trace查询与分析

全链路透视

高级过滤

智能诊断

8.3 全栈可观测：应用可观测

8.3.1 AI原生应用开发的痛点

工具选择盲区、错误排除困难、Token消耗黑洞、循环调用陷阱。

8.3.2 AI原生应用可观测需要具备哪些能力

零代码接入、可视化工具选择过程、精准故障定位、Token成本分析、端到端链路追踪。

8.3.3 演示场景架构

使用LangChain框架构建一个Agent，大模型使用Qwen Turbo。SLS MCP服务器通过SLS HTTP OpenAPI访问日志的接口，完成日志分析请求。LangChain Agent与MCP服务器产生的观测数据会自动采集到可观测平台中。

DRF终极封装ViewSet和Router附教程PDF源码

Mon, 12 Jan 2026 00:00:00 +0000

在DRF官方教程的学习过程中，一个很明显的感受是框架在不断地进行封装，我们自己写框架/工具/脚本/平台也可以模仿模仿，先完成底层代码，再做多层封装，让使用者很容易就上手操作。本文是教程的最后一篇，介绍ViewSets和Routers。

Java官方笔记9Lambda表达式

Mon, 12 Jan 2026 00:00:00 +0000

Lambda Expression

有了Lambda Expression，就不用再写anonymous classes。

写Lambda，首先要找到它的类型。

There is a restriction on the type of a lambda expression: it has to be a functional interface.

函数接口，只有1个抽象方法的接口：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

默认方法do not count，所以下面这个也是函数接口：

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        // the body of this method has been removed
    }
}

静态方法也do not count，所以下面这个还是函数接口：

JMeter响应断言够用了

Mon, 12 Jan 2026 00:00:00 +0000

JMeter断言用来对服务器的响应数据进行验证，其中的响应断言基本能完成大多数的验证工作，但是JMeter还是提供了适用于多个不同场景的断言元件，一共16个，如下图所示：

对IoC容器和Bean的学习笔记

Mon, 12 Jan 2026 00:00:00 +0000

What We Mean by “Spring”

The term “Spring” means different things in different contexts. It can be used to refer to the Spring Framework project itself, which is where it all started. Over time, other Spring projects have been built on top of the Spring Framework. Most often, when people say “Spring”, they mean the entire family of projects. This reference documentation focuses on the foundation: the Spring Framework itself.

关于版本质量的思考V1.0

Mon, 12 Jan 2026 00:00:00 +0000

这个版本质量好不好？

每次遇到这种问题，都很难给出让人满意的答案。

本文梳理下当前我对版本质量的思考，未来会不断迭代更新我的认知。

软件产品质量模型，描述了8个特性：功能适用性、性能效率、兼容性、可用性、可靠性、安全性、可维护性、可移植性。这个模型可以从全局视角，对软件产品质量进行评估。

总不能每次发完版，就套用这个模型来给产品质量打个分吧。

更现实的做法是，定义量化指标多维度进行评估。

指标库是个庞大和复杂的体系，涵盖了项目、产品、需求、开发、测试、质量等多个方面的关键性能指标（Key Performance Indicators，简称KPIs）。

这里只罗列版本质量相关的指标：

线上问题数量及问题级别：系统发布触发用户问题。质量好不好，必然要看问题多不多，影响大不大。

需求缺陷密度：需求缺陷数 / 完成需求数。缺陷少，质量高。想必我们都体验过测出来一堆问题，上线后还是一堆问题的烂质量。

缺陷关闭率：已关闭缺陷数 / 有效缺陷总数。要想提高质量，就要解决问题。曾经历过遗留30个bug不处理就上线的，初创团队抢占市场可以理解，稳定产品的缺陷关闭率低就需要引起重视了。

缺陷关闭时长：所有缺陷(关闭时间 - 创建时间)求和 / 有效缺陷总数。长时间、跨版本都没有解决的问题，一拖再拖，说不定哪天就在线上暴雷了。所有问题都要及时关注，尽快修复。

缺陷逃逸率：上线后发现缺陷数 / 有效缺陷总数。测试同学注意了，灵魂三问，没有测过吗？为什么没测到？为什么不知道？遇到过测试马虎了事的，测试不给力，保不住质量下限。

除了怎么衡量版本质量以外，还有个问题是怎么交付出高质量产品，是让开发少写点bug，还是让测试多找点bug？

有个很有意思的说法是，高质量产品是用出来的。这个认知没有局限于开发、测试谁背锅的责任归属，而是从产品迭代的角度出发，更多的功能，更多的缺陷，就会投入更多的努力去修复这些质量问题，从而提高产品质量。

让更多客户使用，发现更多问题，持续完善产品，才能打磨出高质量产品。

民间流转的pytest项目结构设计

Mon, 12 Jan 2026 00:00:00 +0000

创建上图的pytest项目结构，只需要一条命令即可：

tep startproject demo

前提是安装tep0.9.8版本：

pip install tep==0.9.8

示例代码单独放在了samples文件夹下，可以放心将整个目录删除。其中的db演示了连接MySQL数据库，http演示了requests常见用法和tep request的猴子补丁，login_pay演示了从登陆到下单该如何编写脚本，包括httprunner、mvc（不推荐）、tep（强烈推荐）三种写法。

fixtures从conftest.py文件中单独拎了出来。这个设计与Django不谋而合，Django也有个叫做fixtures的文件夹，用来存放测试数据。其实pytest的fixture的本意是可以用来做setup和teardown的，从这个意义来说，fixtures就是存放测试数据的，比如封装登录接口为用例提供token。

utils存放了一些工具。比如自带的fastapi项目，request猴子补丁，mitmproxy抓包自动生成用例。request猴子补丁可以自定义日志输出格式，在发送请求前后完成任何你想做的操作。

tep0.9.8版本正式发布，对项目脚手架进行了精简，是为接下来的**《tep完整教程帮你突破pytest》**做好准备。

能取值亦能赋值的Python切片

Mon, 12 Jan 2026 00:00:00 +0000

切片，就像面包，给几刀，切成一片一片，可以做成吐司，也可以做成三明治，口味更佳：

AI应用运行时

Sun, 11 Jan 2026 00:00:00 +0000

7.1 AI应用运行时的演进趋势

7.1.1 从云原生到AI原生

云原生时代的核心是应用。将单体应用拆解为更小、更独立、更具弹性的微服务，并高效地在云基础设施上进行部署、扩展和管理。

而Agent的工作流，不再是执行一段固定的main函数，而是一个动态的、长周期的、充满不确定性的“思考-行动”循环。需要极致弹性和成本效益。需要数小时上下文记忆、拥有完整文件系统、并能与浏览器进行复杂交互。

7.1.2 Agentic AI应用的典型场景

场景一：交互式智能内容创作助手

对轮对话、上下文记忆、模型自托管、异构任务流、流式响应。

场景二：个性化AI客服

事件驱动、企业数据、实时在线。

场景三：通用Agent平台+病毒式传播的AIGC创意应用

Agent智能体、代码执行验证、部署与分享、脉冲式流量、大文件处理。

7.1.3 AI原生应用运行时的核心能力

1、面向会话的状态管理与安全隔离

2、大规模实时弹性与精益成本管理

3、异构算力与标准化工具连接能力

7.2 模型运行时

7.2.1 企业模型使用的核心痛点

资源浪费：业务流量波动大，高峰10万，平日几千，预留峰值会导致算力闲置。

冷启动：低频模型无法保持实例存活，使用时冷启动耗时长。

定制化：业务产品需要定制化，产品迭代周期长。

7.2.2 Serverless模型运行时的核心能力

Serverless是什么？

Serverless不是完全没有服务器，而是开发者不需要关心服务器的管理。对于开发者来说，只需关注代码，其他的交给云平台。主流Serverless平台包括阿里云函数计算、腾讯云云函数等。

Serverless和云服务器的区别？

云服务器只是一台远程的服务器；Serverless只上传代码片段（函数），不管服务器，当有请求触发时，代码才会运行。

1、异构算力和1/N卡切分使用

在算力层，Serverless模型运行时通过GPU虚拟化技术将单张GPU显卡划分为N个独立计算单元，每个实例具备隔离的显存空间与算力资源，不同实例通过GPU分时复用技术实现并行推理。

Serverless模型运行时通过池化技术，将CPU/GPU/XPU统一纳管到一个资源池，开发者可根据模型特性按需配置算力模型，比如语音识别等轻量任务分配CPU，图像生成等算力密集型任务分配GPU碎片，大语言模型等显存密集型任务分配GPU整卡或多卡。

2、负载感知调度和毫秒级闲置唤醒

在调度层，Serverless模型运行时通过负载感知调度系统实时监测请求队列深度、GPU显存占有率、实例健康状态等多维指标，基于池化技术构建三级响应机制：请求优先分配至活跃实例；当资源吃紧时，毫秒级唤醒闲置实例了；仅在极端流量下触发冷启动。

其核心技术突破在于利用CRID（用户空间检查点/恢复）技术冻结显存状态，并将显存数据临时置换至内存，并在新的请求调度前实现毫秒级/秒级状态恢复，较传统虚机/容器方案提速百倍。

3、集成加速框架和开发调试工具链

在开发层，Serverless模型运行时预集成加速框架深度优化模型运行效率：vLLM框架的Paged Attention技术通过显存分页管理提升3倍吞吐量；SGLang的RadixAttention实现注意力机制并行编译，降低60%推理延迟；TensorRT-LLM的量化融合策略提升2倍能效比。

开发工具链提供DevPod交互式环境，开发环节实现白屏化操作和实时反馈，集成在线IDE如VSCode/JupyterLab/SSH终端，开发者在云端环境具备比本地环境更高的生产效率；生产部署环节实现革命性简化——上传模型文件后，系统在30秒内自动生成Dockerfile、构建推理服务、输出OpenAPI文档及SDK。

总结，GPU碎片化技术提供原子级算力单元，为智能调度奠定资源基础；负载感知引擎通过毫秒级实例弹性，将碎片化算力转化为即时服务能力；开发工具链则构建自动化流水线，使技术红利直达开发者工作台。

7.2.3 Serverless模型运行时——AI大脑的终极载体

Serverless模型运行时实现了异构算力革命、智能调度进化、开发范式升级三重突破，是承载AI大脑的核心基座。

7.3 智能体运行时

7.3.1 AI应用形态的持续演进

1、“请求-响应”模式：无状态的事务性AI任务

通过快速复制无状态的计算实例来应对流量变化。

2、“对话”模式：有状态的协作式Agentic AI应用

7.3.2 Agent运行时的核心架构目标

1、围绕会话请求和资源调度模型，维持长时运行的状态延续

2、实现面向Active-Idle资源管理，解决长时运行的成本困境

7.3.3 现有架构支撑Agent运行时对比分析

7.3.4 为AI原生的“会话式”Serverless运行时

AI应用的会话既需要状态持久化，又需要高性能的本地计算和会话维度隔离能力。

一个会话，一个独立运行时：

原生会话状态保持
灵活可靠的安全隔离
毫秒级的弹性速度

7.4 工具与云沙箱

7.4.1 AI Agent与工具：从概念到能力

Agent常用工具类型：

DRF使用超链接API实现真正RESTful

Sun, 11 Jan 2026 00:00:00 +0000

很多API并不是真正的实现了RESTful，而应该叫做RPC (Remote Procedure Call 远程过程调用)，Roy Fielding曾经提到了它们的区别，原文如下：

JavaWeb开发进阶SpringMVC的DispatcherServlet

Sun, 11 Jan 2026 00:00:00 +0000

DispatcherServlet简介

DispatcherServlet是Spring MVC框架的核心组件，充当前端控制器（Front Controller）的角色。它负责接收所有的HTTP请求，并将它们分发给适当的处理器（控制器）。DispatcherServlet是整个Spring MVC应用程序的入口点，管理请求的整个生命周期。

通过源码查看DispatcherServlet定义：

public class DispatcherServlet extends FrameworkServlet
public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware
public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware

DispatcherServlet继承了FrameworkServlet，继承了HttpServletBean，继承了HttpServlet。HttpServlet来自jakarta.servlet.http.HttpServlet，也就是新版Servlet：

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.1.0</version>
    <scope>provided</scope>
</dependency>

果然，Spring MVC是基于Servlet的！

DispatcherServlet注册

DispatcherServlet是个Servlet，需要注册后才能使用。有3种注册方式：web.xml、Spring MVC、Spring Boot

① web.xml

<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

</web-app>

② Spring MVC

Java官方笔记8泛型

Sun, 11 Jan 2026 00:00:00 +0000

泛型

为什么需要泛型？generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods.

泛型有个好处是不需要类型转换：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   // no cast

这个例子的泛型，是指List的实现使用了泛型<T>，从而给使用带来了好处。

定义

class name<T1, T2, ..., Tn> { /* ... */ }

比如定义class List<T>，使用List<String>

将以下代码：

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

改为泛型实现：

JMeter定时器设置延迟与同步

Sun, 11 Jan 2026 00:00:00 +0000

JMeter定时器一般用来设置延迟与同步。它的作用域和优先级如下：

Python元组拆包捡到8倍镜快准狠

Sun, 11 Jan 2026 00:00:00 +0000

元组拆包

元组是不可变列表，列表是通过索引取值的，元组也是：

tuple_test = (1, 2, 3)
a = tuple_test[0]
b = tuple_test[1]
c = tuple_test[2]

但Python是出了名的一行代码解决问题，元组拆包就是精髓技术之一：

a, b, c = tuple_test

print("%s %s %s" % tuple_test)

把元组一一对应拆出来，就叫做元组拆包。拆包有个要求，元组中的元素数量必须跟接受这些元素的空挡数一致，否则会报错：

tuple_test = (1, 2, 3)
a, b = tuple_test  # ValueError: too many values to unpack (expected 2)

_占位符

使用_占位符可以解决这个问题：

tuple_test = (1, 2, 3)
a, b, _ = tuple_test

这样就只获取到部分数据了，这在取函数返回值时特别有用，比如：

import os

_, filename = os.path.split("/home/dongfanger/.ssh/idrsa.pub")
print(filename)  # "idrsa.pub"

*前缀

当返回值特别多时，_占位符写起来麻烦，可以用*来处理剩下的元素：

>>> a, b, *rest = range(5)
>>> a, b, *rest
(0, 1, [2, 3, 4])

注意rest是个列表，如果没有足够元素，会返回空列表：

>>> a, b, *rest = range(2)
>>> a, b, *rest
(0, 1, [])

*前缀变量能放在任意位置，比如，放在中间：

>>> a, *body, c, d = range(5)
>>> a, body, c, d
(0, [1, 2], 3, 4)

放在前面：

SpringBoot官方笔记8其他

Sun, 11 Jan 2026 00:00:00 +0000

Container Images

FROM eclipse-temurin:17-jre as builder
WORKDIR application
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
RUN java -Djarmode=layertools -jar application.jar extract

FROM eclipse-temurin:17-jre
WORKDIR application
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
COPY --from=builder application/snapshot-dependencies/ ./
COPY --from=builder application/application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

$ docker build --build-arg JAR_FILE=path/to/myapp.jar .

Production-ready Features

The spring-boot-actuator module provides all of Spring Boot’s production-ready features.

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

Endpoints

Actuator endpoints let you monitor and interact with your application. Spring Boot includes a number of built-in endpoints and lets you add your own. For example, the health endpoint provides basic application health information.

teprunner测试平台入门级部署手册发布啦

Sun, 11 Jan 2026 00:00:00 +0000

很多朋友是因为teprunner，也就是这个小众的pytest内核测试平台关注的公众号。为了让大家更好的上手teprunner，我更新了它的README，希望能让小伙伴们根据这些文档内容，一步一步的在自己本地电脑上把项目跑起来。项目跑起来之后，就可以参考前面一系列的学习教程，自己动手做一遍，在做的过程中和teprunner进行对比，不懂的点逐一突破，由点到面，完整实现。**这种学习方式能更快速的掌

tep集成mitmproxy录制流量自动生成用例

Sun, 11 Jan 2026 00:00:00 +0000

使用

操作过程非常简单，流程如下：

①配置过滤域名

必须配置，不然会有很多无效流量造成数据冗余。

②启动代理

「示例」使用了反向代理，tep自带FastApi启动Mock服务：

③录制流量

「示例」通过Postman发起请求：

自动生成用例

用例就在tests/mitm实时生成好了，用例文件名为当前时间：

每录制一个请求，就能在测试用例中看到实时添加了一条测试步骤：

    # 接口描述
    # 数据
    # 请求
    response = request(
        "{method}",
        url="{url}",
        headers={headers},
        {body_grammar}
    )
    # 数据提取
    # var = response.jmespath("expression")
    # 断言
    assert response.status_code < 400

录制完成以后，就可以再次编辑测试用例完善它。

原理

utils/mitm.py源码如下：

#!/usr/bin/python
## encoding=utf-8

## mitmproxy录制流量自动生成用例

import os
import time

from mitmproxy import ctx

project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
tests_dir = os.path.join(project_dir, "tests")
## tests/mitm
mitm_dir = os.path.join(tests_dir, "mitm")
if not os.path.exists(mitm_dir):
    os.mkdir(mitm_dir)
## 当前时间作为文件名
filename = time.strftime("%Y%m%d_%H_%M_%S", time.localtime()) + ".py"
case_file = os.path.join(mitm_dir, filename)
## 生成用例文件
template = """from tep.client import request


def test():
"""
if not os.path.exists(case_file):
    with open(case_file, "w", encoding="utf8") as fw:
        fw.write(template)


class Record:
    def __init__(self, domains):
        self.domains = domains

    def response(self, flow):
        if self.match(flow.request.url):
            # method
            method = flow.request.method.lower()
            ctx.log.error(method)
            # url
            url = flow.request.url
            ctx.log.error(url)
            # headers
            headers = dict(flow.request.headers)
            ctx.log.error(headers)
            # body
            body = flow.request.text or {}
            ctx.log.error(body)
            with open(case_file, "a", encoding="utf8") as fa:
                fa.write(self.step(method, url, headers, body))

    def match(self, url):
        if not self.domains:
            ctx.log.error("必须配置过滤域名")
            exit(-1)
        for domain in self.domains:
            if domain in url:
                return True
        return False

    def step(self, method, url, headers, body):
        if method == "get":
            body_grammar = f"params={body}"
        else:
            body_grammar = f"json={body}"
        return f"""
    # 接口描述
    # 数据
    # 请求
    response = request(
        "{method}",
        url="{url}",
        headers={headers},
        {body_grammar}
    )
    # 数据提取
    # var = response.jmespath("expression")
    # 断言
    assert response.status_code < 400
"""


## ==================================配置开始==================================
addons = [
    Record(
        # 过滤域名
        [
            "http://www.httpbin.org",
            "http://127.0.0.1:5000"
        ],
    )
]
## ==================================配置结束==================================

"""
==================================命令说明开始==================================
## 正向代理
mitmdump -s mitm.py
## 反向代理
mitmdump -s mitm.py --mode reverse:http://127.0.0.1:5000 --listen-host 127.0.0.1 --listen-port 8000
==================================命令说明结束==================================
"""

通过mitmproxy命令启动代理后，获取当前时间作为文件名在tests/mitm下生成用例文件，给addons添加插件Record类，通过response钩子捕获请求信息，对请求进行域名过滤，域名匹配成功的请求就使用测试步骤代码模板，填充method、url、headers、body数据，追加到测试用例文件中。

大模型时代，测试工作会有什么变化

Sun, 11 Jan 2026 00:00:00 +0000

“ChatGPT是倾盆大雨前的第一场雨”，OpenAI首席科学家Ilya Sutskever。

大模型是指在人工智能领域，尤其是机器学习和深度学习中，具有大量参数和复杂结构的模型。

大模型通过在大量数据上进行预训练，然后针对特定任务进行微调，最终部署到应用中以执行复杂任务。

最近百度推出的“萝卜快跑”打车（Robotaxi），就是大模型应用之一。收集大量驾驶数据，包括视频、图像、雷达、车辆传感器等数据，对数据进行标注、归一化和增强等预处理。然后对大模型进行预训练，学习道路环境、交通规则、物体识别等。根据自动驾驶需求，对模型进行微调，保持车道、避让障碍物、识别交通标识等。将训练好的模型集成到自动驾驶系统中，在模拟环境和封闭场地进行测试。经过充分的模拟和实车测试后，部署到出租车上，实现无人驾驶。

未来世界，到底是个什么样的世界啊。

截止2024年初，已有诞生了近百个参数规模大于100亿的模型，在图像语言、推荐系统、医疗诊断、办公软件等各行各业，掀起了滔天巨浪，甚至有人感叹第四次工业革命是不是就要到来。

从个人体验来说，日常工作中使用ChatGPT时间已经远远超过了搜索引擎。测试工作虽然没有颠覆式改变，但可以预见未来会有不少变化。

以下纯属我的猜想。

功能用例。AI可以根据需求文档分析出功能用例。只要针对垂直业务进行大量训练，一个既懂业务，又懂测试用例设计的机器人，是很可能出现的。

自动化用例。AI可以自动生成，自动执行，自动断言，自动完成自动化测试。流量录制回放已经替代了部分回归测试工作，有AI能力加持，很难不去想象，未来是不是会出现“无人回归测试”。

代码评审。AI可以分析增量代码，计算出影响范围，给出改动点、影响点和测试点。ChatGPT已经很懂代码了，再结合精准测试分析，这项技术会愈加成熟。

测试数据。AI可以生成各种各样的测试数据。文件数据、内存动态数据、数据库存储数据，想要什么给你什么。

测试工具。AI可以快速生成测试工具。ChatGPT具备强大的代码生成能力，创建工具将变得简单快捷。

AI未来是否会取代人类？测试工作的特点之一是重复性，AI恰好就是解决重复问题的，所以很多重复性测试工作，一定会被AI取代。但是AI始终无法取代测试人员，为什么？

因为AI不能替测试人员背锅呀。

AI网关

Sat, 10 Jan 2026 00:00:00 +0000

6.1 网关的演进历程

是什么在推动软件架构的演进呢？业务规模。业务从互联网、移动互联网以及即将到来的万物互联，其规模仍然在高速增长，也就意味着软件架构的复杂度也会越来越高，网关的特性也会越来越多。越来越复杂、越来越智能。

6.1.1 流量网关

代表软件是Nginx，将客户请求分配到不同的服务器上，从而实现流量负债均衡，避免单点故障，确保服务的稳定性和连续性。

6.1.2 ESB网关

ESB，企业服务总线，通过集中管理消息路由、转换和安全，实现服务的快速部署和高效运作。

6.1.3 微服务网关

微服务网关可以实现负载均衡、限流、熔断、降级、身份验证等功能，通过统一入口管理和优化各微服务间的交互。Spring Cloud Gateway是一个广泛应用的微服务网关。

6.1.4 云原生网关

云原生网关是伴随K8S的广泛应用而诞生的一种创新网关。既能有流量网关的特性来处理海量请求，又具备微服务网关的特性来做服务发现与服务治理，同时要求网关也具备弹性扩缩容能力解决容量调度问题。

6.1.5 AI网关

之前的几种类型网关处理的流量基本是以HTTP、RPC为主，多采用长连接，长连接采用request-response模式。AI采用的协议以SSE/Websocket为主，虽然也是长连接，但跟request-response模式相比，Server可以主动发送数据给Client，Websocket更是一种全双工协议，主要在语音类的实时通讯场景中使用。

AI场景对网关有新诉求，比如：多模型代理、智能路由、模型增强、安全防护、流式传输、无损变更等。

Higress网关已经在阿里云内部大规模生产落地，可以访问项目地址了解：https://higress.ai/

6.1.6 API网关

从流量网关，再到AI网关，都是API网关在不同软件架构下的网关形态。HTTP/gRPC/Dubbo/Websocket都可以称之为API，MCP、A2A也可以称之为API。

6.2 AI网关的定义、特点与应用场景

AI网关是提供多模型流量调度，MCP和Agent管理，智能路由和AI治理的下一代网关。AI网关不仅完整继承了API网关的通用能力，如安全认证、路由转发、流量控制等，也演进出了大模型Fallback、大模型负载均衡、Token级别的精细化流量管控、语义化缓存、内容安全、联网搜索、MCP协议转化和管理、工具精选和搜索效果优化等面向AI场景的能力。

6.2.1 AI应用的流量特征

高延时
大带宽与流式传输
长连接
API驱动

6.2.2 AI网关的应用场景

1、模型服务提供商（MaaS）的接入层

2、AI应用的开发网关

3、企业内部的中央AI网关

4、MCP工具生态的统一入口

5、构建企业AI能力货币化的统一开放平台

6.3 AI网关的核心能力和最佳实践

6.3.1 核心能力

1、多模型代理

2、多模型回退/容灾

3、消费者认证

4、内容安全防护

5、Token限流

6、语义缓存

7、可观测性

8、MCP代理

9、工具的动态组装

10、工具的智能路由

6.3.2 最佳实践

AI网关的原子能力可以总结为面向LLM、Agent、MCP和AI开放平台四大类，这里总结了8类常见的实践，多模型代理、消费者认证、内容安全与防护、Token限流、语义缓存、多模型容灾、多模型可观测和AI开放平台。

1、多模型代理

需求场景：

文本、图像、音频、3D等多模态业务场景。
企业不同垂直领域，需要调用专用模型。
任务需要多个模型分工协作。
医疗机构，处理患者数据使用私有模型，其他和患者无关使用通用模型。

DRF比Django的认证和权限高在哪里

Sat, 10 Jan 2026 00:00:00 +0000

Django可以用LoginRequiredMixin和PermissionRequiredMixin给类视图添加认证和权限，DRF做了高级封装，提供了更简洁的实现方式。我们通过继续学习官网教程来进行了解。

JavaWeb开发进阶SpringMVC简介

Sat, 10 Jan 2026 00:00:00 +0000

Spring MVC，又称为Spring Web MVC，名字来源于Spring模块spring-webmvc，是一个基于Servlet API开发的Web框架。

Java官方笔记7接口

Sat, 10 Jan 2026 00:00:00 +0000

接口

接口只能包含：constants, method signatures（abstract）, default methods, static methods, and nested types

方法体只存在于：default methods and static methods

接口不能实例化，只能被类实现，或者被其他接口继承（接口可以多继承）。

定义接口：

public interface OperateCar {

   // constant declarations, if any

   // method signatures
   
   // An enum with values RIGHT, LEFT
   int turn(Direction direction,
            double radius,
            double startSpeed,
            double endSpeed);
   int changeLanes(Direction direction,
                   double startSpeed,
                   double endSpeed);
   int signalTurn(Direction direction,
                  boolean signalOn);
   int getRadarFront(double distanceToCar,
                     double speedOfCar);
   int getRadarRear(double distanceToCar,
                    double speedOfCar);
         ......
   // more method signatures
}

类实现接口：

JMeter逻辑控制器完整介绍

Sat, 10 Jan 2026 00:00:00 +0000

JMeter逻辑控制器可以对元件的执行逻辑进行控制，就像编程一样，实现业务需求。

Python数据模型与Python对象模型

Sat, 10 Jan 2026 00:00:00 +0000

数据模型==对象模型

Python官方文档说法是“Python数据模型”，大多数Python书籍作者说法是“Python对象模型”，它们是一个意思，表示“计算机编程语言中对象的属性”。这句话有点抽象，只要知道对象是Python对数据的抽象，在Python中万物皆对象就可以了。

对象三要素

对象有三个要素：编号（identity）、类型（type）、值（value）。

identity

编号就是对象的内存地址，从创建后就不会改变。is运算符用来比较2个对象的编号。id()函数返回对象编号的整数表示。

type

类型决定了可以对对象做哪些操作，也定义了对象的可能值，比如int和bool类型的值就不一样。type()函数返回对象类型。很多人会误以为Python是弱类型语言，其实Python是强类型语言，这个误解的真实原因是，Python不需要编译，不需要提前知道变量的类型，在运行时才检查类型，这应该叫做动态语言。

类型在创建后也不会改变，虽然可以进行类型转换，但转换实际会产生新对象：

a = 1
print(id(a))
print(id(str(a)))
print(id(a))

结果为：

140715000207008
2136059506160
140715000207008

value

对象三要素中唯一能改变的就只有值了。官网有一句正确的废话：允许改变值的对象是mutable（可变的），不允许改变值的对象是immutable（不可变的）。它的意义在于当不可变对象的值是对可变对象的引用时，该如何判断对象的可变性？结论是不可变对象仍然是不可变的，因为这个引用是不能变的，但是我们通常会认为这个不可变对象的值是可变的，尤其是对象容器。对象类型也会决定是否可变，比如numbers、strings、tuples是不可变的，dictionaries、lists是可变的。

对象容器

有些对象包含了对其他对象的引用，这叫做containers对象容器，比如tuples、lists、dictionaries。大多数情况下，我们说容器的值，说的是引用的对象的值，而不是引用编号。但讨论容器可变性时，则仅仅是指容器直接包含的引用编号。比如tuple是不可变的，如果它包含了对一个可变对象的引用后，当该可变对象改变时容器的值也会改变。

对象回收

对象不会被显式销毁，但是它们会被当做垃圾回收，只要不存在对象引用，这就是Python垃圾回收机制！垃圾回收机制比较复杂，比如循环引用，实际上已经没有使用了，但是还存在引用等，涉及到算法规则，等写完Python进阶，在写Python原理时做进一步研究。

Python垃圾回收机制不是银弹，不能解决所有问题，所以在引用外部资源，比如打开文件后，我们需要注意显式close，防止资源始终占用内存，无法释放，造成内存泄漏。close除了手动调用close()方法外，也可以使用with来自动close。

类型决定一切

对象的类型几乎决定了对象的一切行为，甚至是对象编号，比如对于不可变类型：

a = 1
b = 1

a和b可能会指向同一个值为1的对象，也可能会指向两个不同的值为1的对象，这取决于具体实现。

但是对于可变类型：

c = []
d = []

c和d一定会指向两个不同的单独的空列表。

小结

Python数据模型就是常说的对象模型，万物皆对象，有编号、类型、值三个要素。了解了对象模型后，Python另一个重要概念即将浮出水面，它就是数据结构。

SpringBoot官方笔记7IO

Sat, 10 Jan 2026 00:00:00 +0000

Caching

Spring Boot auto-configures the cache infrastructure as long as caching support is enabled by using the @EnableCaching annotation.

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class MyMathService {

    @Cacheable("piDecimals")
    public int computePiDecimal(int precision) {
        ...
    }

}

Before invoking computePiDecimal, the abstraction looks for an entry in the piDecimals cache that matches the i argument. If an entry is found, the content in the cache is immediately returned to the caller, and the method is not invoked. Otherwise, the method is invoked, and the cache is updated before returning the value.

tep0.9.5支持自定义扩展request

Sat, 10 Jan 2026 00:00:00 +0000

tep0.9.5更新了以下内容：

teprunner重磅更新Git打通PyCharm与测试平台

Sat, 10 Jan 2026 00:00:00 +0000

经过Python测试交流群的小伙伴群策群力，teprunner添加了一个重要功能，把PyCharm中的代码，通过Git同步到测试平台中，生成测试用例。这样，teprunner就成了一个名副其实的pytest脚本在线管理平台。

测试流程，别再层层加码了

Sat, 10 Jan 2026 00:00:00 +0000

想当初，测试流程很纯粹，就是研发把代码写完了，功能交给测试，测试提bug，测完了上线，再发个测试报告，完事。

AI工具

Fri, 09 Jan 2026 00:00:00 +0000

5.1 AI工具简介

5.1.1 Function Calling

Function Calling需要编写代码，并且存在规格碎片化、可靠性挑战、工程治理缺位、厂商锁定与迁移成本高等问题。

5.1.2 MCP

MCP，Model Context Protocol，模型上下文协议，是一个开放标准，帮助连接AI助手与数据所在的系统，包括内容存储库、业务工具和开发环境。

MCP可以看作是AI应用程序的“USB-C端口”，就像USB-C为连接设备与各种外设提供了标准化方式，MCP为AI模型连接不同数据源和工具提供了标准化方法。

MCP把工具（Tools）、资源（Resources/用于检索与长上下文读写）、提示（Prompts）、会话（Sessions）、取样/推理（Sampling）等能力统一纳入协议语义，并标准化“枚举-描述-请求-响应-权限-审计”的全链路。传输层上，MCP不限定具体载体，既可以通过HTTP/WebSocket，也可以通过stdio等方式交换消息。

5.1.3 MCP就足够了吗

无论是RAG、Function Call还是MCP，其实都是为了让模型获取更多知识，调用更多工具来完成更复杂的事情。MCP并不是万能的，短期内存在不确定性与不同声音，国内是否成为事实标准亦未定。以MCP为协议底座，叠加AI工具接入的最佳实践与企业级安全治理，才能把“可接入”变成“可规模、可移植、可审计”的Agent能力。

5.2 AI工具标准化

5.2.1 MCP协议介绍

MCP协议遵循客户端-服务器（Client-Server）架构，允许AI应用程序通过MCP客户端与多个MCP服务器建立连接。MCP架构包含以下几个部分：

MCP Host：协调和管理一个或多个MCP客户端的AI应用程序，如Claude Desktop、Visual Studio Code等，需要通过MCP协议访问数据。
MCP Client：MCP客户端，运行在MCP Host内部，负责与MCP Server建立并维护连接。MCP Host会为每一个MCP Server单独创建一个Client，Client与Server保持一对一连接。
MCP Server：MCP服务器，轻量级程序，通过MCP协议公开特定功能。MCP协议规定了MCP Server可为Client提供工具、资源文件以及提示词模板。

MCP协议采用JSON-RPC 2.0作为通信规范，所有消息均使用JSON格式进行序列化。消息类型包括：Request、Result、Error、Notification。示例如下：

请求：

响应：

AI应用程序与MCP Server交互的整体流程如下：

5.2.2 MCP的核心优势

标准化模型与工具的连接方式
灵活的资源调度方式
支持双向、异步通信
支持能力共享
构建方式便捷

5.2.3 MCP面临的挑战

安全问题
大规模应用问题
集中管理问题

5.2.4 可行的解决方案

1、AI网关解决MCP安全问题

下一章将详细介绍AI网关。

2、工具优选和语义检索提升批量MCP的调用质量、降低调用耗时

工具优选：当模型请求在经过网关调用LLM时，携带含有大量工具的tool_calls数组时，网关侧基于Qwen3 Embedding和Qwen3 Reranker的方案，提供工具的精选能力，将tool_calls的数量压缩至目标数量，以提升模型响应速度与工具选择精确性。
语义检索：基于Higress网关的WASM插件机制，通过创建一个“All-in-One”的MCP Server，将用户在网关实例中注册的所有MCP工具进行统一聚合和管理，并提供智能的语义化检索能力。

DRF类视图让你的代码DRY起来

Fri, 09 Jan 2026 00:00:00 +0000

刚开始写views.py模块的代码，一般都是用def定义的函数视图，不过DRF更推荐使用class定义的类视图，这能让我们的代码更符合DRY（Don’t Repeat Yourself）设计原则：

JavaWeb开发基础ServletFilter

Fri, 09 Jan 2026 00:00:00 +0000

Filter是什么

Filter用于对请求和响应进行预处理和后处理。Filter链（Filter Chain）允许多个Filter依次处理同一个请求和响应。

Filter的使用场景

日志记录：记录请求和响应的详细信息，例如请求时间、响应时间、请求参数等
安全检查：检查用户是否有权限访问特定资源，例如验证用户身份、检查用户角色等
压缩：对响应内容进行压缩，例如使用GZIP压缩响应数据
字符编码设置：设置请求和响应的字符编码，例如将请求和响应的字符编码设置为UTF-8
输入验证：对请求参数进行验证，例如检查参数是否为空、参数格式是否正确等

Filter Interface

Filter接口有3个方法：

package javax.servlet;

import java.io.IOException;

public interface Filter {
    void init(FilterConfig var1) throws ServletException;

    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;

    void destroy();
}

容器在启动时创建Filter实例，并调用其init(FilterConfig filterConfig)方法进行初始化。每次请求到达时，容器调用Filter的doFilter(ServletRequest request, ServletResponse response, FilterChain chain)方法进行过滤。容器在关闭时调用Filter的destroy()方法进行清理。

Filter可以通过两种方式进行配置：

1.在web.xml中配置：

<filter>
    <filter-name>MyFilter</filter-name>
    <filter-class>com.example.MyFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>MyFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

如果采用web.xml，那么去掉Filter只需要修改web.xml即可，不需要修改代码。

2.使用注解配置：

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter("/*")
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 预处理操作
        System.out.println("Request received at " + System.currentTimeMillis());

        // 继续执行下一个过滤器或目标资源
        chain.doFilter(request, response);

        // 后处理操作
        System.out.println("Response sent at " + System.currentTimeMillis());
    }

    @Override
    public void destroy() {
        // 清理操作
    }
}

FilterChain Interface

Filter接口的doFilter方法，第3个参数类型是FilterChain，它的定义如下：

Java官方笔记6继承

Fri, 09 Jan 2026 00:00:00 +0000

继承

Java只有单继承，最顶级的父类是Object。

子类会继承父类的fields和methods，而不会继承constructors，因为constructors不属于methods，但是子类可以通过super调用父类的constructor。

子类继承父类的范围是：public、protected、package-private

隐式转换，子类转父类（只有1个爸爸）：

Object obj = new MountainBike();

显示转换，父类转子类（有多个子女，所以要明确指定）：

MountainBike myBike = (MountainBike)obj;

类有field，而接口没有，所以在多继承时就有问题：如果多个类有相同的field，那么子类将不知道用哪一个，而接口不存在这个问题。Java不支持继承多个类，但是可以实现多个接口。

重载

子类的方法跟父类有完全相同的签名和返回类型（也可以是子类），将会覆盖父类方法Override。

如果子类定义了1个static方法，跟父类完全相同，那么父类方法会被隐藏Hide。

Override和Hide是不同的：

public class Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Animal");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method in Animal");
    }
}

public class Cat extends Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Cat");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method in Cat");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        Animal myAnimal = myCat;  // 隐式转换
        Animal.testClassMethod();  // 调的父类
        myAnimal.testInstanceMethod();  // 父类对象引用，还是调的子类
    }
}

The static method in Animal
The instance method in Cat

Override只会调子类方法，而Hide取决于调用方是父还是子，比如这里的myCat，隐式转换为父类Animal后，会调父类的static方法，而调的实例方法却是子类的。（如果不是隐式转换，而是直接给父类实例化，那肯定还是调父类方法）

JMeter36个内置函数及11个新增函数介绍

Fri, 09 Jan 2026 00:00:00 +0000

JMeter内置了36个函数，这些函数可以通过函数助手进行编辑和测试。了解这些函数，不仅能提高JMeter的使用熟练度，也有助于知晓测试工具或测试框架通用的函数有哪些，在自主设计时，作为参考借鉴。

Python骚操作从列表推导和生成器表达式开始

Fri, 09 Jan 2026 00:00:00 +0000

序列

序列是指一组数据，按存放类型分为容器序列与扁平序列，按能否被修改分为不可变序列与可变序列。

容器序列与扁平序列

容器序列存放的是对象的引用，包括list、tuple、collections.deque。

扁平序列存放的是对象的值，包括str、bytes、bytearray、memoryview和array.array。

不可变序列与可变序列

不可变序列，包括tuple、str、bytes。

可变序列，包括list、bytearray、array.array、collection.deque、memoryview。

下图左边是父类，右边是子类，可以看出可变序列是从不可变序列继承来的，扩展了可变方法：

列表推导

Python语言魅力在于简洁，这能从最常见的创建列表体现出来，比如我们想把字符串"abc"转换成新列表["a", "b", "c"]，常规写法：

symbols = "abc"
codes = []
for symbol in symbols:
    codes.append(symbol)
print(codes)  # ["a", "b", "c"]

用到了for循环和列表append方法。实际上可以不用append方法，直接：

symbols = "abc"
codes = [symbol for symbol in symbols]

这叫做列表推导，是更加Pythonic的写法。

无论是编写效率还是可阅读性，列表推导都更胜一筹，可以说是构建列表的快捷方式。但是不能滥用，通用原则是，如果列表推导的代码超过了两行，就要考虑用append了。这不是规定，完全可以凭借自我喜好来选择。

笛卡尔积是指多个序列中元素所有组合，我们用列表推导来实现笛卡尔积：

colors = ["black", "white"]
sizes = ["S", "M", "L"]
tshirts = [(color, size) for color in colors for size in sizes]

一行代码搞定！Life is short，use Python，list comprehension is wonderful，amazing。

SpringBoot官方笔记6消息

Fri, 09 Jan 2026 00:00:00 +0000

The Spring Framework provides extensive support for integrating with messaging systems, from simplified use of the JMS API using JmsTemplate to a complete infrastructure to receive messages asynchro

teprunner测试平台定时任务这次终于稳了

Fri, 09 Jan 2026 00:00:00 +0000

teprunner测试平台已经有一个多月没有更新了，主要原因是定时任务不够稳定，经过反复试错，找到了解决办法，这次终于稳定了。

tep支持MVC架构实现用例数据分离

Fri, 09 Jan 2026 00:00:00 +0000

大家好，我是刚哥。

自动化用例依赖问题，是个伪命题

Fri, 09 Jan 2026 00:00:00 +0000

伪命题，是指那些表面上看似正确，但实际上是错误的、没有意义的或者根本无法验证的命题。

DRF对Django请求响应做了技术升级

Thu, 08 Jan 2026 00:00:00 +0000

Django视图是用来处理请求和响应的，Django默认是按Form和Template来设计的，如果要处理以JSON格式为主的RESTful API，那么就需要对Django请求和响应的处理代码进行优化改造，本文就来介绍DRF在这一部分的技术升级。

JavaWeb开发基础Servlet事件和监听器

Thu, 08 Jan 2026 00:00:00 +0000

事件和监听器

事件是指在程序运行过程中发生的特定动作或情况。比如：

用户操作，如点击按钮、输入文本
系统操作，如文件读取完成、网络连接断开
应用程序内部的状态变化，如对象属性改变、方法调用

监听器是一个接口或类，用于定义在特定事件发生时要执行的操作。监听器会“监听”特定的事件，当事件发生时，监听器中的相应方法会被调用，从而执行预定义的操作。

事件和监听器是相辅相成的，它们的工作原理如下：

事件源：触发事件的来源。例如，按钮是事件源，点击按钮会触发点击事件
事件对象：当事件发生时，事件源会创建一个事件对象，包含有关事件的信息
注册监听器：监听器需要注册到事件源，以便监听特定的事件。注册后，事件源会在事件发生时通知监听器
事件处理：当事件发生时，事件源会调用监听器中的相应方法，传递事件对象，从而执行预定义的操作

Servlet Event Class

事件（Event）是一个类，封装了与特定事件相关的信息。

基本是构造方法和get方法：

ServletRequestEvent

public class ServletRequestEvent extends EventObject {
    private static final long serialVersionUID = 1L;
    private final ServletRequest request;

    public ServletRequestEvent(ServletContext sc, ServletRequest request) {
        super(sc);
        this.request = request;
    }

    public ServletRequest getServletRequest() {
        return this.request;
    }

    public ServletContext getServletContext() {
        return (ServletContext) super.getSource();
    }
}

ServletRequestAttributeEvent

public class ServletRequestAttributeEvent extends ServletRequestEvent {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final Object value;

    public ServletRequestAttributeEvent(ServletContext sc, ServletRequest request, String name, Object value) {
        super(sc, request);
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public Object getValue() {
        return this.value;
    }
}

ServletContextEvent

public class ServletContextEvent extends EventObject {
    private static final long serialVersionUID = 1L;

    public ServletContextEvent(ServletContext source) {
        super(source);
    }

    public ServletContext getServletContext() {
        return (ServletContext) super.getSource();
    }
}

ServletContextAttributeEvent

public class ServletContextAttributeEvent extends ServletContextEvent {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final Object value;

    public ServletContextAttributeEvent(ServletContext source, String name, Object value) {
        super(source);
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public Object getValue() {
        return this.value;
    }
}

HttpSessionEvent

public class HttpSessionEvent extends EventObject {
    private static final long serialVersionUID = 1L;

    public HttpSessionEvent(HttpSession source) {
        super(source);
    }

    public HttpSession getSession() {
        return (HttpSession) super.getSource();
    }
}

HttpSessionBindingEvent

public class HttpSessionBindingEvent extends HttpSessionEvent {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final Object value;

    public HttpSessionBindingEvent(HttpSession session, String name, Object value) {
        super(session);
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public Object getValue() {
        return this.value;
    }
}

Java单元测试Mock框架Mockito入门介绍

Thu, 08 Jan 2026 00:00:00 +0000

鸡尾酒

Mockito是Java的单元测试Mock框架。它的logo是一杯古巴最著名的鸡尾酒Mojito，Ｍojito鸡尾酒，源自古巴的哈瓦那，带有浓厚的加勒比海风情。并不浓烈，但是喝一杯下去，脸上会泛起红晕，象少女的羞涩。味道很清新，有一点青涩、有点甜蜜。

Stub & Mock

Stub和Mock是Test Double类型中的2种。Test Double一共有5种类型，Dummy，Stub，Spy，Mock，Fake。

Test Double是测试复制品，用来统称模拟真实对象的假对象。因使用场景有略微不同，而有这5种类型。

Dummy，通常只用来填充参数列表。有可能是null对象引用，或Object类实例等。
Fake，是简化版的实现，比如基于内存实现的数据库，不会真的去做数据库操作，用简单的HashMap来存放数据。
Stub，Stub用来替代SUT(System Under Test)依赖的组件，但是只模拟一个外部依赖，不做断言。
Spy，介于Stub和Mock之间。如果真实对象没有被打桩，当调用Spy对象时，真实对象也会被调用。
Mock，可以理解为Stub+Verification，既模拟外部依赖，也会定义预期结果。

看一个实例，发送邮件，

public interface MailService {
    public void send(Message msg);
}

先写个Stub，

public class MailServiceStub implements MailService {
    private List<Message> messages = new ArrayList<Message>();

    public void send(Message msg) {
        messages.add(msg);
    }

    public int numberSent() {
        return messages.size();
    }
}

实现Stub的状态验证，

class OrderStateTester…

public void testOrderSendsMailIfUnfilled() {
    Order order = new Order(TALISKER, 51);
    MailServiceStub mailer = new MailServiceStub();
    order.setMailer(mailer);
    order.fill(warehouse);
    assertEquals(1, mailer.numberSent());
}

只做了简单的测试，断言发出了1封邮件。没有测试是否发送给了对的收件人，或者邮件正文是否正确。不过不影响跟Mock比较。

Java官方笔记5数字和字符串

Thu, 08 Jan 2026 00:00:00 +0000

Numbers

Number的子类：

另外还有BigDecimal和BigInteger，用于高精度计算，AtomicInteger和AtomicLong用于多线程应用。

我们有时候需要用包装类而非基本数据类型，理由如下：

方法入参类型为Object，只能传入对象
使用包装类提供的常量，比如MIN_VALUE和MAX_VALUE
使用包装类的方法来做类型转换

format

import java.util.Calendar;
import java.util.Locale;

public class TestFormat {

    public static void main(String[] args) {
      long n = 461012;
      System.out.format("%d%n", n);      //  -->  "461012"
      System.out.format("%08d%n", n);    //  -->  "00461012"
      System.out.format("%+8d%n", n);    //  -->  " +461012"
      System.out.format("%,8d%n", n);    // -->  " 461,012"
      System.out.format("%+,8d%n%n", n); //  -->  "+461,012"

      double pi = Math.PI;

      System.out.format("%f%n", pi);       // -->  "3.141593"
      System.out.format("%.3f%n", pi);     // -->  "3.142"
      System.out.format("%10.3f%n", pi);   // -->  "     3.142"
      System.out.format("%-10.3f%n", pi);  // -->  "3.142"
      System.out.format(Locale.FRANCE,
                        "%-10.4f%n%n", pi); // -->  "3,1416"

      Calendar c = Calendar.getInstance();
      System.out.format("%tB %te, %tY%n", c, c, c); // -->  "May 29, 2006"

      System.out.format("%tl:%tM %tp%n", c, c, c);  // -->  "2:34 am"

      System.out.format("%tD%n", c);    // -->  "05/29/06"
    }
}

DecimalFormat

JMeter四种参数化方式

Thu, 08 Jan 2026 00:00:00 +0000

JMeter参数化是指把固定的数据动态化，这样更贴合实际的模拟用户请求，比如模拟多个不同账号。JMeter一共有四种参数化方式，分别是：

SpringBoot官方笔记5Data

Thu, 08 Jan 2026 00:00:00 +0000

Spring Boot integrates with a number of data technologies, both SQL and NoSQL.

teprunner测试平台用例编写等体验响应式升级

Thu, 08 Jan 2026 00:00:00 +0000

本文开发内容

在免费开源的测试平台中，teprunner的UI界面应该算得上第一梯度了，BUT，美中不足，在不同分辨率显示器（比如13.3寸小屏笔记本）下布局大的弹出窗口，表现不尽如人意。而这又是核心功能代码编辑的界面，比如用例编写、fixture编写，很有必要优化升级。除此之外还有滚动条的问题：竖向双滚动条和横向滚动条，也对体验造成影响。本文将对这些内容进行改造，具体如下：

编写用例页面，从弹窗改为子页面。
编写fixture页面，从弹窗改为子页面。
代码编辑区域高度自适应。
缩小左侧菜单，移动项目环境和新增按钮同一行，扩大编辑区面积。
消除所有双向滚动条。
消除所有横向滚动条。
语法说明添加环境变量和fixtures示例代码。
其他细节优化。

响应式是指同一套前端代码在不同浏览器（PC端、移动端等）都能适配，Element UI已经是响应式设计了，本文的响应式体现在代码编辑区行高根据window.innerHeight自动计算设定。

升级效果展示

左侧菜单栏变窄；添加环境变量和fixtures示例代码。

项目环境和新增按钮同一行显示，扩大有效内容可视面积。

fixtures的新增和编辑从弹窗改为子路由页面，代码编辑区高度自适应，纵向滚动条只出现一个。

消除横向滚动条；缩小了用例描述列以外其他列宽；替换操作按钮文字为图标。

用例的新增和编辑从弹窗改为子路由页面，代码编辑区高度自适应，纵向滚动条只出现一个。

用例运行结果的新增和编辑从弹窗改为子路由页面，代码编辑区高度自适应，纵向滚动条只出现一个。

测试计划的新增，编辑，运行结果也做了相同调整。

整体而言，有效信息的可视面积和可操作面积都尽可能扩大了！

关键技术点

前端代码修改文件如下：

比较繁琐，没有新知识，这里就不一一讲解了，而是选择用到的关键技术点来进行知识回顾：

template添加<router-view></router-view>
主页面div添加v-if="$route.name === 'name'"
在router/index.js中添加children子路由
跳转页面前，存localStorage
新页面create()时，取localStorage
this.$router.push跳转路由
div同行显示用float: left，紧跟的div换行用clear: both
window.innerHeight获取屏幕高度

小结

本文完成了对teprunner测试平台前端UI界面的体验升级，已经适配13.3寸到27寸显示器，如果还在担心不好用的话，那么现在可以好好试试了。定时任务从目前优化效果来看，已经趋于稳定，不久就会和大家见面。

tep集成HttpRunner与Flask实现开箱即用

Thu, 08 Jan 2026 00:00:00 +0000

大家好，我是刚哥。

魔法方法推开Python进阶学习大门

Thu, 08 Jan 2026 00:00:00 +0000

热爱Python

Python是Guido van Rossum设计出来的让使用者觉得如沐春风的一门编程语言。2020年11月12日，64岁的Python之父宣布由于退休生活太无聊，自己决定加入Microsoft的DevDiv Team，致力于“确保更好地使用Python”。尽管在国内有些声音在Diss着Python，认为它太简单，只是个脚本语言，但是它的发明者对Python的热情，仍然激励着我们坚持对Python的热爱。

奇迹时刻

collection.len()是面向对象语言的写法，len(collection)是Python语言的写法，这种风格叫做Pythonic。从前者到后者，就像变魔术一样，一瞬间让人眼前一亮。这个魔术就是Python魔法方法，或者叫双下方法，它是用双下划线开头和双下划线结尾的特殊方法，比如obj[key]，Python解释器实际上会转换成obj.__getitem__(key)来运行，但是使用者并无感知。

`getitem`和`len`

__getitem__用来获取数据，__len__用来返回长度，这2个魔法方法是Python基础，我们通过一副扑克牌来了解：

import collections

# 定义一副牌
Card = collections.namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
    # 大小
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    # 花色
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        # 生成一副牌
        self._cards = [Card(rank, suit) for suit in self.suits
                                        for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

本来我们对这副牌什么都不能做，但是由于实现了__len__，可以使用len()函数查看有多少张牌：

>>> len(deck)
52

由于实现了__getitem__，可以使用中括号索引取值：

>>> deck[0]
Card(rank='2', suit='spades')

能进行切片：

>>> deck[:3]
[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]
>>> deck[12::13]
[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]

能迭代：

如何构建“测试开发体系”

Thu, 08 Jan 2026 00:00:00 +0000

构建知识体系，首先需要具备写作习惯和写作能力。笔记的重点是记录，需要养成记笔记的习惯，把知识保存下来。良好的写作能力，可以将复杂的概念用文字清晰表达，具有逻辑性和条理性。知识体系的展现形式，不只是脑图，还包括文档、幻灯片、流程图等，既要会写又要会画，通过多种形式将知识呈现出来。

上下文工程

Thu, 08 Jan 2026 00:00:00 +0000

4.1 提示词工程

提示词工程，不是简单的提问，而是一套涵盖指令设计、上下文注入、角色设定和格式控制的综合性技术。

4.1.1 优秀提示词的核心实践

明确角色与目标

范例：“假设你是一位拥有10年经验的市场营销总监，请为一款新型智能手表起草一份面向年轻专业人士的产品介绍文案。”
提供清晰指令与完整上下文

范例：“请总结以下技术文章的核心观点（不超过200字），并列出其中提到的三个关键数据。不要添加个人评论。文章内容如下：[在此处粘贴文章]”
运用范例进行引导

范例：“请分析以下句子的情感及关键对象。范例：输入：‘我喜欢这部电影的剧情。‘输出：{‘sentiment’: ‘positive’, ‘aspect’: ‘plot’}。现在，请分析这个句子：‘这台相机的画质很棒，但电池续航太短。’”
定义结构化输出格式

范例：“请将你的回答组织成JSON格式，包含’product_name’和’key_features’两个字段，其中key_features是一个包含至少三项功能的数组。”

4.1.2 提示词工程的固有局限性

应对动态及长流程任务的局限
应对模型固有的无状态特性
无法突破模型固有的知识边界
长上下文中的信息利用不均衡

正是因为提示词工程有诸多局限性，上下文工程（Context Engineering）应运而生。

4.2 上下文工程

上下文工程的核心理念，在于将AI应用开发的焦点从优化单次交互的指令，转向为模型的每一次推理动态构建一个完整、准确且高效的认知环境。它不再局限于设计静态的提示词模板，而是致力于创建一个系统，确保模型在执行任务时，能够实时获取并利用完成该任务所需的所有相关信息，包括外部知识、历史记忆、可用工具及执行环境。

4.2.1 上下文工程与提示词工程的核心区别

4.2.2 上下文工程的关键组成部分

外部知识库的动态供给
长期与短期记忆系统
工具与能力的扩展
运行时的上下文管理

4.3 RAG技术原理与挑战

4.3.1 RAG的基础范式：三阶段工作流

1、第一阶段：索引（Indexing）

将原始的外部知识转化为机器可高效检索的格式。文档解析与提取，文本分块（Chunking），语义向量化（Embedding），构建向量索引库。

2、第二阶段：检索（Retrieval）

根据用户的自然语言查询，从已构建好的向量索引库中，快速、准确地找出最相关的N个知识块（Top-K）。

3、第三阶段：生成（Generation）

将前一阶段检索到的多个相关知识块与用户的原始查询进行整合，构建一个增强的提示词（Augmented Prompt）。比如：

4.3.2 RAG在工程化落地中面临的挑战

知识单元的完整性与信息密度的抉择
难以精准捕捉模糊、多样的用户意图
召回匹配时难以兼顾语义相关性与关键词精确性
需要探索如何在检索精度与完整性之间取得平衡
应对需要多知识点综合推理的查询实现

4.4 RAG系统优化实践：索引构建

4.4.1 基础文本分块策略

1、固定大小分块

2、基于句子或段落分块

3、语义分块：引入Embedding技术计算相邻文本单元间的语义相似度，在相似度得分显著下降的位置进行切分，从而识别出文本中的语义边界。

4.4.2 高级分块优化策略

1、滑动窗口（Sliding Window）

2、小块检索，大块生成（Small-to-Big）

3、元数据标注与过滤

4.4.3 处理复杂文档的索引策略

文档除了纯文本，还包括表格、图片、代码、脚注等复杂结构。

AI应用开发框架

Wed, 07 Jan 2026 00:00:00 +0000

3.1 智能体的定义与主流开发范式

3.1.1 什么是智能体

智能体（Agent）可以理解为一个具备自主理解、规划、记忆和工具使用能力的数字化实体。

我们在前面了解到LLM、MCP，它们和Agent是啥关系呢？LLM是“大脑”，Agent是“身体”，Agent通过MCP协议访问外部能力（Tools / Resources）。

【纯LLM交互】
用户：帮我分析main.py文件
LLM：我无法直接访问文件，请您将文件内容粘贴给我


【Agent交互】
用户：帮我分析main.py文件
Agent：我来读取并分析这个文件
      → 调用文件读取工具
      → 分析代码结构
      → 提供详细分析报告

智能体让AI从一个只会内容生成的语言模型，进化成一个具备自主规划能力的行动者。

3.1.2 智能体的主流开发范式

简单LLM应用：直接调用模型API实现内容生成
单智能体：增加RAG、Tool、Memory等，让模型具备与特定环境交互的能力
工作流：将应用拆分，形成多个独立子智能体，再按照预定义的流程编排起来
多智能体系统：相比于工作流，多智能体系统采用的是模型驱动的、对话式的流程编排，各个子智能体具备更多的自主决策权

3.1.3 单智能体

典型的单智能体架构如下：

单智能体非常依赖底层模型能力。

3.1.4 工作流

1、Chain - 链式工作流

每一步由一个独立的LLM调用完成，并将上一阶段的输出作为下一阶段的输入。

2、Routing - 路由工作流

对输入进行分类，将它们分派到专门设计的下游任务或处理路径。

3.1.5 多智能体系统

由多个具备一定自治能力的Agent组成，每个Agent有自己的角色、能力或工具使用范围。它们之间可以通过消息或上下文进行交互，协同完成复杂目标。

3.2 开发一个简单的智能体

3.2.1 智能体框架选型

Python：LangChain、LlamaIndex、AutoGen、CrewAI，开源的Google ADK、Strands等，阿里云开源的AgentScope等

Java：Spring AI Alibaba等

这本白皮书是阿里出的，后面就用Spring AI Alibaba为例进行介绍。

3.2.2 Spring AI Alibaba中的Agent定义

React Agent，采用ReAct模式，将推理（Reasoning）和行动（Action）交错进行，形成一个动态的“思考-行动-观察”循环。

思考（Thought）：LLM分析当前的任务目标、已有的信息和可用的工具，然后生成一个关于下一步应该做什么的推理过程或计划。这个思路过程通常会以自然语言文本展示，解释了它的决策逻辑。

行动（Action）：智能体决定调用的外部工具（如搜索引擎、数据库查询API或自定义函数）。它会生成结构化的指令，明确指出要调用的工具名称和所需的参数。

观察（Observation）：应用程序执行工具调用，并将返回的结果（如搜索结果、API响应或函数返回值）作为观察信息反馈给智能体。

Allure测试报告完整学习笔记

Wed, 07 Jan 2026 00:00:00 +0000

简介

假如你想让测试报告变得漂亮一点，那你一定会在搜索引擎中找到Allure测试报告的。Allure官方给出了个在线网站，访问以下链接就能一睹为快：

https://demo.qameta.io/allure/

可以在左下角切换为中文报告：

如此好看的测试报告，哪个老板不喜欢呢？

安装Allure

1.在GitHub releases：

https://github.com/allure-framework/allure2/releases

或者Maven Central：

https://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/

下载安装包并解压。

2.找到bin目录，Windows使用allure.bat，Unix使用allure：

3.为了后续方便使用，可以把bin完整路径添加到系统环境变量PATH中，然后在命令行直接输入allure命令。

官方也给出了通过Linux的ppa、Mac的brew、Windows的scoop的安装方式，不过对于咱们老百姓来说，不如手动下载包来安装实在。

安装后就可以检查是否安装成功了：

$ allure --version
2.17.2

因为Allure是用Java写的，所以如果无法运行，那么要检查下有没有安装Java。

Allure测试报告的结构

Overview

Suites

Graphs

Timeline

Behaviors

Packages

Java TestNG集成Allure Report

集成

在Maven的pom.xml中添加：

<properties>
    <aspectj.version>1.8.10</aspectj.version>
</properties>
<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-testng</artifactId>
        <version>LAST_VERSION</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.20</version>
            <configuration>
                <argLine>
                    -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
                </argLine>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjweaver</artifactId>
                    <version>${aspectj.version}</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

然后执行命令：

Flask项目发布流程

Wed, 07 Jan 2026 00:00:00 +0000

本文继续对Flask官方教程进行学习，我就直接跳过Templates、Static Files、Blog Blueprint三小节了，因为基本不会在实际项目中用到这些技术，有时间多学习下前端才是。这篇文章把Make the Project Installable、Test Coverage、Deploy to Production这三小节汇总来学习。我觉得这是官方给出的一个Flask项目发布流程，

JavaWeb开发基础ServletSession

Wed, 07 Jan 2026 00:00:00 +0000

Session是什么

在Web应用程序中，Session（会话）是用于在多个请求之间保持用户状态的一种机制。由于HTTP协议是无状态的，每个请求都是独立的，服务器无法直接知道两个请求是否来自同一个用户。Session通过在服务器端存储用户状态信息，并在客户端使用一个唯一的Session ID来标识用户，从而实现状态保持。

Session工作原理如下：

创建Session：当用户第一次访问Web应用程序时，服务器创建一个新的Session，并生成一个唯一的Session ID
发送Session ID：服务器将Session ID发送给客户端，通常通过HTTP响应头中的Set-Cookie字段
存储Session ID：客户端浏览器将Session ID存储在Cookie中，并在后续请求中将其发送回服务器
识别Session：服务器通过接收到的Session ID识别用户的会话，并从服务器端存储中获取相应的Session数据

四种主要技术

Cookies
Hidden Form Field
URL Rewriting
HttpSession

1. Cookies（Cookie）

Cookie是存储在客户端浏览器中的小数据片段。它们会随着每个HTTP请求一起发送到服务器，可以用来存储会话标识符。

工作原理

当用户第一次访问网站时，服务器生成一个唯一的会话ID，并将其作为Cookie发送到客户端浏览器
浏览器存储这个Cookie，并在后续请求中将其发送回服务器
服务器使用Cookie中的会话ID来检索用户的会话数据

优点

对用户透明
由浏览器自动管理
可以存储少量数据

缺点

用户可以在浏览器中禁用Cookie
存储容量有限（通常每个Cookie大约4KB）
如果处理不当，可能存在安全问题（例如Cookie盗窃）

示例

import javax.servlet.http.Cookie;


// 在Servlet中设置Cookie
Cookie sessionCookie = new Cookie("JSESSIONID", session.getId());
sessionCookie.setMaxAge(30 * 60); // 30分钟
response.addCookie(sessionCookie);

// 在Servlet中检索Cookie
Cookie[] cookies = request.getCookies();  // 从请求获取Cookie
if (cookies != null) {
    for (Cookie cookie : cookies) {
        if ("JSESSIONID".equals(cookie.getName())) {
            String sessionId = cookie.getValue();
            // 使用会话ID检索会话数据
        }
    }
}

Cookie有两种类型：

Java官方笔记4类和对象

Wed, 07 Jan 2026 00:00:00 +0000

创建类

定义类Bicycle：

public class Bicycle {

    // the Bicycle class has
    // three fields
    public int cadence;
    public int gear;
    public int speed;

    // the Bicycle class has
    // one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // the Bicycle class has
    // four methods
    public void setCadence(int newValue) {
        cadence = newValue;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }
}

创建子类MountainBike继承类Bicycle：

JMeter关联陌生又熟悉

Wed, 07 Jan 2026 00:00:00 +0000

JMeter关联是什么

JMeter关联，这几个字看着可能会有点陌生，实际上却是工作中经常会做的一件事情，尤其是接口自动化，它指的是把一个接口的响应作为另一个接口的参数，从而把接口关联起来。

JMeter关联是通过后置处理器来实现的，本文将介绍两个主流提取器：正则表达式提取器和JSON JMESPath提取器。

正则表达式提取器

Name

最好有业务含义的名称。

Comments

可以为空的注释。

Apply to

匹配范围。

Main sample and sub-samples

匹配当前父取样器及其子取样器。

Main sample only

仅匹配当前父取样器。

Sub-samples only

仅匹配子取样器。

JMeter Variable Name to use

匹配JMeter变量。

Field to check

匹配响应的字段，共七个选项。

Body：主体，最常用。

Body(unescaped) ：替换了所有的html转义符的响应主体内容，注意html转义符处理时不考虑上下文，因此可能有不正确的转换，不太建议使用。

Body as a Document：从不同类型的文件中提取文本，注意这个选项比较影响性能。

Response Headers：响应Headers。

Request Headers：请求Headers。

URL：请求URL。

Response Code：响应代码，比如200、404返回码。

Response Message：响应信息，比如“成功”、“OK”字样。

Name of created variable

创建的变量名，比如变量名为token，通过${token}进行访问。

Regular Expression

正则表达式。

Template( $i$ where i is capturing group number, starts at 1)

用$$引用起来，如果在正则表达式中有多个正则表达式（多个括号括起来的），则可以是 $1$ 、 $2$ 等等， $1$ 指第一个模板， $2$ 指第二个模板，依次类推， $0$ 指全文匹配，$1$$2$指同时取第一个和第二个模板。

JUnit5依赖注入与测试接口

Wed, 07 Jan 2026 00:00:00 +0000

依赖注入

以前的JUnit的类构造方法和测试方法都是不能有参数的，JUnit Jupiter有一个颠覆性的改进，就是允许它们有入参，这样就能做依赖注入了。

ParameterResolver是一个接口类，类构造方法和测试方法在运行时，必须由被注册的ParameterResolver进行解析。JUnit Jupiter有三个自动注册的内置解析器：

TestInfoParameterResolver 参数类型为TestInfo
RepetitionInfoParameterResolver 参数类型为RepetitionInfo
TestReporterParameterResolver 参数类型为TestReporter

TestInfo

TestInfo包含the display name, the test class, the test method, and associated tags等信息。

示例：

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

@DisplayName("TestInfo Demo")
class TestInfoDemo {

    TestInfoDemo(TestInfo testInfo) {
        assertEquals("TestInfo Demo", testInfo.getDisplayName());
    }

    @BeforeEach
    void init(TestInfo testInfo) {
        String displayName = testInfo.getDisplayName();
        assertTrue(displayName.equals("TEST 1") || displayName.equals("test2()"));
    }

    @Test
    @DisplayName("TEST 1")
    @Tag("my-tag")
    void test1(TestInfo testInfo) {
        assertEquals("TEST 1", testInfo.getDisplayName());
        assertTrue(testInfo.getTags().contains("my-tag"));
    }

    @Test
    void test2() {
    }

}

RepetitionInfo

pytest用例查找原理

Wed, 07 Jan 2026 00:00:00 +0000

当执行pytest命令时，pytest会从project中查找test来执行。本文先从几个路径相关的概念讲起，这样便于理解pytest在遍历路径时的走向。

SpringBoot官方笔记4Web

Wed, 07 Jan 2026 00:00:00 +0000

Most web applications use the spring-boot-starter-web module to get up and running quickly. You can also choose to build reactive web applications by using the spring-boot-starter-webflux module.

teprunner测试平台测试计划批量运行用例

Wed, 07 Jan 2026 00:00:00 +0000

本文开发内容

上一篇文章已经把pytest引入到测试平台中，通过多线程和多进程的方式，运行测试用例。有了这个基础，做批量运行用例的功能就很简单了，只需要前端传入一个CaseList即可。本文的后端代码是增删改查和复用run_case相关代码做个run_plan。前端代码将学习如何通过LocalStorage在非父子组件之间传递数据。具体开发内容如下：

测试计划增删改查
测试计划动态添加移除测试用例
运行测试计划，批量运行用例
计划运行结果、用例运行结果

编写后端代码

编辑teprunner/urls.py文件，添加测试计划的路由：

编辑teprunner/models.py文件，添加3张表的model：

Plan存放测试计划，PlanCase存放计划和用例关联关系，PlanResult和CaseResult类似，这里之所以把单独出来一张结果表，是为了和用例结果CaseResult相互独立，防止计划结果覆盖用例结果，毕竟CaseResult一般是手工跑出来的，PlanResult一般是定时任务跑出来的，功能数据解耦后处理起来也更方便。

编辑teprunner/serializers.py文件，添加序列化器：

为了前端展示需要，这里额外关联了一些字段进行展示。尤其是：

caseNum用例总条数，passedNum成功条数，failedNum失败条数，errorNum错误条数。成功定义为：只有passed，没有failed和error的用例。失败定义为：只有failed，没有error的用例。错误定义为：只要有error的用例。

本文还展示了，如果序列化器的某个字段只在存库时使用，返回响应时不展示，该怎么处理：

重写to_representation方法，把不需要返回的字段pop移出去。这里output在计划运行结果不需要，在用例运行结果才需要，为了减少传输数据，就在计划运行结果的接口响应中移出去了。

最后来写View，新增teprunner/views/plan.py文件：

重写list方法，添加查询条件。重写destroy方法，判断必须先删除关联测试用例，才能删除测试计划。

PlanCaseView类似：

添加add方法：

在添加用例时写入plan_case表。添加remove方法：

在移除用例时从plan_case表删除数据。继续：

result视图用来返回计划运行结果，根据searchType来分别查询用例总条数、成功条数、失败条数、错误条数。

继续：

plan.case_result和case.case_result类似，返回测试计划的每条用例的运行结果。

在测试计划添加用例的时候，有个用例列表，需要增加2个过滤条件，编辑teprunner/views/case.py文件：

第一个过滤条件是排除当前计划已经添加过的用例：exclude_plan_id由前端传入，根据PlanCase关联关系找到已添加的用例进行过滤；第二个查询条件是关键字：用例ID或用例描述，跟PlanCaseView.list()里面一样。

最后，编辑teprunner/views/run.py文件，增加批量运行用例的功能：

添加delete_plan_result方法，在运行用例前，先把已有结果删掉，注意这里的model是PlanResult。继续：

修改pytest_subprocess函数，添加plan_id字段。继续：

修改save_case_result函数，判断没有plan_id就存case_result表，有plan_id就存plan_result表。

复制run_case的代码为run_plan：

修改case相关代码为plan。值得注意的是中间那段代码，根据plan_id从PlanCase中找到关联用例，生成了case_list，这样就复用run_case的多线程和多进程代码，批量运行测试用例了。

编写前端代码

编辑src/router/index.js文件，添加测试计划相关路由：

		{
            path: "plan",
            name: "plan",
            meta: {
              title: "测试计划",
            },
            component: () => import("@/views/teprunner/plan/PlanManagement.vue"),
            children: [
              {
                path: "addPlan",
                name: "addPlan",
                meta: {
                  title: "添加计划",
                },
                component: () => import("@/views/teprunner/plan/PlanEditor"),
              },
              {
                path: "editPlan",
                name: "editPlan",
                meta: {
                  title: "编辑计划",
                },
                component: () => import("@/views/teprunner/plan/PlanEditor"),
              },
              {
                path: "caseList",
                name: "caseList",
                meta: {
                  title: "用例列表",
                },
                component: () => import("@/views/teprunner/plan/CaseList"),
              },
              {
                path: "planResult",
                name: "planResult",
                meta: {
                  title: "计划运行结果",
                },
                component: () => import("@/views/teprunner/plan/PlanResult"),
                children: [
                  {
                    path: "caseResult",
                    name: "caseResult",
                    meta: {
                      title: "用例运行结果",
                    },
                    component: () => import("@/views/teprunner/plan/CaseResult"),
                  },
                ],
              },
            ],
          },

跟之前做增删改查不一样的地方是：**在父组件中，不会import子组件，而是通过LocalStorage进行组件之间传值。**因此这里增加了添加计划、编辑计划等路由。

测试的道与术

Wed, 07 Jan 2026 00:00:00 +0000

“道”说起来有点抽象，它相当于我们常说的“软技能”，包括价值观、认知能力、学习能力、创新能力、沟通协作等。不同层次的测试人员，道的差异也很大。初级测试人员，可能只知道测试是为了找出问题，能把需求上线即可。高级测试人员，也许会更加注重质量保障，从全局思考，既要保证线上不出问题，又要提高测试效率。他们的行为准则也不一样。有些人不注重资产沉淀，虽然能完成任务，但给人散乱的印象。有些人敬畏流程，严格按照标

从函数到包的Python代码层次

Wed, 07 Jan 2026 00:00:00 +0000

代码层次

Python是一门脚本语言，新建一个.py文件，写点代码，就可以跑起来了，无论放哪都可以。比如where.py文件：

print("Where am I?")

那么问题来了，这是写在哪里的呢？为了一目了然，我们用“导游图”的视角来看看代码层次：

红色箭头指出了，是写在模块中的，原来一个.py文件就是一个模块。模块中可以写函数和类，模块可以放在包中。

函数

Python中最出名的函数一定是print()了，毕竟全世界都在用它say Hello World。Python函数其实和数学中的函数很像，比如y = f(x)。有函数名字、输入和输出。Python的函数结构如下：

函数通过def关键字来定义：

def 函数名（参数列表）:
    函数体

参数列表有就有，无则无，多个参数用逗号分隔。例如：

def hello() :
    print("Hello World!")

hello()  # 调用函数

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

调用函数，不需要再加def，直接函数名（参数列表）即可。参数既可以是变量，也可以是其他函数，只要能一一对应。return关键字用来返回值。return不是必需的，如果没有，那么函数会把内部代码全部都执行完再退出，如果有，函数会在return语句立刻退出，同时返回return语句的值，例如：

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
   print("这里不会执行！")
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

类

为什么还要写类，函数它不香么？这个问题有点大，我只能简单解释一下，那就是因为，类是包括了函数的，如果有一天你发现函数不够用了，那么可以用类试试，哈哈哈。

揭开DRF序列化技术的神秘面纱

Wed, 07 Jan 2026 00:00:00 +0000

在RESTful API中，接口返回的是JSON，JSON的内容对应的是数据库中的数据，DRF是通过序列化（Serialization）的技术，把数据模型转换为JSON的，反之，叫做反序列化（deserialization）。本文就来揭开2揭开DRF序列化技术的神秘面纱技术的神秘面纱。

原创pytest辅助工具tep0.9.1版本恢复项目初始化文件

Wed, 07 Jan 2026 00:00:00 +0000

最近几个月时间有些小伙伴问到为什么tep项目初始化文件没有了？

AI原生应用的关键要素

Tue, 06 Jan 2026 00:00:00 +0000

2.1 模型

大模型扮演着大脑的角色，负责核心的理解、推理与生成任务。

2.1.1 模型分类

通用大模型：GPT、Claude、Qwen、DeepSeek、Gemini等通用大模型。

垂直领域模型：情感分析、语言翻译、意图分类等垂直领域模型。

通用大模型适合处理复杂、开放的任务，垂直领域模型适合处理简单、高频的任务。

2.1.2 模型能力和微调

模型的知识是固化的，需要不断地“喂”它，把这些信息结构化地描述清楚并且提供给它，它会在每次的交互中动态地理解你提供的内容，并结合自身的通用知识来完成内容的生成。

企业专属模型的训练和微调的成本是巨大的，它不仅包括高昂的计算资源费用，还需要海量的高质量标注数据、专业的算法团队以及漫长的开发周期。对于绝大多企业来说，投入与产出不成正比，很难持续。

2.1.3 如何选择模型

基于企业的实际业务场景，权衡任务复杂度、性能要求、开发成本和响应延迟等多个因素来综合选择和组合最合适的模型。

一个务实的策略是从顶配开始，逐步优化：先用能力最强的模型搭建原型以验证业务逻辑，再逐步将流程中的非核心、简单任务替换为更经济、更快速的小模型，最终找到成本与性能的最佳平衡点。

2.2 框架

Spring或Dubbo开发一个微服务应用，代码确定，容易形成标准化的框架。而开发一个AI Agent应用，LLM存在高度不确定性，设计模式的落地方式差异很大。

2.2.1 Agent设计模式

1、Chain of Thought（思维链）

让模型在回答前，把推理过程一步步写出来。

2、Self-Ask（自问自答）

让模型在回答时学会反问自己，把大问题拆成多个小问题，然后逐个回答。

3、ReAct（推理+行动）

在推理和外部行动（比如调用搜索引擎或API）之间交替进行。

4、Plan-and-Execute（计划与执行）

把任务拆成两个阶段，先生成计划，再逐步执行。

5、Tree of Thoughts（ToT，树状思维）

不是单线思维，而是生成多条思路分支，像树一样展开，再通过评估机制选出最佳分支。

6、Reflexion / Iterative Refinement（反思与迭代优化）

Agent自我纠错，犯错后会总结失败原因，再带着反思尝试下一次。

7、Role-playing Agents（角色扮演式智能体）

把任务拆分给不同角色的Agent，通过对话协作完成任务。

这些模式不是互斥的，可以混搭使用。

其中ReAct已经被LangChain、LlamaIndex、Dify、Spring AI Alibaba等开发框架内置为基础框架。

2.2.2 Agent开发框架

1、从低代码到高代码

低代码平台是对于高代码的一层封装，其抽象层次很难满足所有场景，无法在性能、扩展性和复杂业务逻辑方面满足大规模生产的要求。

高代码是当下AI原生应用生产落地的主流形态，ADK、LangGraph、AutoGen、AgentScope、Spring AI Alibaba等框架，为开发者提供了面向Agent的编程接口。

2、高代码的演进

高代码模式本身经历了从ChatClient→Workflow→Agentic的演进过程。

ChatClient，一次单一的LLM调用。Workflow，将传统工作流转化为LLM节点编排。Agentic，提供面向Agent的API，并内置多种通用的协作模式（Pattern）。

3、零代码的愿景

尝试让用户完全通过自然语言即可驱动开发。目前处于探索与验证阶段，难以承担大规模生产任务。

2.3 提示词

在AI原生应用中，不再编写复杂的代码，而是使用更接近人类语言的方式与AI沟通，这就是Prompt（提示词）。提示词的质量很大程度上影响了AI应用的输出效果。

2.3.1 提示词是什么

提示词可以是一个具体的问题、一段描述、一组关键词，或是相关的上下文，不仅限于自然语言文本，还可以包含代码片段、数据格式说明，甚至是图像与文字相结合的多模态输入。

2.3.2 提示词质量=AI输出质量

大模型的输出质量，既要看大模型本身，也要看提示词是否清晰、完整、具体。比如，“写点关于人工智能的东西”，生成的内容是泛泛而谈。“以科技专栏作家的身份，撰写一篇800字左右的文章，探讨人工智能在医疗影像诊断中的最新应用、优势与挑战，并列举实例”，能生成一篇逻辑严谨、信息详实、专业度高的文章。

Flask的Blueprints和Views

Tue, 06 Jan 2026 00:00:00 +0000

Flask的view函数是用来对请求作出响应的。单个URL能匹配到单个View，那么多个类似的URL，比如：

JavaWeb开发基础ServletConfig与ServletContext

Tue, 06 Jan 2026 00:00:00 +0000

ServletConfig

package javax.servlet;

import java.util.Enumeration;

public interface ServletConfig {
    String getServletName();

    ServletContext getServletContext();

    String getInitParameter(String var1);

    Enumeration<String> getInitParameterNames();
}

ServletConfig用于Servlet初始化时从web.xml获取配置信息。主要有以下方法：

public String getInitParameter(String name): Returns the parameter value for the specified parameter name.
public Enumeration getInitParameterNames(): Returns an enumeration of all the initialization parameter names.
public String getServletName(): Returns the name of the servlet.
public ServletContext getServletContext(): Returns an object of ServletContext.

示例，web.xml

Java官方笔记3Java语言基础

Tue, 06 Jan 2026 00:00:00 +0000

变量

Instance Variables (Non-Static Fields) 实例变量（非静态变量）

一个类可以创造多个实例，实例中的变量叫做实例变量，相互独立。

Class Variables (Static Fields) 类变量（静态变量）

对比来看，类变量就是类的变量，一个类只能有一份，不能复制，使用static关键字来定义类变量。

代码：

public class MyVar {
    static int classVar = 1;  // 类变量（静态变量）
    int instanceVar = 2;  // 实例变量
}

对比Python来看就很清楚：

class MyVar:
class_var = 1

def __int__(self):
  instance_var = 2

Local Variables 局部变量

局部变量是由代码位置决定的，前面的实例变量和类变量，是放到Field位置，而局部变量是放到Method里面。也就是说，局部变量是放在方法的花括号里面的变量，并且只能在方法内部访问，不能被其他地方访问，这就是所谓的局部。

public class MyVar {
    static int classVar = 1;  // 类变量（静态变量）
    int instanceVar = 2;  // 实例变量

    void method() {
        int localVar = 3;  // 局部变量
    }
}

Parameters 参数

JMeter100个线程竟然只模拟出1个并发

Tue, 06 Jan 2026 00:00:00 +0000

线程组编辑区如下：

JUnit5参数化测试的几种方式

Tue, 06 Jan 2026 00:00:00 +0000

参数化测试一直是津津乐道的话题，我们都知道JMeter有四种参数化方式：用户自定义变量、用户参数、CSV文件、函数助手，那么JUnit5有哪些参数化测试的方式呢？

pytest断言技巧

Tue, 06 Jan 2026 00:00:00 +0000

pytest的断言把Python语言简洁的优点发挥的淋漓尽致，因为它用的就是Python的标准断言assert。

SpringBoot官方笔记3核心

Tue, 06 Jan 2026 00:00:00 +0000

SpringApplication

By default, INFO logging messages are shown, including some relevant startup details, such as the user that launched the application.

Lazy Initialization

When lazy initialization is enabled, beans are created as they are needed rather than during application startup.

spring.main.lazy-initialization=true

@Lazy(false) annotation：disable lazy initialization for certain beans

Customizing the Banner

adding a banner.txt file to your classpath or by setting the spring.banner.location property to the location of such a file. If the file has an encoding other than UTF-8, you can set spring.banner.charset.

teprunner测试平台Django引入pytest完整源码

Tue, 06 Jan 2026 00:00:00 +0000

本文开发内容

pytest登场！本文将在Django中引入pytest，原理是先执行tep startproject命令创建pytest项目文件，然后从数据库中拉取代码写入文件，最后调用pytest命令运行用例。为了提高运行效率，用例运行是并行的，采用了多线程和多进程，两个都有，这在最后有个单独小结进行比较完整的说明。因为用例运行是异步的，所以前端并不知道什么时候执行完才能拿到运行结果，可以发多个HTTP请求轮询，但这种方式并不优雅，本文将采用WebSocket来实现用例结果查询。具体内容为：

cases/<int:pk>/run运行用例接口
ws/teprunner/cases/<int:case_id>/result/用例结果查询接口
projects/<int:pk>/export下载项目环境接口
前端添加WebSocket请求

知识点涉及有点多：tep、pytest、同步、异步、多线程、多进程、回调函数、WebSocket、长连接、全双工、ASGI、WSGI、打ZIP包、文件字节流传输。

编写后端代码

编辑requirements.txt，添加tep和channels：

tep==0.6.9
channels==3.0.3

tep是用来创建pytest项目的，channels是用来实现WebSocket的。

编辑teprunner/urls.py文件，添加HTTP路由：

首先实现run接口，新建teprunner/views/run.py文件：

这是运行用例的主体流程：

第一步从请求中获取用例id、运行环境、运行人，这里演示了获取user数据的两种方式：接口传参和从token中解析。然后根据project_id，run_env，user_id定义了pytest项目的路径。
第二步使用tep startproject创建项目文件，清空fixtures和tests目录，目的有两个：一是清掉tep默认fixtures和示例cases，防止对平台产生干扰；二是保证每次运行目录都是干净的，就不用单独去处理前端手动删掉fixture/case后，文件残留的问题。然后从数据库中拉取环境变量、fixtures等数据更新文件。
起多个线程，分别执行用例，执行前先拉取用例代码写入文件，这里是单条用例运行，之所以要用for循环，是因为用例迟早是要批量执行，在设计时就考虑到，避免后面走弯路。然后删掉数据库运行结果，通过subprocess起子进程调用pytest命令，最后在线程的回调函数中根据pytest_result保存用例结果到数据库中。

图中很多函数和类是我封装的，一个一个拆解来看：

这里定义了Django中存放pytest项目的目录文件，project_temp_name是按照project_id、env_name、user_id来划分的，目的是让运行目录尽量隔离开来，不要相互影响，借鉴了Docker容器的思想，可以把这个目录视为用例运行容器。继续：

tep startproject命令创建pytest项目，pytest文件有特定组织方式，比如conftest.py文件等，tep提供了脚手架一条命令创建项目结构。继续：

fixture_env_vars.py里面存放了tep的环境变量，Django这里每次都从数据库的env_var表中获取数据，动态更新到文件里面。setdefault是个骚操作，这行代码等价于：

if env_name in mapping.keys():
    mapping[env_name][name] = value
else:
    mapping[env_name] = {name: value}

继续：

分别从数据库中获取代码写入fixture文件和case文件，把前端传参的运行环境写入conf文件。继续：

清空fixtures目录，清空tests目录。继续：

pull_tep_files是写环境变量，写fixture文件，写conf文件三步的集合，复用代码。pull_case_files通过yield定义为了生成器，它和list的区别是不会一次把所有数据产生到内存中，而是每次用的时候产生一次，节约内存开销。delete_case_result用于运行用例前删除case_result表里面已经存在的这条用例的数据。case_result按照用例id和运行人存的多条，每个运行人都有一条属于自己的运行数据，避免数据相互干扰，返给前端的是运行时间最新的那一条！

继续：

subprocess.getoutput()可以执行shell命令并返回执行结果，这里就拿到了pytest控制台日志，这个函数是在线程池中异步执行的，主线程不能一直等待它执行，所以需要有个回调函数，等它自己执行完了去调用这个回调函数。save_case_result就是个回调函数，它的入参pytest_result等于pytest_subprocess函数返回的元组，拆包后就能拿到outout、cmd、case_id、run_env、run_user_nickname，从中解析出result和elapsed后，就可以存库了，无则新增，有则更新。

run接口做好了，再接口做下载环境接口，编辑teprunner/views/project.py：

打包的代码是从网上找的，把source_dir打包成zip_filename文件。继续：

file_iterator函数也是网上找的，把二进制文件读取为字节流，传输给前端，需要使用StreamingHttpResponse对象并添加Content-Type和Content-Disposition。红框的代码跟run接口类似，区别在于目录换成了export_temp_dir()，且不包含测试用例，生成zip文件后会把导出临时目录删掉，防止冲突。

两个HTTP接口做完了，开始实现WebSocket。WSGI一种网关接口，是Python为了解决Web服务器端与客户端之间的通信问题而产生的，不支持WebSocket；ASGI是WSGI的扩展，意思是异步网关接口，支持WebSocket。编辑teprunnerbackend/urls.py文件：

添加了WebSocket路由。编辑teprunnerbackend/asgi.py文件：

添加websocket的URLRouter，http保持默认。编辑teprunnerbackend/settings.py文件：

INSTALLED_APPS中添加channels，继续：

添加ASGI应用配置和CHANNEL配置。CHANNEL_LAYERS是一种通信系统，允许多个Consumer实例之间互相通信，以及与外部Django程序实现互通。学习版这里使用的InMemory。

生产中不建议使用InMemory，可能会有性能问题，而是应该使用Redis：

CHANNEL_LAYERS = {
    "default": {
        "BACKEND": "channels_redis.core.RedisChannelLayer",
        "CONFIG": {
            "hosts": [("127.0.0.1", 6379)],
        },
    },
}

最后，编辑teprunner/views/case.py文件：

tep环境变量、fixtures、用例三者之间的关系

Tue, 06 Jan 2026 00:00:00 +0000

tep是一款测试工具，在pytest测试框架基础上集成了第三方包，提供项目脚手架，帮助以写Python代码方式，快速实现自动化项目落地。

测试工程师的成长，体现在2个地方

Tue, 06 Jan 2026 00:00:00 +0000

小伙伴B，测试过程中时刻充满了学习呀，工作中对自己需求的部分搞清楚，就涉及到很多知识点的学习呀，比如去了解开发咋实现的，然后你如何去测试。

快用DjangoRESTframework写写API吧

Tue, 06 Jan 2026 00:00:00 +0000

Django默认是前后端绑定的，提供了Template和Form，现在流行前后端分离项目，Python大佬坐不住了，于是便有了Django REST framework：https://github.com/tomchristie

老板给我安排了个测试环境治理的活

Tue, 06 Jan 2026 00:00:00 +0000

测试环境困局

测试环境治理专项是在我入职2个月接手的活，用“烂摊子”来形容一点也不为过。年久失修，需求基本没有在测试环境使用，想用也有很多问题。人员缺乏信心，之前负责测试环境的同学抱怨极多，外部推不动，内部又没有技术能力支撑，负能量已经蔓延到整个团队。当然，我也是其中一员，这事确实难搞。在技术部测试环境平台化的大方向下，需要每个组出一个接口人来牵头，考虑到我以前写过测试平台，乱七八糟的事都整过，老板就指定了我。

What，测试环境是什么？

测试环境是一套能够支撑业务系统运行的环境，是相对于预发环境和生产环境来说完全隔离的环境。测试环境=应用+数据+配置+依赖服务。应用包含系统应用和中间件等，数据就是测试物料，配置针对测试环境应该有单独的一套，依赖服务要跟外部联调好以后整个环境才是可用的。测试环境治理就是通过内部搭建和外部联调，保障业务系统能够在完全隔离的环境中运行。

Why，为什么要做测试环境？

测试环境是为了隔离。如果只有一套生产环境，那么开发、测试、上线等活动，可能会对线上系统稳定性造成影响，可能会污染线上用户数据，可能引起客户投诉甚至资产损失，所以需要有一套完全隔离的测试环境。

Who，谁来负责测试环境？

每个测试人员都需要具备测试环境搭建能力。当然可以推动运维或研发来搭建测试环境，但是测试人员需要具备搭建能力，能够自主编译，构建，部署，遇到问题能够根据日志做初步定位，将问题抛出推动研发或外部依赖方解决。

When，什么时间做测试环境？

测试环境治理需要前置到研发自测阶段。在实践过程中，测试同学暴露出来最多的问题是，没有时间投入到测试环境搭建中，一方面是缺乏动力，不肯迈出艰难的第一步，另一方面也是跟项目节奏有关，研发就算用测试环境自测，也会在预发联调好以后再提测，到测试手上时，已经有可用的预发环境了，就不会再去用测试环境。“项目时间紧，测试环境不好用，直接用预发测吧”，顺理成章的就成为了很合理的借口。所以需要从提测，前置到，研发自测，做测试环境治理：

Where，从哪里入手测试环境？

测试环境治理需要从上往下才能推动，先有文化，才有行动。假如只有某个部门想做测试环境治理，外部依赖基本上是推不动的，一个人呐喊得再愤怒其他人也可能无动于衷。所以得先把测试环境治理这件事，跟老板沟通，从高层入手，把它定义为一项政治任务，从上往下层层递进。

How，怎么做测试环境？

工欲善其事，必先利其器，公司的基建比较完善，给测试人员搭建测试环境降低了很大难度。设想一下，假如只能折腾Docker和K8S，那可能需要专门的运维才能搞得定环境，对测试来说门槛就会比较高了，除了少数技术能力强的，其他同学基本没有什么可操作性。测试环境平台化就是武器。公司有个部署平台叫做JDOS，日常运维都是在这上面操作，没有运维人员，环境全靠开发人员和测试人员自己整。JDOS已经是页面化操作了，但它对测试环境没有特殊的应用场景，是个大而全的平台，所以二级部门开了一个测试环境平台，Env，“一款全流程自动化测试环境搭建的利器”。

Env的核心思想是1+N。1代表稳定分组（分组≈Pod），搭建稳定分组需要经过创建系统，创建应用，创建集群，申请机器，代码编译构建，部署镜像，修改配置等操作，需要选取master稳定版本，这样才能对外提供稳定服务。N是克隆1产生的多个分组，相互隔离，能让开发同学复用测试搭建好的环境，完成冒烟自测等过程；也能在多业务联调测试时，通过平台快速搭建一套全链路测试环境。

Env提供了环境监控的功能。对于搭建好的稳定环境，它可以每天监控机器是否可用，服务是否正常，镜像是否老旧，等等等，让你及时维护环境，保障稳定性。

Env提供了一键搭建的功能。新克隆的环境，只要点一下“一键搭建”，就会基于稳定分组，自动化搭建一套新环境，大大节约了时间成本。

Env提供了拓扑画图的功能。将多个应用拖到一张拓扑图里面，根据依赖关系连线，能够直观了解到应用之间的依赖关系。基于拓扑来克隆新环境，也能批量克隆多个应用。假如多项目需求并行迭代，想要多套联调的测试环境，就可以克隆多套新环境。

Env还解决了一个资源浪费的问题，以前搭建测试环境比较随意，申请资源也很容易，其实会导致很多机器用过后，一直空置在那里。Env收拢了申请资源入口，基于Env来创建稳定分组，只能有1个，想要更多必须走审批。而对于克隆的新环境，也会有期限，14天以后会自动释放，想要延期也必须走审批。

我所负责的第一件事，就是用Env来搭建一张拓扑图，把组内所有应用都从JDOS迁移到Env上，维持稳定环境对外提供支撑对接，克隆环境对内支持多项目并行。

搭建测试环境只是起步，测试环境治理的目标是需求能够使用测试环境。对于外部依赖少的业务模块来说，这相对容易。对于外部依赖很多的业务模块来说，这就很难了。那么该如何推动这件事呢？

第1个策略是共建，让研发和测试一起来搭建和维护测试环境。

第2个策略是做功能验证，梳理出链路用例，跟踪验证结果，识别卡点问题：

对于卡点问题的处理，把干系人单独拉群对，响应超过3天就往上抛，一定会遇到推不动的问题，那么办法只能找自己的上游负责人，层层向上反馈，让上面的负责人去找对方负责人，然后推动对方的下游同学来协助解决。卡点问题记录后需要做问题分类，做好统计，这既是工作量的体现，也是每周进度汇报的依据：

第3个策略就是制定kpi，强制大家使用测试环境完成绩效。

How much，测试环境做到什么程度？

测试环境的kpi能反应出测试环境应该做到什么程度，可以使用需求使用测试环境占比和测试环境bug占比。需求使用测试环境占比的计算公式是打标了测试环境的提测卡片数/总的提测卡片数，测试在点击开始测试时，选择是否使用测试环境进行打标。测试环境bug占比的计算公式是测试环境bug/(测试环境bug+预发环境bug+生产环境bug)，在提交缺陷时选择环境类型进行打标。测试环境bug占比的意义更大，因为使用测试环境与否，最终的体现还是落在缺陷上面的，比较容易量化，需求使用测试环境占比不是很确定，需求多少功能在测试环境使用了，相对来说不是很好度量，但也可以作为辅助指标进行观察。

测试环境破局

测试环境关联了很多东西，比如物料、自动化、精准、流水线等，都可以围绕测试环境来做文章。测试环境既是团队重点，也是是我个人的大案例，目前已经解决了部分困难，要想做出一鸣惊人的成绩，还需要站在更高的角度去看待整个事情，这也是一个全新的挑战，需要不断刷新自己，突破。

条件循环语句组成了Python代码的骨架

Tue, 06 Jan 2026 00:00:00 +0000

条件控制

我们都知道流程图是有多个分支的，程序中也是如此，在Python中是用if语句来判断程序该走哪个分支的。它的执行过程如下：

代码执行过程如下

if

if语句的一般形式如下：

if condition_1:
    statement_block_1

如果condition_1为True，执行statement_block_1。

condition_1是条件表达式，由各种运算符和数据类型组成，条件表达式的结果可以是True/False的布尔值，也可以是非布尔值。Python中的0、None、空列表、空字典等都会被认为是False，反之都会被认为是True。

else

else语句在条件为False时执行：

if condition_1:
    statement_block_1
else:
    statement_block_2

如果condition_1为True，执行statement_block_1。
如果condition_1为False，执行statement_block_2。

elif

if…else实现了“如果满足条件，那么xxx，否则xxx”，除此之外，还可以用elif实现多个连续判断，分别执行不同的语句：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

如果condition_1为True，执行statement_block_1。
如果condition_1为False，再判断，如果condition_2为True，执行statement_block_2。
否则，执行statement_block_3。

elif可以写多个。这种写法的执行顺序是从上往下，只要满足了某个if或elif的条件，就会在当前分支执行后跳出去，不再执行后面的判断，如果每个if或elif的条件都是False，最后就会执行else。

if嵌套

假如想满足if或elif的条件后，继续做判断，那么就需要进行if语句嵌套，让statement_block_1等代码块也包含if语句：

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

示例：

1、mindsdb

加星数：26.4k

技术栈：python，SDK (Golang, js, ruby, rust, C#, java, Cli)

GitHub地址：https://github.com/mindsdb/mindsdb

项目介绍：MindsDB是一个开源的机器学习平台，旨在简化AI模型的创建、训练和部署过程。它允许开发者使用熟悉的SQL查询语言来构建和操作机器学习模型，从而降低了AI开发的门槛。

2、Mattermost

加星数：30.3k

技术栈：TypeScript, Golang

GitHub地址：https://github.com/mattermost/mattermost

项目介绍：Mattermost是一个强大的开源协作平台，特别适合软件开发团队。它提供了丰富的功能和高度的可定制性，确保团队在整个软件开发生命周期中能够高效、安全地协作。通过自托管，用户可以完全控制他们的数据和平台的运行环境。

3、Kong

加星数：39k

技术栈：Lua, Perl, Raku, Starlark, Shell, Python

GitHub地址：https://github.com/Kong/kong

项目介绍：Kong API Gateway是一个功能强大且高度可扩展的API网关，适用于各种环境。它以高性能和丰富的功能集（如安全性、负载均衡和监控）而著称。通过插件系统，Kong可以轻松扩展其功能，满足不同用户的需求。此外，Kong还提供了高级的AI功能，支持多种大语言模型，帮助用户实现智能化的API管理和优化。

4、Taipy

加星数：12.5k

技术栈：python, typescript

GitHub地址：https://github.com/avaiga/taipy

项目介绍：Taipy是一个强大的工具，专为数据科学家和机器学习工程师设计，帮助他们构建数据和AI的Web应用程序。通过简化开发和部署流程，Taipy使用户能够专注于数据和AI算法的开发。其仅需Python语言的特点，使得用户无需学习新的编程语言，从而降低了使用门槛。Taipy还提供了强大的UI生成和场景/数据管理功能，进一步简化了项目的开发和管理。

5、appwrite

加星数：44.1k

技术栈：TypeScript, php

GitHub地址：https://github.com/appwrite/appwrite

项目介绍：Appwrite是一个强大的端到端后端服务器，专为Web、移动、原生或后端应用程序设计。通过抽象复杂性和提供一整套现成的API和工具，Appwrite使开发者能够更快地构建安全的应用程序。其Docker微服务架构还使得部署和扩展变得更加方便。

AI原生应用及其架构

Mon, 05 Jan 2026 00:00:00 +0000

1.1 大模型技术发展回顾和产业价值

1.1.1 大模型发展回顾与展望

2022年11月，ChatGPT横空出世，模型即服务（MaaS）模式快速兴起，AI从实验室走向商业场景。2024年，OpenAI推出o1模型和4o模型，大模型技术迎来质的飞跃。2025年，多家大模型厂商支持模型上下文协议（MCP），Google推出A2A架构，AI从单点工具向系统级生产力工具转变。

1.1.2 大模型的五大产业价值

效率新工具、服务新体验、产品新形态、决策新助手、科研新模式。

1.2 AI时代应用架构的演进

1.2.1 IT应用架构的演进脉络

云原生架构是指，Kubernetes等技术通过容器化、集群化管理，实现按量使用、秒级弹性的极致资源调度。

每一次架构升级，都是在满足业务规模更大、需求变化更快、资源成本更低的述求。

1.2.2 云原生应用架构向AI原生应用架构的跃迁

如果说，云原生解决的是如何高效地运行，那么AI原生是在此基础上解决如何智能地运行。

在云原生应用架构中，我们讨论的是容器如何管理、服务如何拆分、流量如何治理。而在AI原生应用架构下，其目标是在满足可扩展、可观测、安全合规的同时，最大化释放模型的智能潜力。

在大语言模型（LLM）出现之前，AI只能以功能模块形态嵌入系统。LLM具备通用理解、推理和生成能力，并能通过函数调用、外部工具联动和知识库，形成可扩展的Agent体系。AI原生应用的运行逻辑不再完全由工程师编写的代码所决定，而是由大模型进行自出判断、行动和生成，并具备以下3个特征：

以LLM为核心，用自然语言统一交互协议；
以多模态感知扩展输入边界，以Agent框架编排工具链；
以数据飞轮驱动模型持续进化，实现系统的自我优化。

1.3 AI原生应用及其架构的定义

AI原生应用架构，涵盖了模型、应用开发框架、提示词、RAG、记忆、工具、网关、运行时、可观测、评估和安全等关键要素。

1.3.1 大模型推理决策

传统应用使用编程语言（Java、C++等）进行编码，AI原生应用使用大语言模型（LLM），通过Prompt（提示词）等自然语言方式进行构建。

LLM具有语义理解与推理方面的能力，能够在面对模糊和复杂的开放式任务时，自主生成和调整业务执行逻辑，并根据需要完成工具调用与流程编排。

1.3.2 Agent编排和执行

传统应用是工具，Agent是助手。单Agent无法完成复杂任务时，可以协同多Agent编排完成复杂任务。自身能力受限时，可以扩展工具，甚至自己编写工具完成任务。

1.3.3 数据优化决策

模型输出可能存在偏差，甚至在某些情况下完全不符合用户或业务方的预期。为了解决这个问题，AI原生应用必须具备基于数据驱动的持续进化能力。在多轮交互中，持续保留并利用历史信息，理解用户的偏好、行为习惯与目标。同时，应用还需要通过数据采集构建高质量的评测数据集，并结合行业数据、用户反馈数据和客户业务数据进行持续评估与优化。

1.3.4 工具调用与环境连接

大语言模型运行机制的本质仍是基于“输入Token→输出Token”的序列生成过程。受限于这一机制，模型既无法直接感知外部环境，也无法获取实时更新的知识，更缺乏对物理世界的直接操控能力。

AI原生应用通常通过工具调用的方式扩展模型的环境连接能力。一是支持语音、图像乃至动作等多模态输入；二是支持联网检索获取最新信息，并且通过API对接外部系统，或直接驱动企业内部系统的业务流程。“模型+工具”协同运行。

1.4 AI原生应用架构成熟度

1.4.1 AI原生应用架构成熟度的定义

AI原生应用架构成熟度，是指用于综合衡量AI原生应用在技术实现、业务融合与安全可信等方面所达到的水平，客观反映其从简单功能集成到复杂智能决策的演进阶段与发展层次。

1.4.2 AI原生应用架构成熟度的演进

1、概念验证级：单点功能辅助

2、早期试用级：场景化初步闭环

3、成熟应用级：核心业务深度集成

4、完全成熟级：企业级自适应迭代

1.4.3 AI原生应用架构成熟度的评估

以五大能力特征作为核心评估维度：自然语言交互能力、多模态理解与生成能力、动态推理与自主决策能力、持续学习与迭代能力、安全可信。

本评估体系旨在为AI原生应用的规划、开发、部署与优化提供一套完整的诊断工具和行动指南，最终推动其从概念验证走向规模化、高价值的产业应用。

Flask使用SQLite数据库

Mon, 05 Jan 2026 00:00:00 +0000

SQLite是一个小型的轻量数据库，特别适合个人学习使用。因为SQLite不需要额外的数据库服务器，同时它也是内嵌在Python中的。缺点就是如果有大量的写请求过来，它是串行处理的，速度很慢。

HttpRunner3的$符号是如何解析的

Mon, 05 Jan 2026 00:00:00 +0000

变量解析

$符号在很多测试框架中都会拿来用做变量解析，大名鼎鼎的JMeter就有这个用法。HttpRunner3也支持$符号，比如：

Step(
    RunRequest("登录")
        .post("/login")
        .with_headers(**{"Content-Type": "application/json"})
        .with_json({"username": "dongfanger", "password": "123456"})
        .extract()
        .with_jmespath("body.token", "token")
        .validate()
        .assert_equal("status_code", 200)
),
Step(
    RunRequest("搜索商品")
        .get("searchSku?skuName=电子书")
        .with_headers(**{"token": "$token"})
        .extract()
        .with_jmespath("body.skuId", "skuId")
        .with_jmespath("body.price", "skuPrice")
        .validate()
        .assert_equal("status_code", 200)
),

从登录提取的变量token，在搜索商品中使用$token来引用。

parser.py

HttpRunner对$符号的解析是在parser.py文件中实现的：

这些方法可以分为四类：

url

build_url()
变量

extract_variables() get_mapping_variable() parse_variables_mapping() regex_findall_variables() parse_data() parse_string()
函数

get_mapping_function() parse_function_params() regex_findall_functions() parse_string_value() parse_data() parse_string()
参数化（"${parameterize(account.csv)}"）

parse_parameters()

本文专门针对变量这一块源码来进行剖析。

全局变量池

HttpRunner3在运行时的所有变量都是存储在__session_variables这个字典中的：

在脚本开始时会把config的预设变量加载进来，然后会在执行Step测试步骤时，把各个步骤的变量也放到全局变量池里面。

解析过程

在runner.py的第350行代码能看到解析变量的调用：

然后parse_variables_mapping()函数需要仔细看：

def parse_variables_mapping(
    variables_mapping: VariablesMapping, functions_mapping: FunctionsMapping = None
) -> VariablesMapping:

    parsed_variables: VariablesMapping = {}

    while len(parsed_variables) != len(variables_mapping):
        for var_name in variables_mapping:

            if var_name in parsed_variables:
                continue

            var_value = variables_mapping[var_name]
            variables = extract_variables(var_value)

            # check if reference variable itself
            if var_name in variables:
                # e.g.
                # variables_mapping = {"token": "abc$token"}
                # variables_mapping = {"key": ["$key", 2]}
                raise exceptions.VariableNotFound(var_name)

            # check if reference variable not in variables_mapping
            not_defined_variables = [
                v_name for v_name in variables if v_name not in variables_mapping
            ]
            if not_defined_variables:
                # e.g. {"varA": "123$varB", "varB": "456$varC"}
                # e.g. {"varC": "${sum_two($a, $b)}"}
                raise exceptions.VariableNotFound(not_defined_variables)

            try:
                parsed_value = parse_data(
                    var_value, parsed_variables, functions_mapping
                )
            except exceptions.VariableNotFound:
                continue

            parsed_variables[var_name] = parsed_value

    return parsed_variables

tests/parser_test.py有一段测试代码：

JaCoCo增量覆盖率的基本实现原理

Mon, 05 Jan 2026 00:00:00 +0000

什么是增量覆盖率

如图所示，在master分支提交了HelloController，然后从master拉了个新分支test；提交了第1次代码，增加了WorldController；提交了第2次代码，增加了DonController。增量的获取方式有两种：

版本对比：在分支上，第2次提交和第1次提交版本对比的增量代码，就是DonController；第2次提交和刚从master拉取分支时版本对比的增量代码，除了DonController还有WorldController；
分支对比：把test分支和master分支进行对比，增量代码就是DonController和WorldController；

增量，就是通过版本对比或分支对比，多出来的新增加的那部分代码。覆盖率是指程序运行以后，有多少代码被执行到了，除以总的代码数算出来的，即覆盖率=执行代码行数/总代码行数。增量覆盖率是针对增量代码来计算的，也就是增量覆盖率=执行代码行数/增量代码行数。

基本实现原理

使用JaCoCo的On-the-fly模式，以tcpserver方式启动，将远程机器的覆盖率数据通过TCP通信dump到本地jacoco.exec文件，二次开发JaCoCo源码，实现增量覆盖率分析和输出HTML报告。

JaCoCo默认覆盖率

JaCoCo是一个开源的覆盖率工具，它的On-the-fly模式，无须侵入应用启动脚本，只需在JVM中通过-javaagent参数指定jar文件启动的代理程序，代理程序在ClassLoader装载一个class前判断是否需要注入class文件，将统计代码插入class，覆盖率分析就可以在JVM执行的过程中完成。

启动脚本示例：

java -javaagent:jacocoagent.jar -jar target/app.jar

默认情况下，JaCoCo会在JVM停掉以后，生成覆盖率数据，一个jacoco.exec文件。

官方手册也有相关说明：

output默认为file：At VM termination execution data is written to the file specified in the destfile attribute。这种方式有2个局限，一是必须停掉应用；二是只能把覆盖率数据生成到本地文件。

output还有另外一个选项，tcpserver：

java -javaagent:jacocoagent.jar=output=tcpserver,address=0.0.0.0,port=2014 -jar target/app.jar

address：服务端地址；

port：服务端端口；

通过这种方式启动后，会同时启动一个TCP服务端，使用lsof -i :2014命令查看端口进程：

然后就能通过TCP通信，来获取覆盖率数据，也就是所谓的”dump“。

代码片段：

@Override
    public void dump(String dumpPath, String ip, int port) throws IOException {
        dumpPath = FileUtil.getAbsolutePath(dumpPath);
        if (!FileUtil.exist(dumpPath)) {
            FileUtil.mkdir(dumpPath);
        }
        FileOutputStream localFile = new FileOutputStream(dumpPath + File.separator + "jacoco.exec");
        ExecutionDataWriter localWriter = new ExecutionDataWriter(localFile);
        SocketAddress socketAddress = new InetSocketAddress(ip, port);
        Socket socket = new Socket();
        try {
            socket.connect(socketAddress, 10000);
            RemoteControlWriter writer = new RemoteControlWriter(socket.getOutputStream());
            RemoteControlReader reader = new RemoteControlReader(socket.getInputStream());
            reader.setSessionInfoVisitor(localWriter);
            reader.setExecutionDataVisitor(localWriter);
            log.info("开始dump:{} {}", ip, port);
            writer.visitDumpCommand(true, false);
            if (!reader.read()) {
                log.error("Socket closed unexpectedly");
                throw new IOException("Socket closed unexpectedly.");
            }
            log.info("dump完成:{} {}", ip, port);
        } catch (Exception e) {
            log.info("dump失败:{}", e.getMessage());
        } finally {
            socket.close();
            localFile.close();
        }
    }

dump经过TCP通信，将远程机器的覆盖率数据取到本地后，生成jacoco.exec文件，然后可以使用jacococli.jar生成HTML报告：

JavaWeb开发基础Servlet请求分发与重定向

Mon, 05 Jan 2026 00:00:00 +0000

请求分发

Servlet的RequestDispatcher接口定义：

package javax.servlet;

import java.io.IOException;

public interface RequestDispatcher {
    String FORWARD_REQUEST_URI = "javax.servlet.forward.request_uri";
    String FORWARD_CONTEXT_PATH = "javax.servlet.forward.context_path";
    String FORWARD_PATH_INFO = "javax.servlet.forward.path_info";
    String FORWARD_SERVLET_PATH = "javax.servlet.forward.servlet_path";
    String FORWARD_QUERY_STRING = "javax.servlet.forward.query_string";
    String INCLUDE_REQUEST_URI = "javax.servlet.include.request_uri";
    String INCLUDE_CONTEXT_PATH = "javax.servlet.include.context_path";
    String INCLUDE_PATH_INFO = "javax.servlet.include.path_info";
    String INCLUDE_SERVLET_PATH = "javax.servlet.include.servlet_path";
    String INCLUDE_QUERY_STRING = "javax.servlet.include.query_string";
    String ERROR_EXCEPTION = "javax.servlet.error.exception";
    String ERROR_EXCEPTION_TYPE = "javax.servlet.error.exception_type";
    String ERROR_MESSAGE = "javax.servlet.error.message";
    String ERROR_REQUEST_URI = "javax.servlet.error.request_uri";
    String ERROR_SERVLET_NAME = "javax.servlet.error.servlet_name";
    String ERROR_STATUS_CODE = "javax.servlet.error.status_code";

    void forward(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    void include(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
}

它有2个方法，forward和include：

Java官方笔记2面向对象编程基本概念

Mon, 05 Jan 2026 00:00:00 +0000

对象Object

对象有2个特征：状态state和行为behavior。我们可以用真实世界的对象来做类比，这样有助于理解面向对象编程，比如狗的状态（名字、颜色、品种）和行为（叫、抓、摇尾巴），自行车的状态（当前档位、当前踏板节奏、当前速度）和行为（切换档位、切换踏板节奏、踩刹车）。

软件对象也是由状态和行为组成：

状态，在软件对象中，叫做字段fields，或变量variables。

行为，在软件对象中，叫做方法methods，或函数functions。

所谓的数据封装data encapsulation，就是字段只在内部，不对外暴露，仅由方法进行操作，对象与对象之间通过方法来相互访问。

Java是纯粹的面向对象编程语言。

类Class

类，可以视为对象的模版，基于类来创造出同一类对象。

比如自行车的类：

class Bicycle {

    int cadence = 0;
    int speed = 0;
    int gear = 1;

    void changeCadence(int newValue) {
         cadence = newValue;
    }

    void changeGear(int newValue) {
         gear = newValue;
    }

    void speedUp(int increment) {
         speed = speed + increment;   
    }

    void applyBrakes(int decrement) {
         speed = speed - decrement;
    }

    void printStates() {
         System.out.println("cadence:" +
             cadence + " speed:" + 
             speed + " gear:" + gear);
    }
}

类也是有2个特征：字段和方法。比如Bicycle类有字段cadence、speed、gear和方法changeCadence()、changeGear()、speedUp()等。

JMeter测试计划配置项解析

Mon, 05 Jan 2026 00:00:00 +0000

测试计划（Test Plan），是JMeter目录树的初始根节点，它的编辑区如下：

JUnit5的条件测试、嵌套测试、重复测试

Mon, 05 Jan 2026 00:00:00 +0000

条件测试

JUnit5支持条件注解，根据布尔值判断是否执行测试。

自定义条件

@EnabledIf和@DisabledIf注解用来设置自定义条件，示例：

@Test
@EnabledIf("customCondition")
void enabled() {
    // ...
}

@Test
@DisabledIf("customCondition")
void disabled() {
    // ...
}

boolean customCondition() {
    return true;
}

其中customCondition()方法用来返回布尔值，它可以接受一个ExtensionContext类型的参数。如果定义在测试类外部，那么需要是static方法。

内置条件

JUnit5的org.junit.jupiter.api.condition包中内置了一些条件注解。

操作系统条件

@EnabledOnOs和DisabledOnOs，示例：

@Test
@EnabledOnOs(MAC)
void onlyOnMacOs() {
    // ...
}

@TestOnMac
void testOnMac() {
    // ...
}

@Test
@EnabledOnOs({ LINUX, MAC })
void onLinuxOrMac() {
    // ...
}

@Test
@DisabledOnOs(WINDOWS)
void notOnWindows() {
    // ...
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Test
@EnabledOnOs(MAC)
@interface TestOnMac {
}

JRE条件

pytest参数化进阶

Mon, 05 Jan 2026 00:00:00 +0000

用过unittest的朋友，肯定知道可以借助DDT实现参数化。用过JMeter的朋友，肯定知道JMeter自带了4种参数化方式（见参考资料）。pytest同样支持参数化，而且很简单很实用。

SpringBoot官方笔记2使用

Mon, 05 Jan 2026 00:00:00 +0000

Build Systems

选择Maven or Gradle，而不要Ant（not particularly well supported）

In practice, you do not need to provide a version for any of these dependencies (spring-boot-dependencies) in your build configuration, as Spring Boot manages that for you. When you upgrade Spring Boot itself, these dependencies are upgraded as well in a consistent way.

Each release of Spring Boot is associated with a base version of the Spring Framework.

Starters are a set of convenient dependency descriptors that you can include in your application.

tep0.6.0更新聊聊pytest变量接口用例3个级别复用

Mon, 05 Jan 2026 00:00:00 +0000

tep是一款测试工具，在pytest测试框架基础上集成了第三方包，提供项目脚手架，帮助以写Python代码方式，快速实现自动化项目落地。fixture是pytest核心技术，本文聊聊如何使用fixture完成变量、接口、用例3个级别复用。

teprunner测试平台开发用例管理不只有增删改查

Mon, 05 Jan 2026 00:00:00 +0000

本文开发内容

用例管理是对用例进行增删改查，按照前面文章的思路，把它做出来应该不难，如果你已经自己写好了，那么可以和本文提交的代码比较下看看。除了增删改查，用例管理还需要提供运行用例的入口，在操作列添加一个运行按钮，单条用例运行，并弹窗展示运行结果。用例列表需要能看到每条用例执行情况，添加表格列用于展示，其中“运行结果”列要有超链接，点击查看上次运行结果。为了避免修改别人用例出错，还需要有个复制用例功能。除了在线编辑，平台应支持下载项目环境到本地，无缝切换到PyCharm，让新用户快速上手。综上所述，本文开发内容如下：

用例增删改查。
运行按钮，点击后弹出“运行用例结果”。
添加表格展示列，其中“运行结果”用颜色区分不同结果状态：passed，failed，error，点击超链接后弹出“查看用例结果”。
复制按钮，点击后生成一条复制的新用例。
新增/编辑页面，添加运行按钮。
运行/查看页面，添加编辑按钮。
下载环境到本地。

工作量主要在前端，后端先做一部分。

编写后端代码

编辑teprunner/urls.py，添加路由：

除了增删改查，还添加了2个接口，一个用于获取用例运行的结果，一个用于复制测试用例。

编辑teprunner/models.py，添加模型：

第一个Model是Case，没有定义name字段，实际上用例ID和用例描述已经够用了，name不知道填什么，有点多余。第二个Model是CaseResult，会记录运行结果，这个运行结果是从pytest执行日志最后一行的Summary截取出来的，比如1 passed，1 failed，耗时也是从Summary截取出来的。output存放代码运行后打到控制台的输出日志。最后三个字段记录运行环境、运行人和运行时间，运行时间取的数据库记录被添加/更新的时间。添加好以后迁移到数据库中：

python manage.py makemigrations
python manage.py migrate

编辑teprunner/serializers.py，添加序列化器，第一个序列化器是CaseSerializer：

只关联了Case模型的字段。

第二个序列化器是CaseListSerializer：

它主要用来返回用例列表的数据，除了用例本身，还需要用例结果。serializers.SerializerMethodField用于自定义序列化字段，定义好字段后，在下面添加get_前缀+字段名的方法，这是Django的规则，然后在方法内部添加取值代码，比如get_result()，instance是指Meta.model定义的模型，这里就等同于Case，通过instance.id获取到Case.id并赋值给case_id变量，从CaseResult的对象中过滤case_id匹配的用例结果，按运行时间倒序，取最新1条结果的result字段的值。其他字段的处理是类似的，runTime这里做了下日期格式化：

第三个序列化器是CaseResultSerializer：

只关联了CaseResult模型的字段，runTime同样做了日期格式化。从这里也能更清晰的看到，instance就是指的自己！

新建teprunner/views/case.py文件，添加视图，先把简单的两个视图做了，第一个视图是case_result：

这里是个知识点，采用@api_view注解的函数视图，如果想用序列化器，那么采用这种方式。

第二个视图是copy_case：

根据case_id查找到现有Case对象，在case.desc后面添加--复制后缀，其他字段数据复用，保存，就完成复制用例了。

第三个视图是CaseViewSet：

继承了ModelViewSet，重写了list列表查询，因为如果不重写，默认返回的结果是serializer_class = CaseSerializer序列化器的内容。我们需要的是CaseListSerializer这个序列化器的内容。这里也是一个知识点！如果想在类视图中，使用serializer_class以外的序列化器加分页，采用这种方式。

重写的list方法首先添加了project_id、case_id、desc、api四个过滤条件，与前端的当前项目、用例ID搜索框、用例描述搜索框、API路径搜索框一一对应。__icontains表示包含，相当于模糊匹配，i忽略大小写。接着用到了自定义分页的类，按照统一的分页格式，返回序列化器的数据。

最后，重写了update方法，用现有的创建人进行更新。

编写前端代码

编辑router/index.js，添加路由：

编辑views/teprunner/index.vue，添加菜单项：

新建views/teprunner/case/CaseManagement.vue文件，增删改查基础代码不再另加赘述，挑选新代码：

在运行结果列，添加了超链接，点击后打开用例结果弹窗，这个弹窗查看和运行用例都会用到，用第一个参数type做区分：

getResultColor方法返回颜色样式：

由于用例结果弹窗和用例列表表格都会有这个字段，于是把resultColor方法提取到了utils/commonMethods.js文件中：

CaseManagement.vue是一个父组件，它有3个子组件，如下图所示：

通过import后，添加标签代码引入：

是否显示弹窗通过DialogFormVisible的true/false来控制，DialogTitle指定弹窗标题。:开头是父组件向子组件传值， @开头是接受子组件发过来的emit事件通知，从而调用父组件中方法。这样就把这几个组件绑定在一起了！

端到端自动化的开源框架

Mon, 05 Jan 2026 00:00:00 +0000

什么是Playwright？

Playwright是一个开源框架，用于对Web应用进行端到端测试。

什么是端到端测试？

这里的“端”，不是指A模块或B模块，而是可以理解为从前端到后端。举个例子，对于登录功能来说，如果只测前端，那么测试范围就是前端页面，可能会对后端接口进行mock。如果只测后端，那么测试范围就是后端接口等。而端到端呢，就是前端输入用户名密码，点击登录，与后端交互，查询数据库，鉴权，后端返回登录成功，前端进行页面跳转。端到端测试，可以理解为全流程测试，也可以理解为模拟用户场景测试。

Playwright框架特点

官方网站首页：https://playwright.dev/python/

总结下重点，一是跨浏览器、跨平台、跨语言；二是自动等待；三是多用户场景测试；四是只需要一次登录；五是可以录制脚本。

快速入门

在官网的顶部菜单可以切换不同编程语言的教程：

本文及后续文章均选择Python。

安装

安装Python的Playwright，这里结合了pytest：

pip install pytest-playwright

成功后安装浏览器：

playwright install

这里也可以不安装浏览器，而是在脚本里面指定现有浏览器路径。

示例

test_example.py

import re
from playwright.sync_api import Page, expect

def test_has_title(page: Page):
    page.goto("https://playwright.dev/")

    # Expect a title "to contain" a substring.
    expect(page).to_have_title(re.compile("Playwright"))

def test_get_started_link(page: Page):
    page.goto("https://playwright.dev/")

    # Click the get started link.
    page.get_by_role("link", name="Get started").click()

    # Expects page to have a heading with the name of Installation.
    expect(page.get_by_role("heading", name="Installation")).to_be_visible()

执行pytest后默认会选择chrome在headless模式下运行，可以通过日志观察运行过程。

更新命令：

pip install pytest-playwright playwright -U

编写测试

访问url：

解决“测试流程”问题的底层逻辑

Mon, 05 Jan 2026 00:00:00 +0000

这3个问题本质上都是测试流程问题，解决的底层逻辑是建立自己的流程并灵活调整。

你知道Python基本数据类型是哪6个么

Mon, 05 Jan 2026 00:00:00 +0000

Python 是强类型语言，在学习 Python 时，有必要了解 Python 有哪些基本数据类型，一共 6 个：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）。数据类型的知识是非常多的，一篇文章讲不明白，本文仍然属于入门系列，内容主要是基础简介。

字符集其实很简单

Mon, 05 Jan 2026 00:00:00 +0000

字符集其实是个很简单的东西，但很多人当时看懂了，过了就忘了。

自定义Django认证系统的技术方案

Mon, 05 Jan 2026 00:00:00 +0000

Django已经提供了开箱即用的认证系统，但是可能并不满足我们的个性化需求。自定义认证系统需要知道哪些地方可以扩展，哪些地方可以替换。本文就来介绍自定义Django认证系统的相关技术细节。

Django认证系统并不鸡肋反而很重要

Sun, 04 Jan 2026 00:00:00 +0000

在使用django-admin startproject创建项目后，Django就默认安装了一个采用session实现的认证系统。这是Django相比于其他框架的一大特点：自带认证系统，开箱即用。有人说它方便，有人说它鸡肋，但它作为Django的重要组成部分，学习它有助于我们理解Django框架的核心技术。

FastAPI使用typing类型提示

Sun, 04 Jan 2026 00:00:00 +0000

typing是Python标准库，用来做类型提示。FastAPI使用typing做了：

Flask启动应用时都干了些啥

Sun, 04 Jan 2026 00:00:00 +0000

一个Flask应用（Flask Application）是Flask类（Flask Class）的实例。在前面的文章中，都是通过定义全局Flask实例的方式来编写的Flask应用代码，比如：

HttpRunner3的变量是如何传递的

Sun, 04 Jan 2026 00:00:00 +0000

HttpRunner3的变量可以在测试类的用例配置中通过variables添加，也可以在测试步骤中使用extract()、with_jmespath()提取出来放到变量x，再用$x传递给下一个接口使用，比如登录到下单流程的部分测试脚本如下：

JavaWeb开发基础Servlet生命周期与工作原理

Sun, 04 Jan 2026 00:00:00 +0000

Servlet生命周期

Servlet的生命周期由Servlet容器（如Tomcat、Jetty等）管理，主要包括以下5个阶段：

加载Servlet类
创建Servlet实例
调用init方法
调用service方法
调用destroy方法

加载（Loading）：
- 当Servlet容器启动或第一次接收到对某个Servlet的请求时，它会加载Servlet类
- 这个过程只发生一次，除非Servlet被卸载或容器重新启动
实例化（Instantiation）：
- 在加载Servlet类之后，容器会创建一个Servlet实例
- 这个实例化过程也是一次性的，除非Servlet被卸载或容器重新启动
初始化（Initialization）：
- 容器调用Servlet实例的init()方法进行初始化
- init()方法只被调用一次，用于执行一次性的初始化任务，如读取配置参数、初始化资源等
- 你可以重写init()方法以执行自定义的初始化逻辑
```
public void init(ServletConfig config)
```
请求处理（Request Handling）：
- 每当有请求到达时，容器会调用Servlet的service()方法来处理请求
- service()方法根据请求的类型（如GET、POST等）调用相应的处理方法（如doGet()、doPost()等）
```
public void service(ServletRequest request, ServletResponse response)
```
销毁（Destruction）：
- 当容器决定卸载Servlet（如容器关闭或Servlet被重新加载）时，它会调用Servlet的destroy()方法
- destroy()方法用于执行清理任务，如关闭资源、保存状态等
- destroy()方法只被调用一次
```
public void destroy()
```

Servlet重新加载

Servlet被重新加载通常发生在以下几种情况下：

Servlet类文件被修改：
- 如果在开发过程中修改了Servlet类文件，Servlet容器可能会检测到这些更改并重新加载Servlet
- 这通常发生在开发环境中，生产环境中一般不会自动重新加载
容器配置发生变化：
- 如果修改了Servlet容器的配置文件（如web.xml），容器可能会重新加载相关的Servlet
容器重启：
- 当Servlet容器重启时，所有的Servlet都会被重新加载
手动重新加载：
- 某些Servlet容器提供了手动重新加载Servlet的功能，通常通过管理控制台或命令行工具

当Servlet被重新加载时，Servlet容器会执行以下步骤：

销毁现有的Servlet实例：
- 容器调用现有Servlet实例的destroy()方法，执行清理任务
- 释放资源，如关闭数据库连接、释放文件句柄等
卸载Servlet类：
- 容器卸载现有的Servlet类，释放类加载器持有的资源
重新加载Servlet类：
- 容器重新加载Servlet类文件，创建新的类加载器实例
实例化新的Servlet对象：
- 容器创建新的Servlet实例
初始化新的Servlet实例：
- 容器调用新的Servlet实例的init()方法进行初始化

Servlet代码示例

有3种方式使用Servlet：

①实现Servlet接口

import java.io.*;
import javax.servlet.*;

public class First implements Servlet {
    ServletConfig config = null;

    public void init(ServletConfig config) {
        this.config = config;
        System.out.println("servlet is initialized");
    }

    public void service(ServletRequest req, ServletResponse res)
            throws IOException, ServletException {
        res.setContentType("text/html");
        PrintWriter out = res.getWriter();
        out.print("<html><body>");
        out.print("<b>hello simple servlet</b>");
        out.print("</body></html>");

    }

    public void destroy() {
        System.out.println("servlet is destroyed");
    }

    public ServletConfig getServletConfig() {
        return config;
    }

    public String getServletInfo() {
        return "copyright 2007-1010";
    }
}

②继承GenericServlet类

Java官方笔记1编写运行Java程序

Sun, 04 Jan 2026 00:00:00 +0000

你可能已经迫不及待想安装Java，写个Java程序跑起来了。但是在这之前，有些概念需要提前了解，因为Java跟C、C++和Python都有点不一样。

JMeter元件作用域实践指南

Sun, 04 Jan 2026 00:00:00 +0000

从一个问题说起

对于以下测试脚本：

为了能调用进入房间接口，需要从考场接口获取考场token。为了调用考场接口，需要从登陆接口获取登陆token。元件说明如下：

学生登录，提取登录${token}传入下个接口参数。
添加HTTP Header Manager：
考场token，提取考场${exam_token}传入下个接口参数。
添加HTTP Header Manager：
进入房间

貌似挺合理，HTTP Header Manager会给下方的接口添加请求头，运行结果真的如我们所料么？

运行顺序

在回答这个问题之前，有必要搞懂JMeter元件的运行顺序，它是由2 个维度来决定的：从上往下和元件类型。

从上往下，即目录树从上往下。元件类型，分为3类：

线程组、逻辑控制器。
取样器。
配置元件、前置处理器、定时器、后置处理器、断言、监听器。

它们的运行顺序如下：

配置元件（如果存在）
前置处理器（如果存在）
定时器（如果存在）
取样器（如果存在）
后置处理器（如果存在且取样器的结果不为空）
断言（如果存在且取样器的结果不为空）
监听器（如果存在且取样器的结果不为空）

换句话说，假设我们新建了1个线程，想用这个线程去发请求。

第一步，初始化配置，比如参数化、设置Header、Cookie等，用到配置元件。

第二步，可能需要给线程加点参数，比如用户参数，用到前置处理器。

第三步，在发送请求前可能会等待一段时间，用到定时器。

第四步，发送请求，用到取样器。

第五步，可能需要提取响应数据，比如正则表达式提取器、JMESPath提取器，用到后置处理器。

第六步，验证结果符合预期，用到断言。

第七步，查看请求响应数据和测试结果，用到监听器。

实践指南

对于以下所列元件：

JMeter会按以下步骤运行：

线程组（如果有多个线程组可以在测试计划设置是顺序执行还是同时执行）
简单控制器（父节点）
HTTP Cookie管理器（配置元件）
用户参数（前置处理器）
Synchronizing Timer（定时器）
HTTP 请求1（取样器）
正则表达式提取器（后置处理器）
响应断言（断言）
HTTP Cookie管理器（配置元件）
用户参数（前置处理器）
Synchronizing Timer（定时器）
HTTP 请求2（取样器）
正则表达式提取器（后置处理器）
响应断言（断言）
HTTP 请求3（取样器）
察看结果树（严格来讲是与第 6 步并行，也就是取样器之后）

作用域

其中有个观察作用域实际效果的关键元件：HTTP请求2，它的前后并没有元件，但是也被作用上了。在JMeter中，同一层级的元件具有相同的作用域！

JUnit5的Tag、Filter、Order、Lifecycle

Sun, 04 Jan 2026 00:00:00 +0000

Tag

JUnit5可以使用@Tag注解给测试类和测试方法打tag，这些tag能用来在执行时进行过滤，它跟group有点类似。

tag应该遵循以下规则：

不能为null或者为空。
不能包含空格。
不能包含ISO控制字符。
不能包含保留字符：, ( ) & | !

示例代码：

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;

@Tag("fast")
@Tag("model")
class TaggingDemo {

    @Test
    @Tag("taxes")
    void testingTaxCalculation() {
    }

}

Filter

打好了tag后，在执行时可以进行过滤，比如Maven配置：

<!-- ... -->
<build>
    <plugins>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
            <configuration>
                <groups>acceptance | !feature-a</groups>
                <excludedGroups>integration, regression</excludedGroups>
            </configuration>
        </plugin>
    </plugins>
</build>
<!-- ... -->

groups用来指定包含哪些tag，excludedGroups用来指定排除哪些tag。

Order

JUnit5默认使用了某种算法来确定test方法的执行顺序。我们可以通过@TestMethodOrder进行自定义，既可以使用内置类，也可以使用实现了MethodOrderer接口的类。

内置类如下：

DisplayName 按DisplayName的字母数字顺序
OrderAnnotation 通过@Order注解指定顺序
Random 随机顺序
Alphanumeric 按test方法名和参数列表的字母数字顺序

示例：

OkHttp学习笔记

Sun, 04 Jan 2026 00:00:00 +0000

OkHttp是什么

OkHttp是一个HTTP客户端，它不只是简单的发送请求和接收响应，还包含了失败重试、响应缓存等特性功能，并且能支持同步和异步请求。

OkHttp的语法相当简洁，比如Get：

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

比如Post：

public static final MediaType JSON
    = MediaType.get("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(json, JSON);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

常见用法

Get（同步）

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      Headers responseHeaders = response.headers();
      for (int i = 0; i < responseHeaders.size(); i++) {
        System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
      }

      System.out.println(response.body().string());
    }
  }

Get（异步）

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();

    client.newCall(request).enqueue(new Callback() {
      @Override public void onFailure(Call call, IOException e) {
        e.printStackTrace();
      }

      @Override public void onResponse(Call call, Response response) throws IOException {
        try (ResponseBody responseBody = response.body()) {
          if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

          Headers responseHeaders = response.headers();
          for (int i = 0, size = responseHeaders.size(); i < size; i++) {
            System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
          }

          System.out.println(responseBody.string());
        }
      }
    });
  }

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://api.github.com/repos/square/okhttp/issues")
        .header("User-Agent", "OkHttp Headers.java")
        .addHeader("Accept", "application/json; q=0.5")
        .addHeader("Accept", "application/vnd.github.v3+json")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println("Server: " + response.header("Server"));
      System.out.println("Date: " + response.header("Date"));
      System.out.println("Vary: " + response.headers("Vary"));
    }
  }

Post JSON

public static final MediaType JSON
    = MediaType.get("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(json, JSON);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

Post字符串

  public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse("text/x-markdown; charset=utf-8");

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    String postBody = ""
        + "Releases\n"
        + "--------\n"
        + "\n"
        + " * _1.0_ May 6, 2013\n"
        + " * _1.1_ June 15, 2013\n"
        + " * _1.2_ August 11, 2013\n";

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody))
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

Post Streaming

  public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse("text/x-markdown; charset=utf-8");

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    RequestBody requestBody = new RequestBody() {
      @Override public MediaType contentType() {
        return MEDIA_TYPE_MARKDOWN;
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        sink.writeUtf8("Numbers\n");
        sink.writeUtf8("-------\n");
        for (int i = 2; i <= 997; i++) {
          sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;
          if (x * i == n) return factor(x) + " × " + i;
        }
        return Integer.toString(n);
      }
    };

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(requestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

Post文件

  public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse("text/x-markdown; charset=utf-8");

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    File file = new File("README.md");

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

Post parameters

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    RequestBody formBody = new FormBody.Builder()
        .add("search", "Jurassic Park")
        .build();
    Request request = new Request.Builder()
        .url("https://en.wikipedia.org/w/index.php")
        .post(formBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

Post multipart

  /**
   * The imgur client ID for OkHttp recipes. If you're using imgur for anything other than running
   * these examples, please request your own client ID! https://api.imgur.com/oauth2
   */
  private static final String IMGUR_CLIENT_ID = "...";
  private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
    RequestBody requestBody = new MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("title", "Square Logo")
        .addFormDataPart("image", "logo-square.png",
            RequestBody.create(MEDIA_TYPE_PNG, new File("website/static/logo-square.png")))
        .build();

    Request request = new Request.Builder()
        .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID)
        .url("https://api.imgur.com/3/image")
        .post(requestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

解析JSON响应为Java对象

  private final OkHttpClient client = new OkHttpClient();
  private final Moshi moshi = new Moshi.Builder().build();
  private final JsonAdapter<Gist> gistJsonAdapter = moshi.adapter(Gist.class);

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://api.github.com/gists/c2a7c39532239ff261be")
        .build();
    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      Gist gist = gistJsonAdapter.fromJson(response.body().source());

      for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) {
        System.out.println(entry.getKey());
        System.out.println(entry.getValue().content);
      }
    }
  }

  static class Gist {
    Map<String, GistFile> files;
  }

  static class GistFile {
    String content;
  }

响应缓存

  private final OkHttpClient client;

  public CacheResponse(File cacheDirectory) throws Exception {
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(cacheDirectory, cacheSize);

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();

    String response1Body;
    try (Response response1 = client.newCall(request).execute()) {
      if (!response1.isSuccessful()) throw new IOException("Unexpected code " + response1);

      response1Body = response1.body().string();
      System.out.println("Response 1 response:          " + response1);
      System.out.println("Response 1 cache response:    " + response1.cacheResponse());
      System.out.println("Response 1 network response:  " + response1.networkResponse());
    }

    String response2Body;
    try (Response response2 = client.newCall(request).execute()) {
      if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);

      response2Body = response2.body().string();
      System.out.println("Response 2 response:          " + response2);
      System.out.println("Response 2 cache response:    " + response2.cacheResponse());
      System.out.println("Response 2 network response:  " + response2.networkResponse());
    }

    System.out.println("Response 2 equals Response 1? " + response1Body.equals(response2Body));
  }

取消调用

  private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build();

    final long startNanos = System.nanoTime();
    final Call call = client.newCall(request);

    // Schedule a job to cancel the call in 1 second.
    executor.schedule(new Runnable() {
      @Override public void run() {
        System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f);
        call.cancel();
        System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f);
      }
    }, 1, TimeUnit.SECONDS);

    System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f);
    try (Response response = call.execute()) {
      System.out.printf("%.2f Call was expected to fail, but completed: %s%n",
          (System.nanoTime() - startNanos) / 1e9f, response);
    } catch (IOException e) {
      System.out.printf("%.2f Call failed as expected: %s%n",
          (System.nanoTime() - startNanos) / 1e9f, e);
    }
  }

超时

  private final OkHttpClient client;

  public ConfigureTimeouts() throws Exception {
    client = new OkHttpClient.Builder()
        .connectTimeout(10, TimeUnit.SECONDS)
        .writeTimeout(10, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build();

    try (Response response = client.newCall(request).execute()) {
      System.out.println("Response completed: " + response);
    }
  }

Per-call Configuration

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build();

    // Copy to customize OkHttp for this request.
    OkHttpClient client1 = client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build();
    try (Response response = client1.newCall(request).execute()) {
      System.out.println("Response 1 succeeded: " + response);
    } catch (IOException e) {
      System.out.println("Response 1 failed: " + e);
    }

    // Copy to customize OkHttp for this request.
    OkHttpClient client2 = client.newBuilder()
        .readTimeout(3000, TimeUnit.MILLISECONDS)
        .build();
    try (Response response = client2.newCall(request).execute()) {
      System.out.println("Response 2 succeeded: " + response);
    } catch (IOException e) {
      System.out.println("Response 2 failed: " + e);
    }
  }

处理认证鉴权

  private final OkHttpClient client;

  public Authenticate() {
    client = new OkHttpClient.Builder()
        .authenticator(new Authenticator() {
          @Override public Request authenticate(Route route, Response response) throws IOException {
            if (response.request().header("Authorization") != null) {
              return null; // Give up, we've already attempted to authenticate.
            }

            System.out.println("Authenticating for response: " + response);
            System.out.println("Challenges: " + response.challenges());
            String credential = Credentials.basic("jesse", "password1");
            return response.request().newBuilder()
                .header("Authorization", credential)
                .build();
          }
        })
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://publicobject.com/secrets/hellosecret.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

跳过重试：

pytest内置和自定义marker

Sun, 04 Jan 2026 00:00:00 +0000

可以通过命令行查看所有marker，包括内置和自定义的

Python运算符可不只有加减乘除

Sun, 04 Jan 2026 00:00:00 +0000

数学里面的加减乘除，就是运算符，但是 Python 的运算符更多样，更复杂，分为算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符、身份运算符。为了更直观的看到运算符的使用，本文采用代码和注释结合的方式进行讲解。

send_keys报错element_not_interactable

Sun, 04 Jan 2026 00:00:00 +0000

这两天要在阿里云日志中操作UI，以输入关键字搜索日志。

SpringBoot官方笔记1入门

Sun, 04 Jan 2026 00:00:00 +0000

Spring Boot helps you to create stand-alone, production-grade Spring-based applications that you can run. Most Spring Boot applications need very little Spring configuration.

SpringBoot接入JaCoCo实践教程

Sun, 04 Jan 2026 00:00:00 +0000

静态接入和动态接入

SpingBoot可以通过2种方式接入JaCoCo：Maven和Agent。Maven方式是静态接入，在编译时计算代码覆盖率。Agent方式是动态接入，服务启起来以后，能实时根据代码命中情况计算代码覆盖率。

教程代码已上传开源项目：https://github.com/dongfanger/mini

Maven

pom.xml添加依赖：

<dependency>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.7</version>
</dependency>

添加配置：

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${project.parent.version}</version>
            </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.7</version>
                <executions>
                    <execution>
                        <id>default-prepare-agent</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>default-report</id>
                        <goals>
                            <goal>report</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

点击maven的install：

target/site/jacoco目录下就生成了覆盖率报告：

Agent

下载jacoco文件后解压，提取2个文件：

使用命令启动SpringBoot，启动参数添加-javaagent：

java -javaagent:jacoco/jacocoagent.jar -jar target/mini-0.0.1-SNAPSHOT.jar

此时会生成1个jacoco.exec文件，这个文件就是覆盖率数据文件，采用以下命令根据数据文件生成HTML报告：

java -jar jacoco/jacococli.jar report jacoco.exec --classfiles ./target/classes/ --sourcefiles ./src/main/java/ --html ./report

接下来就来验证动态特性。把report目录和jacoco.exec都删了，因为jacoco每次部署只能分析一次。把服务停掉后，重新启动。这一次不直接分析，而是先用postman调一下接口：

然后再分析一把：

teprunner测试平台用例前置模块开发

Sun, 04 Jan 2026 00:00:00 +0000

本文开发内容

现在正式进入测试相关功能开发。teprunner测试平台底层是pytest，中间层是tep，还没了解的朋友可以先看看tep的文章，整个平台的设计思路和后面用例的执行都会基于这个工具。tep的测试用例是放在.py文件里面的，全局变量或者说环境变量是引用的env_vars，公共函数和复用接口是引用的fixtures，在做成平台后，需要把这两个部分独立为两个功能模块。多个项目的接口自动化数据需要隔离开来，要有个项目管理功能。本文将开发四个用例前置模块：

后台管理–项目管理
接口自动化–语法说明
接口自动化–环境变量
接口自动化–fixtures

编写后端代码

先创建名为teprunner的app：

django-admin startapp teprunner

在settings的INSTALLED_APPS中添加配置让app生效：

并在urls.py添加路由：

编辑user/fixtures/user.json，添加一个接口自动化的菜单：

截图只截了管理员，测试和开发角色，也需要添加上。access均为true，这三个角色都可以访问。添加后把数据同步到数据库：

python manage.py loaddata user

编辑teprunner/models.py，新增模型：

包括了项目、环境变量和fixture三张表。Project.env_config用于给项目配置多个环境。不同项目不同环境的环境变量不一样，在EnvVar中添加了project_id和env_name，并按(“project_id”, “env_name”, “name”)作为唯一键，不允许重复。不同项目的fixtures不同，不关心环境，在Fixture中只添加了project_id。

models编写好后，迁移到数据库：

python manage.py makemigrations
python manage.py migrate

新建teprunner/serializers.py文件，新增序列化器：

数据库字段的命名是用的下划线，接口返回前端和前端传参是用的驼峰，所以这里通过source这种方式给env_config、project_id、env_name、creator_nickname进行了序列化器的重命名。为了前端更方便处理，使用serializers.CharField把int转化为了str，由于请求时id非必须，增加参数required=False。

teprunner会有很多视图，写在一个文件里面有点臃肿，这里创建views文件夹，新增views/project.py项目视图：

Django REST framework的ModelViewSet视图类能节省很多代码，只需要三行就把项目增删改查接口做了。project_env是函数视图，请求方法为GET，它的作用是返回项目环境列表，当前项目和当前环境，默认为第一个项目和第一个环境。

新建views/envvar.py新增环境变量视图：

环境变量跟项目和环境是强关联的，需要根据项目环境进行过滤，所以重写了list方法，从前端请求拿到curProjectId和curEnvName，通过EnvVar.objects.filter进行过滤。from django.db.models import Q支持多种过滤条件，这在后面的代码中还能看到，比如模糊匹配。

新建views/fixture.py新增fixture视图：

fixture跟项目是强关联的，需要根据项目进行过滤，所以重写了list方法，从前端请求拿到curProjectId，通过Fixture.objects.filter进行过滤。Fixture有个creatorNickname字段，新增fixture时使用的是当前登录用户的昵称，修改fixture时需要用已保存的创建者，重写update方法来实现这个处理。

最后，新建teprunner/urls.py文件，把视图添加到路由中：

编写前端代码

编辑package.json，添加依赖：

fixtures是代码形式的，这是测试平台第一次使用代码编辑组件。添加依赖后记得执行npm install进行安装。

编辑router/index.js：

添加接口自动化的路由，并把home重定向改为语法说明路由。children表示子路由。path是路由地址。meta.title用于显示菜单名。

编辑views/console/index.vue：

添加项目管理菜单。新建ProjectManagement.vue和AddProject.vue，添加项目管理增删改查代码，跟用户管理类似，不再另加赘述。值得注意的是环境配置placeholder="请输入环境英文名（多个环境英文逗号分隔）"，因为tep.env_vars.mapping会用到环境名作为key，所以只能用英文名！

编辑components/WrapComponent.vue，添加一个插槽：

把RPC包进事务的暗坑

Sun, 04 Jan 2026 00:00:00 +0000

# 方式：把判断放进 SQL，一条语句的原子性
rows = db.execute("""
    UPDATE pay_record SET status = 'PAID'
    WHERE order_no = ? AND status = 'INIT'
""", order_no)

if rows == 0:
    return "已处理"          # 别人改过了，我不是第一个

grant_coupon(order_no)       # 只有改成功的那个才发券
return "success"

grant_coupon失败会发生什么？

券永久丢失，该发没发，资损。

第一次请求：

UPDATE status: INIT → PAID   ✅ 已提交，改不回去了
grant_coupon(order_no)        ❌ 抛异常 / 超时 / 下游挂了

第二次请求：

rows = db.execute("UPDATE ... WHERE status = 'INIT'")  # status已是PAID
# rows == 0
return "已处理"   # ← 被自己的幂等逻辑拦住，不会执行grant_coupon

包进一个事务能解决吗

把update和grant_coupon这两个操作，包进一个事务里，要么同时执行，要么同时回滚，是不是就解决了？

工作以后，换种方式学习

Sun, 04 Jan 2026 00:00:00 +0000

工作碎片化时间，理解，思考，总结，能够加速成长。

如何用tep完成增删改查接口自动化

Sun, 04 Jan 2026 00:00:00 +0000

tep的设计理念是让人人都可以用Python写自动化，本文就来介绍如何用tep完成增删改查接口自动化。

80道高频算法题Python版

Sat, 03 Jan 2026 00:00:00 +0000

80道高频算法题来源于牛客网，这些答案都经过了我验证，可以复制粘贴后提交通过：

Django官方为什么没有标准项目结构

Sat, 03 Jan 2026 00:00:00 +0000

Django官方并没有提供标准的项目结构，于是网上众说纷纭，百花齐放，一千个读者有一千个哈姆雷特。那我们该怎么设计项目结构呢？在回答这个问题之前，先了解一下Django原生的目录和文件都是干嘛的。

Dockerfile文件万字全面解析

Sat, 03 Jan 2026 00:00:00 +0000

Dockerfile是一个文本文件，包含一些Docker指令。执行docker build，Docker就会执行Dockerfile里面的指令，来自动创建镜像。

Flask官方推荐项目结构竟然是这样

Sat, 03 Jan 2026 00:00:00 +0000

Flask有个特点：千人千面。它没有硬性规定，你必须采用哪种项目结构来组织代码，这就导致每个人都按照自己的习惯和喜好来写，写出来的项目结构往往是千差万别。在Flask2.0的官方文档中，有一节内容介绍了Flask的项目结构，我们可以窥探一番。

Git比较分支差异的3个命令

Sat, 03 Jan 2026 00:00:00 +0000

查看本地分支

HttpRunner3的用例是怎么运行起来的

Sat, 03 Jan 2026 00:00:00 +0000

在PyCharm中打开examples/httpbin/basic_test.py：

JavaWeb开发基础ServletAPI

Sat, 03 Jan 2026 00:00:00 +0000

Servlet版本

Oracle将Java EE（Java SE还自己保留）交给开源组织，Eclipse基金会接手。但Oracle不允许开源组织使用Java名号，所以Jakarta EE名称于2018.02.26应运而生。

正是因为组织变化，Servlet被割裂为了2个版本，javax.servlet和jakarta.servlet。

javax.servlet已经停止维护，但它仍然是一个非常有用和重要的技术，特别是在许多现有项目中，学习和使用它将为你提供坚实的Web开发基础。

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

如果希望使用Jakarta EE 9或更高版本的Servlet API，则需要切换到javax.servlet。

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.0.0</version>
    <scope>provided</scope>
</dependency>

本文将基于javax.servlet来介绍Servlet，从Usages来看，它仍然是使用最广泛的。

Servlet API

Servlet API主要有2个包，javax.servlet包含了servlet和web container使用的接口和类。javax.servlet.http包含了http相关的接口和类。

javax.servlet接口列表：

Servlet
ServletRequest
ServletResponse
RequestDispatcher
ServletConfig
ServletContext
SingleThreadModel
Filter
FilterConfig
FilterChain
ServletRequestListener
ServletRequestAttributeListener
ServletContextListener
ServletContextAttributeListener

javax.servlet类列表：

GenericServlet
ServletInputStream
ServletOutputStream
ServletRequestWrapper
ServletResponseWrapper
ServletRequestEvent
ServletContextEvent
ServletRequestAttributeEvent
ServletContextAttributeEvent
ServletException
UnavailableException

javax.servlet.http接口列表：

HttpServletRequest
HttpServletResponse
HttpSession
HttpSessionListener
HttpSessionAttributeListener
HttpSessionBindingListener
HttpSessionActivationListener
HttpSessionContext (deprecated now)

javax.servlet.http类列表：

JMeter英文版界面介绍

Sat, 03 Jan 2026 00:00:00 +0000

JMeter的界面虽然不华丽，但是使用起来还是很便利。本文将基于英文版界面对整个可视区域进行介绍，如果想看中文版，请在菜单栏点击Choose Language切换：

JUnit5编写基本测试

Sat, 03 Jan 2026 00:00:00 +0000

JUnit5的测试不是通过名称，而是通过注解来标识的。

pytestx容器化执行引擎

Sat, 03 Jan 2026 00:00:00 +0000

系统架构

前端、后端、pytest均以Docker容器运行服务，单独的容器化执行引擎，项目环境隔离，即用即取，用完即弃，简单，高效。

前端容器：页面交互，请求后端，展示HTML报告
后端容器：接收前端请求，启动任务，构建镜像，触发运行pytest，挂载HTML报告
pytest容器：拉取项目代码，指定目录执行，生成HTML报告

系统流程

支持2种运行模式配置：容器和本地。

容器模式：判断是否支持docker，如果支持，构建pytest镜像，在构建时，通过git拉取项目代码，再运行容器，按照指定目录执行pytest，生成测试报告，并将报告文件挂载到后端。如果不支持，降级为本地运行。

本地模式：模拟容器行为，在本地目录拉取代码，执行pytest，生成测试报告。

效果展示

任务管理：

容器模式：

本地模式：

平台大改造

pytestx平台更轻、更薄，移除了用例管理、任务关联用例相关功能代码，只保留真正的任务调度功能，backend的requirements.txt解耦，只保留后端依赖，pytest相关依赖转移到tep-project。

那如何管理用例呢？约定大于配置，我们约定pytest项目已经通过目录维护好了一个稳定的自动化用例集，也就是说需要通过平台任务调度的用例，都统一存放在目录X下，这些用例基本不需要维护，可以每日稳定执行，然后将目录X配置到平台任务信息中，按指定目录执行用例集。对于那些不够稳定的用例，就不能放到目录X下，需要调试好以后再纳入。

为什么不用marker？pytest的marker确实可以给测试用例打标记，也有人是手动建立任务和用例进行映射，这些方式都不如维护一个稳定的自动化用例集方便，在我们公司平台上，也是维护用例集，作为基础用例集。使用pytest项目同理。

核心代码

一键部署

#!/bin/bash
PkgName='backend'

Dockerfile='./deploy/Dockerfile.backend'
DockerContext=./

echo "Start build image..."
docker build -f $Dockerfile -t $PkgName $DockerContext
if [ $? -eq 0 ]
then
    echo "Build docker image success"
    echo "Start run image..."
    docker run -p 8000:80 $PkgName
else
    echo "Build docker image failed"
fi

FROM python:3.8

ENV LANG C.UTF-8
ENV TZ=Asia/Shanghai

RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone

WORKDIR /app
COPY ./backend .
RUN pip install -r ./requirements.txt -i \
    https://pypi.tuna.tsinghua.edu.cn/simple \
    --default-timeout=3000

CMD ["python", "./manage.py", "runserver", "0.0.0.0:80"]

数据库表

pytest精通fixture

Sat, 03 Jan 2026 00:00:00 +0000

fixture是什么

看看源码

def fixture(
    callable_or_scope=None,
    *args,
    scope="function",
    params=None,
    autouse=False,
    ids=None,
    name=None
):
    """Decorator to mark a fixture factory function.

    This decorator can be used, with or without parameters, to define a
    fixture function.

    The name of the fixture function can later be referenced to cause its
    invocation ahead of running tests: test
    modules or classes can use the ``pytest.mark.usefixtures(fixturename)``
    marker.

    Test functions can directly use fixture names as input
    arguments in which case the fixture instance returned from the fixture
    function will be injected.

    Fixtures can provide their values to test functions using ``return`` or ``yield``
    statements. When using ``yield`` the code block after the ``yield`` statement is executed
    as teardown code regardless of the test outcome, and must yield exactly once.

    :arg scope: the scope for which this fixture is shared, one of
                ``"function"`` (default), ``"class"``, ``"module"``,
                ``"package"`` or ``"session"`` (``"package"`` is considered **experimental**
                at this time).

                This parameter may also be a callable which receives ``(fixture_name, config)``
                as parameters, and must return a ``str`` with one of the values mentioned above.

                See :ref:`dynamic scope` in the docs for more information.

    :arg params: an optional list of parameters which will cause multiple
                invocations of the fixture function and all of the tests
                using it.
                The current parameter is available in ``request.param``.

    :arg autouse: if True, the fixture func is activated for all tests that
                can see it.  If False (the default) then an explicit
                reference is needed to activate the fixture.

    :arg ids: list of string ids each corresponding to the params
                so that they are part of the test id. If no ids are provided
                they will be generated automatically from the params.

    :arg name: the name of the fixture. This defaults to the name of the
                decorated function. If a fixture is used in the same module in
                which it is defined, the function name of the fixture will be
                shadowed by the function arg that requests the fixture; one way
                to resolve this is to name the decorated function
                ``fixture_<fixturename>`` and then use
                ``@pytest.fixture(name='<fixturename>')``.
    """
    if params is not None:
        params = list(params)

    fixture_function, arguments = _parse_fixture_args(
        callable_or_scope,
        *args,
        scope=scope,
        params=params,
        autouse=autouse,
        ids=ids,
        name=name,
    )
    scope = arguments.get("scope")
    params = arguments.get("params")
    autouse = arguments.get("autouse")
    ids = arguments.get("ids")
    name = arguments.get("name")

    if fixture_function and params is None and autouse is False:
        # direct decoration
        return FixtureFunctionMarker(scope, params, autouse, name=name)(
            fixture_function
        )

    return FixtureFunctionMarker(scope, params, autouse, ids=ids, name=name)

总结一下

teprunner测试平台部署到Linux系统Docker

Sat, 03 Jan 2026 00:00:00 +0000

本文是一篇过渡，在进行用例管理模块开发之前，有必要把入门篇开发完成的代码部署到Linux系统Docker中，把部署流程走一遍，这个过程对后端设计有决定性影响。

webdriver使用已打开过的chrome

Sat, 03 Jan 2026 00:00:00 +0000

基本功能：

代码覆盖率从0到100的入门实践

Sat, 03 Jan 2026 00:00:00 +0000

JaCoCo全称是Java Code Coverage，Java代码覆盖率，广泛运用于各种测试平台对Java代码的全量覆盖率和增量覆盖率进行统计，分析代码行差异，度量单元测试效果。Jacoco也是精准测试的技术实现手段之一。

关于FastAPI异步并发的技术背景和细节

Sat, 03 Jan 2026 00:00:00 +0000

FastAPI的路径操作函数，可以使用async def定义：

关于SpringBoot开发的更多细节

Sat, 03 Jan 2026 00:00:00 +0000

在上篇文章《开发你的第一个SpringBoot应用》已经对SpringBoot基本开发流程有了大体了解，本文将继续对SpringBoot官网进行学习，发现关于SpringBoot开发的更多细节。

基于HAR包的流量录制回放

Sat, 03 Jan 2026 00:00:00 +0000

什么是HAR包？

HAR（HTTP Archive format），是一种JSON格式的存档格式文件，通用扩展名为 .har。

HAR包是JSON格式的，打开后，重点关注entries里面的request和response，包含了请求和响应信息。

流量录制

怎么获取HAR包呢？可以网上搜索方法，浏览器F12、抓包工具（Charles、Proxyman等）都可以将HTTP请求导出为HAR包。

生产级别的流量录制很复杂，想要了解的话可以参考阿里开源项目：https://github.com/alibaba/jvm-sandbox-repeater

回放对比

本文重点介绍在导出HAR包后，怎么通过Python来实现回放对比。

使用介绍

一、将HAR包转换为pytest用例

har_file为har包路径，profile配置开启回放，调用Har.har2case()方法将HAR包转换为pytest用例。

转换后会生成：

demo_test.py 与HAR同名的pytest用例文件
demo-replay-diff 对比结果目录，暂时为空
sqlite.db 存储HAR包响应数据，标记为expect

二、执行pytest用例

from tep.libraries.Diff import Diff
from tep.libraries.Sqlite import Sqlite


def test(HTTPRequestKeyword, BodyKeyword):
    var = {'caseId': '023f387db398504889e0afb8dd1bc99d', 'requestOrder': 1, 'diffDir': '/Users/wanggang424/Desktop/PycharmProjects/tep/tests/demo/case/har/demo-replay-diff'}
    
    url = "https://postman-echo.com/get?foo1=HDnY8&foo2=34.5"
    headers = {'Host': 'postman-echo.com', 'User-Agent': 'HttpRunnerPlus', 'Accept-Encoding': 'gzip'}
    ro = HTTPRequestKeyword("get", url=url, headers=headers)
    # user_defined_var = ro.response.jsonpath("$.jsonpath")
    assert ro.response.status_code < 400
    Sqlite.record_actual((ro.response.text, var["caseId"], var["requestOrder"], "GET", "https://postman-echo.com/get?foo1=HDnY8&foo2=34.5"), var)
    
    url = "https://postman-echo.com/post"
    headers = {'Host': 'postman-echo.com', 'User-Agent': 'Go-http-client/1.1', 'Content-Length': '28', 'Content-Type': 'application/json; charset=UTF-8', 'Cookie': 'sails.sid=s%3Az_LpglkKxTvJ_eHVUH6V67drKp0AGWW-.PidabaXOnatLRP47hVyqqepl6BdrpEQzRlJQXtbIiwk', 'Accept-Encoding': 'gzip', 'sails.sid': 's%3Az_LpglkKxTvJ_eHVUH6V67drKp0AGWW-.PidabaXOnatLRP47hVyqqepl6BdrpEQzRlJQXtbIiwk'}
    body = r"""{"foo1":"HDnY8","foo2":12.3}"""
    ro = BodyKeyword(body)
    # ro = BodyKeyword(body, {"$.jsonpath": "value"})
    body = ro.data
    ro = HTTPRequestKeyword("post", url=url, headers=headers, json=body)
    # user_defined_var = ro.response.jsonpath("$.jsonpath")
    assert ro.response.status_code < 400
    Sqlite.record_actual((ro.response.text, var["caseId"], var["requestOrder"], "POST", "https://postman-echo.com/post"), var)
    
    url = "https://postman-echo.com/post"
    headers = {'Host': 'postman-echo.com', 'User-Agent': 'Go-http-client/1.1', 'Content-Length': '20', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'Cookie': 'sails.sid=s%3AS5e7w0zQ0xAsCwh9L8T6R7QLYCO7_gtD.r8%2B2w9IWqEIfuVkrZjnxzm2xADIk34zKAWXRPapr%2FAw', 'Accept-Encoding': 'gzip', 'sails.sid': 's%3AS5e7w0zQ0xAsCwh9L8T6R7QLYCO7_gtD.r8%2B2w9IWqEIfuVkrZjnxzm2xADIk34zKAWXRPapr%2FAw'}
    ro = HTTPRequestKeyword("post", url=url, headers=headers, data=body)
    # user_defined_var = ro.response.jsonpath("$.jsonpath")
    assert ro.response.status_code < 400
    Sqlite.record_actual((ro.response.text, var["caseId"], var["requestOrder"], "POST", "https://postman-echo.com/post"), var)

    Diff.make(var["caseId"], var["diffDir"])

执行时会记录实际请求响应，存入sqlite数据库，标记为actual。

接口自动化框架设计漫谈V1.0

Sat, 03 Jan 2026 00:00:00 +0000

针对“pytest搭建接口自动化框架”，谈谈对框架设计的当前认知。

开源测试平台开发期待你的加入

Sat, 03 Jan 2026 00:00:00 +0000

背景

在2022年7月6日我曾组织过一次开源测试平台开发报名，有50+人报名，到2023年1月28日项目暂停，如大家在Gittee看到的，除我以外，只有1个人真正提交了代码：奉孝。

原因如其中一位同学所说：“感觉我们大部份还是缺少从0到1的经验，负责的内容有时候不要知道从哪下手，又少了点积极性”。描述得很贴切，可能刚开始动力很足，但因为缺少经验，不够积极，最后实践不了。说的很好，就是做不到。也很无奈。

二次启动，分为2个阶段，第一个阶段是学习阶段，我带着大家一起把teprunner平台从0到1开发一遍，把需要掌握的知识先学一遍，保证有一定基础，挑战能够独立完成模块开发。第二个阶段是开发阶段，共同完成EasyPytest测试平台开发，学以致用，加深对前后端分离项目开发的理解，具有真实的平台开发实践。

学习阶段

你都不维护了，我为什么还要学teprunner？Django没意思？我想学FastAPI？

teprunner有一套完整教程，包括前后端源码、11篇电子书教程、2小时视频讲解，虽然我因为工作原因没有继续维护teprunner，但是它仍然非常适合初学者入门学习测试开发，掌握里面的知识，对于后续学习其他技术，都有很大帮助。我的技术提升除了二刷《流畅的Python》和编写了tep开源工具，最大的提升就是完成了teprunner测试平台开发，如果你也能自己动手完成一遍，一定有极大提升。

Django、Flask、FastAPI、SpringBoot，我认为从入门者角度来说，Django是最适合的，它属于开箱即用的框架，很多东西都给你准备好了，你用就行，避免刚开始就陷入环境搭建，三方库拼装、数据库维护的麻烦中，降低理解门槛和操作难度。学会了Django，再学其他的，也很简单，一通百通。刚开始学习，学哪个不是最重要的，最重要的是先学会一个，迈出第一步。以我的经验来说，学习成熟框架Django是个正确选择。

开发阶段

EasyPytest的后端把Django切换为了FastAPI，掌握了Django，再对比FastAPI，就能对后端开发框架有更深入的理解。就像我学Python和Java一样，只学一门百思不得其解，对比一看，豁然开朗。目前已经完成了登录、首页、用户管理的开发，Gitee也有相应源码。未来的规划，是做teprunner的升级版，实现pytest平台化，80%工作本地开发脚本，20%工作交给平台编排运行。

报名方式

添加微信cekaigang，备注参加平台开发，进群。

现开启学习阶段报名：

按需选择，10元/节，录播+直播集中答疑。报名后会获得一份录播+一次集中答疑直播+一个每节课源码。每节课源码跟GitHub上源码不同，只会包含当前这节课进度的源码，一步一步的看到测试平台是如何开发出来的。

课表链接： https://eqgvpqzl6c.feishu.cn/mindnotes/bmncndM8oei2B0MIFE1RMrGuKjd

开发阶段报名需至少参与一节学习课程，从优秀学员或积极学员中选择，时间另行通知。

当然，如果你已经具备奉孝这样的技术能力和积极性，欢迎直接与我联系，请提供你的开源项目地址或在Gitee提交Pull Requests，以证明能够独立完成模块开发，直接参与EP平台共建。

框架V2.0.0开发指南

Sat, 03 Jan 2026 00:00:00 +0000

温馨提示：开发指南，根据V2.0.0编写，不随版本更新维护，仅供入门参考。最新实现请结合教程和源码阅读，教程会在版本发布后维护。

幂等测试

Sat, 03 Jan 2026 00:00:00 +0000

连续调用两次，第一次提交成功，第二次会被驳回——串行重复，系统是防住了的。

刷完3个Java教程后不再犹豫

Sat, 03 Jan 2026 00:00:00 +0000

成年人最大的底气是你拥有一技之长，人生才不会被动。从事测试开发岗位，需要精通一门编程语言，是核心，是大招，是招牌技能。我内心一直在Java和Python之间选择，反复横跳。

我3个月没手写测试用例了，但我的用例采纳率是80%

Sat, 03 Jan 2026 00:00:00 +0000

编写测试用例，是我做测试工作最痛苦的一件事情，没有之一。最难受的是把测试点写成“标准”用例。先要写一个让人一目了然的用例标题，还要讲究什么主谓宾造句，曾经为了让标题好看，我还硬加“验证”2个字前缀。前提条件要把账号数据这些罗列出来。步骤要写清楚每一步干啥，预期也要具体化和量化，不能只写正确。文字写起来啰里啰嗦，写多了头都炸了。

一次全量数据对比工具发现问题的过程与思考

Sat, 03 Jan 2026 00:00:00 +0000

如果没有这次全量数据对比工具，那么也许这个历史问题会继续隐藏着，直到发生线上事故才暴露出来，毕竟人工抽样验证发现的概率只有5.8%。

用PyCharm打个专业的招呼

Sat, 03 Jan 2026 00:00:00 +0000

PyCharm 是什么

PyCharm（读作“拍恰姆”）是 JetBrains 全家桶中的一员，专门用来写 Python 的：

官方网址是：

https://www.jetbrains.com/pycharm/

for Professional Developers，顾名思义，它是为专业开发者而生的。

版本选择

PyCharm 有 2 个版本：

左边的 Professional 是专业版，需要付（ po ）费（ jie ）。右边的 Community 是社区版，永久免费。一般社区版够用了。我用的是专业版，看着齐全。

打开 PyCharm

安装完成后，打开：

不需要导入配置，点击 OK 按钮：

有 2 个主题，个人偏好左边这种，酷酷的。点击左下角 Skip Remaining and Set Defaults 跳过插件安装，进入主界面（专业版破解后才能看到这个界面，具体破解方法网上贼多）：

首次打开，还没有创建项目，会出现引导页。选择 New Project：

这是专业版的界面，社区版会简略一点。选择好存放目录后，还需要配置解释器。点击解释器右边的 ... ，切换到 System Interpreter，选择已经安装好的 Python：

OK 后再点击 Create，来了：

老手可以勾选 Tip of the Day 左小角 Don't show tips。

80道高频算法题Java版

Fri, 02 Jan 2026 00:00:00 +0000

80道常考算法题，逢考必过，剑指offer。

Android测试三件套：传文件、抓包、看日志

Fri, 02 Jan 2026 00:00:00 +0000

在对安卓进行测试时，我们需要把 apk 传到安卓机上，对请求抓包，同时监控应用日志。本文就来讲讲具体操作。

Claude Code使用技巧帮你提效80%

Fri, 02 Jan 2026 00:00:00 +0000

Claude Code是Anthropic公司的产品，跟字节的豆包、阿里的千问和腾讯的元宝一样，只不过它更擅长于跟代码打交道。用Claude Code来写代码，就是通常说的Vibe Coding，跟着感觉编程。

Django搭建示例项目实战与避坑细节

Fri, 02 Jan 2026 00:00:00 +0000

Django 开发项目是很快的，有多快？看完本篇文章，你就知道了。

FastAPI官方教程太棒了（下）

Fri, 02 Jan 2026 00:00:00 +0000

响应状态码

在@app.post()方法中添加status_code参数：

from fastapi import FastAPI

app = FastAPI()


@app.post("/items/", status_code=201)
async def create_item(name: str):
    return {"name": name}

status_code也可以是IntEnum，比如Python的http.HTTPStatus。

常见响应状态码：

100以上，信息；很少直接使用；
200以上，成功；200是OK，201是Created，204是No Content；
300以上，重定向；304是Not Modified；
400以上，客户端错误；404是Not Found；
500以上，服务器错误；

FastAPI引入了status，可以方便的录入这些状态：

from fastapi import FastAPI, status

app = FastAPI()


@app.post("/items/", status_code=status.HTTP_201_CREATED)
async def create_item(name: str):
    return {"name": name}

表单数据

为了使用表单，首先需要安装python-multipart：

pip install python-multipart

示例：

from fastapi import FastAPI, Form

app = FastAPI()


@app.post("/login/")
async def login(username: str = Form(), password: str = Form()):
    return {"username": username}

表单由HTML中的<form></form>发送，请求头的content-type一般是application/x-www-form-urlencoded，当为文件时multipart/form-data。

请求文件

示例：

from fastapi import FastAPI, File, UploadFile

app = FastAPI()


@app.post("/files/")
async def create_file(file: bytes = File()):
    return {"file_size": len(file)}


@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):
    return {"filename": file.filename}

create_file()的类型为bytes，接收到的文件内容也是bytes，数据都存在于内存中，适用于小文件。create_upload_file()的类型为UploadFile，它会在内存设置一个最大存储，超出最大存储，就会把数据转存到磁盘，适用于大文件。

HttpRunner3的HTTP请求是怎么发出去的

Fri, 02 Jan 2026 00:00:00 +0000

在HttpRunner3的示例代码中，发送HTTP请求的代码是这样写的：

JavaWeb开发基础Servlet简介

Fri, 02 Jan 2026 00:00:00 +0000

Servlet是什么？

现在的Java Web开发，很少直接接触到Servlet。在Spring项目中，Spring Boot基于Spring Framework，简化了Spring应用程序开发，Spring Framework是一个全面的Java应用程序框架，其中包含Spring MVC模块，Spring MVC封装了Servlet，以实现Web功能。Servlet不属于Spirng项目，而是Java EE（后改名为Jakarta EE）的一部分。

Servlet可以有很多种描述：

Servlet是一个技术，用来创建Web应用程序
Servlet是一个API，提供了很多接口、类和文档
Servlet是一个接口，必须实现该接口来创建Servlet
Servlet是一个类，位于服务端，接收请求，返回响应
Servlet是一个Web组件，用来创建动态Web页面

CGI与Servlet

在Servlet技术出现以前，Web应用程序是通过CGI（Common Gateway Interface），一种脚本语言，来实现的。

但是CGI存在很多缺点：

如果客户端增多，服务端响应会变慢
对于每个请求，CGI都会创建一个进程，进程数有限
依赖C、C++、perl等编程语言

Servlet技术出现以后，解决了很多CGI问题：

性能：每个请求创建一个线程，而不是进程
可移植性：因为使用了Java语言
健壮性：JVM管理Servlet，无需关心内存泄漏、垃圾回收等
安全性：因为使用了Java语言

总的来说，Servlet是Server Applet，服务端小程序。它是单例多线程的，每个Servlet类在Web容器中只有一个实例，每次客户端请求，Web Server都会从线程池中分配一个线程去创建Servlet，每个请求由一个独立的线程处理，这些线程共享同一个Servlet实例，通过HTTP协议接收和响应来自Web Client的请求。

Java高级编程精华笔记

Fri, 02 Jan 2026 00:00:00 +0000

学习路线

本文是Java高级编程精华笔记，是对菜鸟教程中Java面向对象和Java高级编程的重要章节进行了学习，整理形成的学习笔记，知识图谱如下图所示：

如果想对Java深入学习，可以参考阿里巴巴的技术图谱：

https://developer.aliyun.com/graph/java

继承

Java使用extends关键字来声明继承：

class 父类 {
}

class 子类 extends 父类 {
}

示例，子类企鹅和子类老鼠继承父类动物：

//父类：动物
public class Animal {
    private String name;
    private int id;

    public Animal(String myName, int myid) {
        name = myName;
        id = myid;
    }

    public void eat() {
        System.out.println(name + "正在吃");
    }

    public void sleep() {
        System.out.println(name + "正在睡");
    }

    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}

//子类：企鹅
public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

//子类：老鼠
public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

Java只支持单继承，不支持多继承，但可以多重继承：

JMeter是如何运行施压的

Fri, 02 Jan 2026 00:00:00 +0000

运行文件

JMeter下载地址为：

https://jmeter.apache.org/download_jmeter.cgi

最新版本为5.4.1，依赖于Java8+，下载后无需安装，解压即用。解压后的目录和文件如下：

bin 二进制文件目录，包括配置文件、启动文件、启动jar包、示例脚本。比如Windows和Linux系统的两个启动脚本：

docs API离线帮助文档。
extras 辅助功能，可用于Ant、Jenkins集成。
lib lib根目录下存放JMeter基础jar包，lib/ext目录下存放第三方或自定义扩展jar包。
licenses 证书文本文件。
printable_docs 离线帮助文档。
LICENSE 证书说明。
NOTICE 版权声明。
README 简介。

测试计划

JMeter以图形界面方式启动后，首先映入眼帘的是左侧的TestPlan，测试计划：

JMeter的UI界面只能同时编辑一个测试计划，如果想再编辑另外一个测试计划，必须再打开一个JMeter界面。这是因为测试计划对应的是.jmx文件！不同的.jmx文件只能在不同的界面中编辑。

JMeter界面是通过组件拖拽的方式来编写脚本的，脚本的根目录是测试计划。根节点只能有一个，作为根节点，测试计划很适合来做全局配置，比如在User Defined Variables处添加键值对格式的全局变量。

测试计划是默认节点，JMeter还有另外一个不可缺少的次节点：Thread Group，线程组。

多线程

性能测试工具的目的是用少量电脑产生成百上千个并发请求。多进程和多线程正好能用来实现这个需求，书上有句关于进程和线程的至理名言：“进程是操作系统分配资源的最小单位，线程是程序执行的最小单位”。该如何理解呢？前一句的意思是说，每个应用程序都有对应的进程，按照进程来分配资源，可以使得资源利用最大化，避免浪费。后一句的理解得从一个故事讲起，很久以前，进程拿着资源找CPU执行。CPU一看进程太大，说我处理不了。进程只能拆成多个线程给CPU，不但能执行了，还能在线程之间灵活切换。

多进程和多线程都可以用来模拟并发请求。JMeter是用Java语言写的程序，运行在JVM虚拟机之上，进程的开销比线程大很多，JVM为了保证足够性能，控制了进程的数量。如果用多线程，单台电脑能提供了负载有限，那么就只能用多线程。JMeter只支持多线程！

用户即线程

JMeter除了Thread Group，其他地方都是用的另外一个词：User。实际上它们是一个意思，用户就是线程。JMeter的运行原理就是用多个线程来模拟多个用户！以下是简单示例：

从图中可以看出，有两个线程组，Thread Group 1和Thread Group 2，它们分别定义了自己组内的用户要做的事情。不同线程组做的事情是不一样的，但是同一线程组内部做的事情是一模一样的。我们在写JMeter脚本的时候，实际上是在定义每个用户要做哪些事。当运行脚本的时候，JMeter会启动多个线程，都来执行这个脚本，按照我们写的进行执行。

远程运行

一台机器提供了线程数量有限，如果想要施压更大的并发，那么就需要多台机器。JMeter天然支持多台机器并发：

控制机和负载机本质上没有区别，同一台机器既可以做控制机，也可以做负载机，取决于你的负载设计。控制机的作用是管理多台远程负载机，控制远程负载机脚本运行，收集远程负载机测试结果。负载机是实际产生并发的机器，它们向被测应用系统发起负载。

运行逻辑如下：

远程负载机启动Agent客户端，等待控制机连接。
控制机连接上远程负载机。
控制机发送指令到远程负载机启动线程。
远程负载机运行脚本，回传结果数据。
控制机收集结果并显示。

操作步骤如下：

远程负载机启动jmeter-server.bat。
在控制机bin\JMeter.properties文件中，修改remote_hosts，添加远程负载机的ip和port，多个远程负载机ip 用逗号分隔，如remote_hosts=192.168.0.1:1664,192.168.0.2:1664。1664是默认RMI端口号（Remote Method Invocation，远程方法调用）。
在控制机菜单栏Run执行Remote命令：

小结

本文先从JMeter运行文件讲起，启动后默认有测试计划，建线程组，线程即用户，用多线程来模拟多用户，这就是JMeter运行起来施压的原理。为了解决单台机器负载能力有限的问题，JMeter还提供了远程运行方式，既可以在局域网用多台机器来控制，也可以部署到云服务器上，进行云压测。

JUnit5注解学习指引

Fri, 02 Jan 2026 00:00:00 +0000

注解（Annotations）是JUnit的标志性技术，本文就来对它的20个注解，以及元注解和组合注解进行学习。

Postman竟然还能录制流量

Fri, 02 Jan 2026 00:00:00 +0000

大家好，我是刚哥。

pytest132个命令行参数用法

Fri, 02 Jan 2026 00:00:00 +0000

在Shell执行pytest -h可以看到pytest的命令行参数有这10大类，共132个

pytestx重新定义接口框架设计

Fri, 02 Jan 2026 00:00:00 +0000

概览

脚手架：

用例代码：

"""
测试登录到下单流程，需要先启动后端服务
"""

test_data = {
    "查询SKU": {
        "skuName": "电子书"
    },
    "添加购物车": {
        "skuId": 123,
        "skuNum": 2
    },
    "下单": {
        "orderId": 222,
        "payAmount": "0.2"
    },
    "支付": {
        "skuId": 123,
        "price": 0.1,
        "skuNum": 2,
        "totalPrice": 0.2
    },
}
case_vars = dict()


def test(http, login_headers, file_data):
    # 搜索商品
    url = file_data["domain"] + "/api/tasks/mock/searchSku"
    body = test_data["查询SKU"]

    response = http("get", url=url, headers=login_headers, params=body)
    assert response.status_code < 400

    case_vars["skuId"] = response.jsonpath("$.skuId")
    case_vars["skuPrice"] = response.jsonpath("$.price")

    # 添加购物车
    url = file_data["domain"] + "/api/tasks/mock/addCart"
    body = test_data["添加购物车"]
    body["skuId"] = case_vars["skuId"]

    response = http("post", url=url, headers=login_headers, json=body)
    assert response.status_code < 400

    case_vars["skuNum"] = response.jsonpath("$.skuNum")
    case_vars["totalPrice"] = response.jsonpath("$.totalPrice")

    # 下单
    url = file_data["domain"] + "/api/tasks/mock/order"
    body = test_data["下单"]
    body["skuId"] = case_vars["skuId"]
    body["price"] = case_vars["skuPrice"]
    body["skuNum"] = case_vars["skuNum"]
    body["totalPrice"] = case_vars["totalPrice"]

    response = http("post", url=url, headers=login_headers, json=body)
    assert response.status_code < 400

    case_vars["orderId"] = response.jsonpath("$.orderId")

    # 支付
    url = file_data["domain"] + "/api/tasks/mock/pay"
    body = test_data["支付"]
    body["orderId"] = case_vars["orderId"]

    response = http("post", url=url, headers=login_headers, json=body)
    assert response.status_code < 400
    assert response.jsonpath("$.success") == "true"

页面下载脚手架

启动平台前后端服务后，从页面下载脚手架，平台会拉取开源项目tep-project最新代码，打成压缩包，生成下载文件，弹窗下载。

Python微型Web框架Flask快速入门

Fri, 02 Jan 2026 00:00:00 +0000

Flask是什么

如果说Django是一个开箱即用的自带完善功能的Web框架，那么Flask就是一个只提供基础结构的微型框架。这一点从它的GitHub源码就能看出端倪：

它的核心代码就只有这么多。微型意味着Flask本身只提供了简单的核心的功能，但它具备了强大的可扩展性。比如，它不会强制你使用某个ORM框架，而是把选择权交给你，让你自己决定集成哪个扩展。

无论如何，都应该学习一下Flask，因为它让你从零开始，了解一个Web框架是如何诞生的：

安装Flask

Flask需要Python3.6及以上才能使用，最新的async异步支持需要Python3.7及以上。

安装Flask前可以先创建一个虚拟环境，这样相关的包都放在这个虚拟环境中。

Mac用户：

## 创建
$ mkdir myproject
$ cd myproject
$ python3 -m venv venv
## 激活
$ . venv/bin/activate

Windows用户：

## 创建
> mkdir myproject
> cd myproject
> py -3 -m venv venv
## 激活
> venv\Scripts\activate

然后就通过pip安装Flask即可：

$ pip install Flask

Hello World

Flask是一个Web框架，更准备的说是一个提供接口的后端服务，只需要5行代码就能实现一个接口：

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

截止到目前，还没见过哪个Web框架是这么玩的，有点颠覆对Web框架的认知，印象中的Web框架都是有点庞大的，Flask却很轻巧的就实现了。

运行后会在控制台输出：

> set FLASK_APP=hello
> flask run
 * Running on http://127.0.0.1:5000/

浏览器访问http://127.0.0.1:5000/就会看到Hello, World!字样。

tep用户手册帮你从unittest过渡到pytest

Fri, 02 Jan 2026 00:00:00 +0000

unittest和pytest是Python的2个强大的测试框架，经常用来做UI自动化或接口自动化。unittest是PyCharm的默认集成工具，也是我们大多数人入门自动化的首选框架。pytest提供了更丰富的功能，相对的上手难度也要高一点。如果学了pytest后，想快速用pytest写项目，用于工作实践，那么可以试试我写的这款测试工具：tep，try easy pytest。

代码评审，揭示黑盒背后的真相

Fri, 02 Jan 2026 00:00:00 +0000

一、引言

黑盒测试犹如案发现场，只能根据表象推断事件经过。

代码评审即深入调查，挖掘蛛丝马迹的线索，揭示背后的真相。

“They think I am hiding in the shadows, but I am the shadows.”

二、黑盒测试与白盒测试的区别

黑盒测试存在一些局限性：

可能无法发现与系统实现相关的问题
可能无法覆盖所有的测试场景
测试效率较低，比如准备物料、模拟场景
强依赖需求文档，如果文档不全，测试会漏

对于测试人员来说，可以在代码评审阶段，通过白盒测试改进测试的质量和效率。

三、代码评审的定义和意义

代码评审，Code Review（CR），是一种通过检查代码来提高代码质量的过程。

对于测试人员来说，参与代码评审，可以尽量提前发现问题，减少修复代价，提高效能。

四、代码评审的形式

多人讨论

组织会议，研发牵头讲解代码，架构和测试参与，讨论交流。这是最普遍的一种形式。

Code Diff

查看Code Diff，可以借助Gitlab或IDEA，比较分支差异或版本差异。

对比时机：

提测前和测试中，自行走查代码
发现缺陷，定位代码原因
修复缺陷后，评估影响范围
上线前，是否夹带代码

精准测试

评估测试用例的代码覆盖率，查漏补缺，Jacoco的on-the-fly模式支持动态收集代码覆盖率数据。

五、代码评审的方法

面向业务，面向业务，面向业务。重要的事情说三遍。

刚开始做代码评审，很容易把注意力集中在找代码规范问题上面，比如命名不规范、注释不清楚、代码实现冗长等。这些问题不是测试人员关注的重点，需要由研发团队或代码扫描工具来解决。

在做Code Diff时，也没必要把每个文件、每行代码的意思搞懂，比如研发对代码结构做了调整，在diff时要梳理清楚的话，ROI会非常低，因为既消耗时间，又发现不了问题。

那该怎么做代码评审呢？ 关注业务：

跟需求文档比较，哪些需求是遗漏的，哪些代码是补充的，哪些代码是夹带的
关注核心业务代码逻辑，使用条件覆盖、路径覆盖等方法设计测试用例
优化测试用例，针对代码实现考虑异常、边界、幂等、并发等场景

代码评审要求测试人员具备代码能力，理解编程语言，掌握软件设计，熟悉代码结构和架构，多与开发同学交流，共同优化代码质量。

六、代码评审的实际案例

1、空指针异常

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final SqlSessionTemplate sqlSessionTemplate;
    
    @Autowired
    public UserService(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }
    
    public void getUserById(String userId) {
        User user = sqlSessionTemplate.selectOne("com.example.mapper.UserMapper.getUserById", userId);
        System.out.println(user.getName()); // 可能导致空指针异常
    }
}

如果取到的 user 对象为空，就会导致空指针异常。

多线程简单斗地主

Fri, 02 Jan 2026 00:00:00 +0000

多线程，通道，读写锁（单写多读），随机（洗牌），是本文涉及的主要知识点。

功能测试用例自动生成算法Pairwise工具

Fri, 02 Jan 2026 00:00:00 +0000

Pairwise算法是什么

对于以下测试场景：

浏览器：M，O，P
操作平台：W（windows），L（linux），i（ios）
语言：C（chinese），E（english）

该如何设计功能测试用例呢？

根据数学统计分析，73%的缺陷（单因子是35%，双因子是38%）是由单因子或2个因子相互作用产生的。19%的缺陷是由3个因子相互作用产生的。也就是说，大多数的bug都是条件的两两组合造成的。

Pairwise算法是L. L. Thurstone在1927年首先提出来的，他是美国的一位心理统计学家。Pairwise算法基于两两组合，过滤出性价比高的用例集。它的思路是：如果某一组用例的两两组合结果，在其他组合中均出现，就删除该组用例，从而精简用例。

对于上述测试场景，可以通过笛卡尔积设计18条两两组合的测试用例：

1，M W C
2，M W E
3，M L C
4，M L E
5，M I C
6，M I E
7，O W C
8，O W E
9，O L C
10，O L E
11，O I C
12，O I E
13，P W C
14，P W E
15，P L C
16，P L E
17，P I C
18，P I E

对于第18条用例P I E来说，两两组合是PI ，PE ，IE，PI在17号，PE在16号，IE在12号出现过，所以第18条用例可以过滤掉。按照这个算法继续过滤，最终剩下9条用例：

坚持开发原创测试平台

Fri, 02 Jan 2026 00:00:00 +0000

不管测试平台有没有实际用处，具备测试平台开发能力，是测试开发工程师的必备技能之一。 测试平台的实际收益有多少，仁者见仁智者见智，这是一个辩证问题。测试平台开发能力是否具备，一清二楚，这是一个现实问题。我们能做的只有提高自己，解决现实问题。

接口设计的可测试性

Fri, 02 Jan 2026 00:00:00 +0000

错误码不分层的接口，你只能靠 msg 断言，改个文案用例就跑失败。返回快照的字段返回了实时，数据就无法核对上。

接口自动化框架选型

Fri, 02 Jan 2026 00:00:00 +0000

选择技术栈。Python、Java、Go三选一。能选Python就选Python。只会Java或只会Go才选Java Go。Python语法简单，上手容易，有一整套成熟的接口自动化测试方案，社区完善且持续迭代更新。

开发你的第一个SpringBoot应用

Fri, 02 Jan 2026 00:00:00 +0000

创建SpringBoot项目最便捷的方式一是在https://start.spring.io/根据步骤选择后，下载项目工程压缩包：

理想中的接口自动化项目

Fri, 02 Jan 2026 00:00:00 +0000

如何评价接口自动化项目

我理想中的接口自动化项目，是有一套脚本，能够100%覆盖核心业务场景，能够回归线上频繁出现的问题，能够支持手工无法验证的场景，能够抛出偶现问题，能够包含容易遗漏的边界场景、异常场景，每天都能定时运行，出具报告，给予反馈。

用实际的指标量化下：

功能测试自动化率 = 自动化测试用例数/总测试用例数
自动化发现bug占比 = 自动化发现的bug/总bug数
自动化发现bug有效性 = 自动化发现的有效bug/自动化提交的bug总数
自动化执行成功率 = 自动化执行成功的次数/自动化执行总次数
周活跃自动化用例占比 = (∑每周执行过的自动化测试用例)/(∑周维度自动化测试用例)
应用维度自动化代码覆盖率 = 自动化用例覆盖代码行数/应用维度代码总行数

现状是什么(Situation)

我负责的业务是发票中台，数据流简化后如下图所示：

发票中台对调用方提供RPC服务，底层有读写MySQL、同步ES、消息队列、异步任务等服务，上游是用户和订单，需要账号、增票资质、订单等物料；下游是财务，推送申请单给财务开具发票等。

发票的接口自动化在多年前是写了的，用Java+TestNG+RPC本地化了一套框架来实现，因为人员离职和业务变更，这套自动化到我手上的时候，已经不能用了，本地化的接口自动化项目也无法做数据度量，只有接口测试平台写的自动化用例才会被统计到。

任务是什么(Task)

我给自己定的绩效是在Q2完成95条自动化用例，按照一个标准化的自动化项目来实现发票的接口自动化，结合测试环境、测试物料、流水线、精准分析，打造一个个人的稳定的沉淀物，无论是晋升还是求职，都能拿来讲点故事。

行动是什么(Action)

编写自动化用例的方式

1、最理想的方式，是能够录制线上流量直接转换为自动化用例，修修改改即可。虽然我们有流量录制回放平台，但是它跟接口自动化平台并没有打通，很可惜不能采取这种方式。

2、参考线上流量日志，抓取接口、入参，人工转化为自动化用例。

3、参考接口的代码设计，比如controller/provider/sdk都定义了应用接口，能知道哪些覆盖到了，哪些还需要补充。

4、根据入参模板自行构造参数。参数个数太多的话造起来很麻烦。

我主要采用第2种和第3种方式结合来编写自动化用例。

典型自动化用例

前置步骤：初始化数据，将订单发票类型更新为3。

预设变量：提供参数化数据。

执行步骤：调用修改订单发票类型接口，将发票类型3改为2，入参引用预设变量。

财务接口：依赖测试物料无法满足，通过Mock来返回模板数据，让接口继续往下走。

基础断言：接口响应状态码200。

业务断言：调用订单列表查询接口，用JSONPath提取响应中的发票类型，断言已经改成了2。

场景用例

数据准备：通过物料工具造订单数据，写入MySQL数据库中。

更新MySQL数据：更新订单的部分字段数据，触发binlake，将数据同步至ES，因为提交开票申请是读取的ES数据；从预设变量获取orderId。

提交开票申请：从ES读取订单数据，提交开票申请；从预设变量获取orderId和userId。

查询申请单号：根据订单号查询申请单号；从预设变量获取orderId和userId。用JSONPath提取申请单号，存入动态变量中。

推送财务：把申请单号推送给财务；从动态变量获取applyId。

覆盖更多代码

①看代码：

在Java工程里面的Controller/Provider找到所有接口，分析可以用来做自动化的接口，设计自动化用例进行覆盖。

②代码覆盖率：

借助于jacoco，在执行自动化用例后，把代码覆盖率跑出来，分析没覆盖的代码，补充更多正常/异常/边界的自动化用例。也就是精准测试。

自动化巡检

每天早上8点，定时任务执行用例集；发送邮件，抄送测试组、开发组、领导，让测试、开发和领导都知道自动化建设情况；如果出现问题，一定要在当天解决，并邮件回复问题原因；确保当天的自动化用例结果都是正确的；第二天接着继续巡检。

流水线

在持续集成中，引入自动化用例环节，把自动化用例跑通作为提测卡点，不通过可以驳回。

产出是什么(Result)

定性来看：

结合测试环境、测试物料、自动化、流水线、精准测试，完成了一个能对环境和业务进行稳定性巡检，能对研发提测进行质量门禁，能对应用进行代码覆盖率分析的接口自动化项目。

定量来看：

功能测试自动化率 = 自动化测试用例数/总测试用例数 95/100=95%
自动化发现bug占比 = 自动化发现的bug/总bug数 2/53=3.7%
自动化发现bug有效性 = 自动化发现的有效bug/自动化提交的bug总数 2/2=100%
自动化执行成功率 = 自动化执行成功的次数/自动化执行总次数 5396/5621=96%
周活跃自动化用例占比 = (∑每周执行过的自动化测试用例)/(∑周维度自动化测试用例) 77%
应用维度自动化代码覆盖率 = 自动化用例覆盖代码行数/应用维度代码总行数 39%

这个Q主要完成了核心流程和重要接口的自动化用例，还需要持续补充场景用例和异常/边界的自动化用例。

免费搭建你的电子书网站（附源码）

Fri, 02 Jan 2026 00:00:00 +0000

电子书网站由AI实现，Claude Code+DeepSeek-V4-Pro。技术栈Python+MkDocs，主题Read the Docs，静态托管GitHub Pages。具有中文搜索功能。

为什么Kafka这么快

Fri, 02 Jan 2026 00:00:00 +0000

Apache Kafka是一个开源的分布式事件流处理平台，主要用于高性能数据管道、流式分析、数据集成和关键任务应用。

学习版pytest内核测试平台开发万字长文入门篇

Fri, 02 Jan 2026 00:00:00 +0000

前言

2021年，测试平台如雨后春笋般冒了出来，我就是其中一员，写了一款pytest内核测试平台，在公司落地。分享出来后，有同学觉得挺不错，希望能开源，本着“公司代码不要传到网上去，以免引起不必要麻烦”的原则，只能在家从头写一个，边重新梳理代码边温习巩固知识点，以学习交流为目的，定义为“学习版”。

功能展示

接口自动化

接口自动化–Dashboard：

接口自动化–环境变量：

接口自动化–fixtures：

接口自动化–用例管理：

接口自动化–用例管理–编辑用例：

接口自动化–测试计划：

接口自动化–语法说明：

小工具

小工具–共享脚本：

小工具–HTTP状态查询：

后台管理

后台管理–用户管理

后台管理–项目管理

本文开发内容

登录，登出
首页，修改密码，个人信息
后台管理，用户管理
JWT认证

本文先打个基础，既是测试平台基本结构，也可以作为CMS基础框架，定制开发各种小型项目。

技术栈

Node.js 12.16.3
Vue 4.5.11
Python 3.8
Django 3.1.3
Django REST framework 3.12.2
SQLite 3

IDE编辑器推荐PyCharm旗舰版，既能写Django也能写Vue项目。数据库使用Django自带SQLite ，省去安装MySQL和Navicat/Workbench麻烦，轻量级开发。SQLiteStudio为SQLite数据库可视化工具，只需要下载即可，无需安装，解压就用：：

https://sqlitestudio.pl/

由于会用到models.JSONField，SQLite默认不兼容，所以需要下载sqlite3.dll文件替换下：

https://www.sqlite.org/download.html

根据Python版本选择，比如我的windows安装的Python38-32，下载了sqlite-dll-win32-x86-3340100.zip这个软件包，解压后将D:\Program Files (x86)\Python38-32\DLLs\sqlite3.dll替换。

创建Vue项目

设置npm淘宝镜像：

npm config set registry https://registry.npm.taobao.org

安装Vue CLI：

npm install -g @vue/cli

创建teprunner-frontend项目：

一文搞懂Cookie,Session,Token,JWT

Fri, 02 Jan 2026 00:00:00 +0000

HTTP协议是无状态的，无状态意味着，服务器无法给不同的客户端响应不同的信息。这样一些交互业务就无法支撑了。Cookie应运而生。

真香，理解记忆法学习Python基础语法

Fri, 02 Jan 2026 00:00:00 +0000

这篇文章很难写！我最开始学 Python，和大多数人一样，是看的菜鸟教程：

5分钟轻松学正则表达式

Thu, 01 Jan 2026 00:00:00 +0000

正则表达式是什么？

正则表达式，是一个表达式，用少量的简单字符，来表示复杂的长字符串。

实际工作用到很多，比如日志搜索、查找替换、JMeter 响应数据提取等。

先看一个例子，用户名包含字符、数字、下划线和连字符，并限制字符的个数：

这个表达式可以接受 john_doe、jo-hn_doe、john12_as，但是无法匹配到 Jo，因为它包含了大写的字母而且太短了。

字符匹配

正则表达式之所以强大，是因为通过一些特殊字符，能让它匹配到更多字符串。

表达式`.`

匹配任意单个字符除了换行符。

例：.ar => The car parked in the garage.

表达式`[]`

字符集。匹配方括号内的任意字符。并且字符是无先后顺序的。

例：[Tt]he => The car parked in the garage.

方括号的句号就表示句号。

例：ar[.] => A garage is a good place to park a car.

表达式`[^]`

否定的字符集。匹配除了方括号里的任意字符。

例：[^c]ar => The car parked in the garage.

表达式`*`

匹配 >= 0 个重复的在 * 号之前的字符。

例：a* => babaa123.

例：[a-z]* => The car parked in the garage #21.

AI测试工具开发新姿势MCP Python SDK

Thu, 01 Jan 2026 00:00:00 +0000

简介

MCP是什么？通俗易懂地讲，在互联网时代，应用程序是通过HTTP来交互的，而来到AI时代，大模型可以通过MCP来进行交互。MCP是Model Context Protocol缩写，专为大模型（LLM，Large Language Model）设计的大模型上下文协议。

MCP Server是什么？MCP Server就像网关之于应用程序，数据库连接池之于数据库，位于中间位置，接收请求，调用大模型。可以调用Server进行业务开发，也可以自建Server实现特定功能。

MCP Python SDK是什么？MCP的Python实现，它包含以下功能（官方原文）：

Build MCP clients that can connect to any MCP server
Create MCP servers that expose resources, prompts and tools
Use standard transports like stdio, SSE, and Streamable HTTP
Handle all MCP protocol messages and lifecycle events

安装

推荐使用uv工具来管理Python项目。

安装3.10以上版本Python：

uv python install 3.10

创建示例项目：

uv init mcp-server-demo
cd mcp-server-demo

创建虚拟环境：

uv venv
### 如果当前不是默认Python3.10，需指定版本
uv venv --python 3.10

执行后会提示：

Creating virtual environment at: .venv
Activate with: source .venv/bin/activate

激活：

CodeReview技巧和规范

Thu, 01 Jan 2026 00:00:00 +0000

What-什么是CodeReview？

CodeReview，即代码评审，是白盒测试中，静态测试的一种方法，通过阅读代码，提出代码层面的缺陷。

Why-为什么做CodeReview？

测试左移：在测试前就发现代码缺陷。

明确测试范围：根据需求文档和代码，对齐测试范围，防止研发夹带本次需求范围外的代码上线。

提升代码能力：学习研发优秀的编程技术。

深入原理：了解系统内部结构及实现。

发现隐藏缺陷：能发现某些极端场景下的问题或概率性问题。

减少测试研发周期占比：节省用例执行个数，尤其多个同类异常梳理，不用执行类似用例，CodeReview一行代码即可。

Who-谁适合做CodeReview？

CodeReview需要三大门槛：

①熟悉编程语言，Java/Python/Go等。

②熟悉编程规范，《阿里巴巴XXX编码规范》、《华为XXX编码规范》、《京东XXX编码规范》。

③了解需求、架构和设计，需求文档/架构图/设计文档。

达到门槛才适合做CodeReview。

When-什么时候做CodeReview？

提测前，通过Code Diff Review，自己走读代码或者参与研发代码评审会议均可，

发现功能缺陷时，通过走查代码定位代码原因，并分析是否有关联缺陷。

修复缺陷时，阅读研发commit记录，检查是否引入新缺陷。

上线前，通过merge范围检查是否有夹带代码，为了测试改动的临时代码是否恢复。

Where-在哪里做CodeReview？

线上仓库（如Gitlab），适合于修改点单一，不需要查看上下文信息就能找到缺陷。直接在网页端评审代码且发表comment。

本地仓库（如IDEA），适合于修改点较多，需要查看上下文信息（变量或方法跳转到定义或使用之处）。在本地找到缺陷后在线上发表comment。

How-CodeReview如何上手？

准备：了解需求、架构和设计；学习编程语言；学习代码规范；

实践：坚持CodeReview，记录缺陷，定期总结。如果看代码找缺陷比较困难，可以先从发现功能缺陷后，定位代码原因入手。

常见CR缺陷：

除数为0、整数溢出、精度损失；

可能死循环；

在finally程序块中关闭或者释放资源；

异常未处理或提示不明确（没有catch异常，集合等没有判空和长度为0）；

公式计算错误；

字符串对比不能用==，使用equals；

数组可能越界；

传递引用错误；

类型转换错误；

条件范围选择错误；

重点检查项：

一致性检查：是否需求相关；是否和方案设计一致；代码风格、日志规范、异常处理等是否和统一规范一致；

完整性检查：服务层是否包含了所有业务功能；数据层是否包含所有需要的数据和操作；

正确性检查：计算逻辑等业务逻辑是否正确；变量是否被正确定义和使用；代码是否符合制定的标准；

可修改性检查：代码涉及到常量是否易于修改，比如使用配置，定义为常量类等；建议业务方法只有一个出口和一个入口（异常处理除外）；重要公共方法是否有交叉注释说明；重要的对外方法修改后影响多个下游接口；

可预测性检查：变量初始化；方法稳定性；代码是否存在死循环；代码无穷递归检查；

健壮性检查：代码是否采取措施避免运行时错误（如数组边界溢出、被零除、值越界、堆栈溢出等）

高可用性检查：是否有预案（降级开发、限流配置、兜底策略）；补偿方案是否合理；

结构性检查：程序的每个功能是否都作为一个可辨识的代码块存在；

可理解性检查：是否使用到不明确或不必要的复杂代码；代码中的算法是否符合开发文档中描述的数学模型；每个变量都定义了合法的取值范围；

可验证性检查：代码功能是否便于测试；单元测试覆盖度是否足够；

可追溯性检查：代码是否包括一个修订历史记录，记录中对代码的修改和原因都有记录；

编码规范：

《阿里巴巴Java开发手册》

最新版本：黄山版（2022.2.3发布）

https://github.com/alibaba/p3c

Django匆匆一眼却解答了多年疑惑

Thu, 01 Jan 2026 00:00:00 +0000

Django 是 Python 的一款 Web 开发框架，另外还有 Tornado，Flask，Twisted。为什么我要选择学 Django？原因很简单，上家公司来了个网易的测开，就是用 Django 开发的测试平台。

EasyPytest测试平台开发日志之系统设计

Thu, 01 Jan 2026 00:00:00 +0000

EasyPytest测试平台，帮你高效管理Pytest测试用例。

FastAPI官方教程太棒了（上）

Thu, 01 Jan 2026 00:00:00 +0000

Python第三流行的Web框架

在2020年的Python开发者调查结果中，有这样一段话：“FastAPI在此次调查迭代中首次被引为选项，表现为Python第三流行的Web框架。”

FastAPI创立于2018年12月，不到2年就成为仅次于Flask和Django的第三流行的Web框架。而又经过了一年发展来到2022年，虽然2021年Python开发者调查结果还没有出来，但是从GitHub的star来看，Flask 58.7k，Django 63.6k，FastAPI 44.2k，这个差距缩得越来越小。

FastAPI特性

这里就不做机器翻译了，大家看下原文：

我说下我选择FastAPI的理由：首先就是HttpRunner集成了FastAPI，有大佬背书，相信这个框架足以优秀。其次是注解，用多了SpringBoot以后，越来越喜欢注解，层次清晰。对于前后端分离项目来说，Flask虽然非常精简却又自带了Jinja模板引擎，Django虽然是百宝箱却又显得太重，而FastAPI介于两者之间，就是一个纯粹的后端应用。并且FastAPI是基于Starlette框架的，集成了实用功能比如类型检查、OpenAPI（Swagger）等等，这跟我基于pytest框架做tep测试工具的理念很相似。

安装

对Python版本要求是3.6+。

先安装FastAPI：

pip install fastapi

再安装ASGI服务器，比如Uvicorn：

pip install "uvicorn[standard]"

也可以同时安装fastapi和uvicorn：

pip install "fastapi[all]"

运行

写个main.py文件：

from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}

在命令行输入启动应用：

uvicorn main:app --reload

main是Python模块名。

app是app = FastAPI()。

--reload在代码变化时自动重启服务器。

打开浏览器访问：

http://127.0.0.1:8000/items/5?q=somequery

就能看到JSON响应：

{"item_id": 5, "q": "somequery"}

访问：

http://127.0.0.1:8000/docs

就能看到Swagger接口文档：

pydantic

pydantic是一个数据验证的库，FastAPI使用它来做模型校验。比如：

Flask一分钟Mock一个API

Thu, 01 Jan 2026 00:00:00 +0000

如果安装了Python，并且安装了Flask：

HttpRunner3源码剖析init文件干了些啥

Thu, 01 Jan 2026 00:00:00 +0000

大家好，我是刚哥。

japi项目需求分析阶段

Thu, 01 Jan 2026 00:00:00 +0000

项目简介

japi项目，是一个接口自动化平台开发项目，由【交流群】招人共建，基于JMeter，参考MeterSphere，以学习为目的，完成一个SpringBoot+Vue技术栈的纯粹的接口自动化平台开发。

项目成员

经过"填写人员分工表"以后，最终有38人参与了本次项目：

刚哥、布鲁、嘉宥、守正、大刚、风雨、奉孝、大姚、畅月、渔夫、小禹、钰琪、天湖、迷龙、肥涵、胖子、局长、呼呼、明亮、安宁、木棉、番茄、玥玥、哈瑞、虚竹、十五、阿新、卡罗、大白、库昊、左右、小涌、古风、玉洁、小韩、小卷、千凝、昆明。

随着项目进行，后续“提交学习总结”等环节层层递进，真正留下来的项目成员，会在GitHub的README中署名。

在填表时收集了大家的历史经验，这里汇总整理了一下，供参考：

“Vue+Django写过测试平台；SpringBoot写过后端应用；Python小工具开发；Python+Pytest+Requests搭建接口自动化框架；Python+Unittest或Pytest自动化测试框架搭建及脚本开发；各类开源自动化测试平台搭建，如：HttpRunnerManager、流马、Yapi、Sonic等；js+Django2实现UI自动化测试平台；使Testng框架进行接口测试；Vue+fastapi写过测试平台；python+selenium UI自动化；python+httprunner，接口文档解析自动生成字段校验用例；python+RobotFramework做过UI；Java做过单元测试，熟悉基础语法；学过JavaSE，JavaEE，实战经验不多；Python Pyqt GUI工具开发；Python 接口自动化、APP自动化框架设计及编码；独立负责主导Python+Locust性能测试；三方库和标准库：unittest、pytest、appium、selenium、request、httprunner；画过简单的html、css；App UI自动化框架搭建：pytest+appium+allure+jenkins接口自动化框架搭建：pytest+request+allure+jenkins二次开发及维护过flask+vue接口测试平台；二次开发及维护过springboot+angularUI测试平台；Pytest+Playwright UI自动化脚本编写；”

我总结了几个关键字：Vue、Django、SpringBoot、Flask、FastAPI、ElementUI、RobotFramework、脚本开发、工具开发、平台开发、接口自动化、UI自动化、APP自动化。

项目计划

招募，人员分工，需求分析，设计，编码，测试，上线。

由于是以学习为目的，加上都是业余时间投入，也有其他事情要忙，所以该项目不会像真正项目那样，设置里程碑和交付节点，会给足够的学习时间，战线拉得比较长，过程大于结果。

需求分析

MeterSphere官方给出的功能列表，接口自动化相关的模块有接口定义和接口自动化。

接口定义包括以下功能：

在线添加并编辑接口定义; 以树状形式展示项目的模块及对应接口; 支持HTTP、Dubbo、SQL、TCP类型接口请求; 支持通过MeterSphere Json、Postman、Swagger 等多种格式文件快速导入接口，Swagger可通过URL定时同步; 支持接口快捷调试; 根据接口定义快速配置HTTP、TCP协议Mock服务; API列表、CASE列表、文档模式多种模式灵活切换; 接口页面API、TEST、CASE、MOCK多种操作灵活切换; 测试环境信息管理功能; 单接口用例支持引用环境; 支持正则匹配、jsonpath、xpath等多种类型的断言规则; 支持正则匹配、jsonpath、xpath等多种类型的参数提取; 支持BeanShell、Python、Groovy、JavaScript等多种语言的前后置脚本; 支持前置SQL、后置SQL; 支持上传并引用自定义Jar包; 支持查看接口及用例变更历史; 手动执行、定时任务、Jenkins插件触发等多种执行方式; API、CASE一键复制; CASE一键创建性能测试; 接口定义依赖关系设置;

接口自动化包括以下功能：

创建多接口串联的场景化测试; 从接口列表中快速导入接口或接口用例; 跨项目的场景引用功能; 客户端SSL证书认证配置; 场景用例支持引用环境; 支持条件、循环、事务、等待等多种类型的控制器; 支持正则匹配、jsonpath、xpath等多种类型的断言规则; 支持正则匹配、jsonpath、xpath等多种类型的参数提取; 支持BeanShell、Python、Groovy、JavaScript等多种语言的前后置脚本; 场景变量提供多种类型; 提供Mock数据和JMeter变量表达式; 环境配置增加区分模块、路径两种方式添加域名; 增加全局前置脚本、全局后置脚本; 基于插件机制实现其他协议; 支持上传并引用自定义Jar包; 支持查看场景用例变更历史; 手动执行、定时任务、Jenkins插件触发等多种执行方式; 串行、并行两种批量执行方式自由选择; 支持指定测试资源池远程执行; 可多场景串行、并行执行; 场景一键创建性能测试; 场景一键复制; 场景批量执行可自由选择独立报告或集合报告; 场景一键添加到测试计划；

除此之外还有：

java+appium+安卓模拟器实现app自动化Demo

Thu, 01 Jan 2026 00:00:00 +0000

环境搭建

据说，很多人都被繁琐的环境搭建给吓到了。

是的，确实，繁琐。

node.js

下载地址：

https://nodejs.org/en/download/

cmd 输入 node -v，出现下图说明成功：

JDK

下载地址：

https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

百度一下“配置Java”，配置环境变量。

cmd 输入 java -version，出现下图说明成功：

Android SDK

下载地址：

https://www.androiddevtools.cn/

百度一下"配置Android SDK环境变量"。

cmd 输入 adb，出现下图说明成功：

Appium Desktop

下载地址：

https://github.com/appium/appium-desktop/releases

或

https://testerhome.com/topics/680

Maven

下载地址：

http://maven.apache.org/download.cgi

百度一下“ maven环境配置”。

cmd 输入 mvn -version，出现下图说明成功：

IntelliJ IDEA

下载地址：

http://www.jetbrains.com/idea/

安卓模拟器

下载地址：

https://www.yeshen.com/

把 Android SDK 目录下 \platform-tool 的 adb.exe 拷贝。

打开 Nox\bin 目录，粘贴替换 adb.exe。

打开模拟器。

JavaWeb开发基础7个Web术语解析

Thu, 01 Jan 2026 00:00:00 +0000

7个Web术语

Website: static vs dynamic
HTTP
HTTP Requests
GET vs POST
Servlet Container
Server: Web vs Application
Content Type

Website: static vs dynamic

网站内容包括文本、图片、音频、视频，通过URL来访问。网站分为静态网站和动态网站。

静态网站

静态网站是用HTML编写的，所有内容都包含在网页内，就像是打印出来的一样。

动态网站

动态网站分为客户端和服务端，内容是可以动态变化的，可以根据用户请求动态更新网页内容。服务端语言有Servlet、ASP.NET等。

HTTP

HTTP是Hypertext Transfer Protocol缩写，超文本传输协议，位于OSI网络分层模型的应用层（第七层）。

HTTP具有以下特点：

media independent：支持任何类型的媒体内容
connectionless：无连接，客户端发送请求后，就断开了连接
stateless：无状态，服务端不会保留客户端请求的状态，不知道谁是谁

HTTP是基于TCP/IP协议的，通过TCP建立可靠连接。为什么说HTTP是无连接的，但又是基于TCP可靠连接的？如果想要可靠地传输数据，那么就必须要有稳定可靠的连接，保证数据不丢失，这个连接就是TCP连接。HTTP正是通过TCP连接来发送和接收数据的。

在HTTP/1.0中，每次请求都会建立一个新的TCP连接，完成请求后立即关闭连接。在HTTP/1.1中，引入了持久连接，允许多个请求/响应在同一个TCP连接上进行，但每个请求/响应对话仍然是独立的。HTTP/1.1是持久连接，那么还能叫做无连接吗？是的，仍然是无连接。持久连接是通过 Connection: keep-alive 头部实现的，允许连接在一段时间内保持打开状态，不需要重新建立和关闭连接。无连接的本质是每个请求/响应对话都是独立的，强调的是独立。

HTTP Requests

HTTP请求是客户端发送给服务端的请求，包含以下内容：

The Request-line（请求行）
The analysis of source IP address, proxy and port（源信息）
The analysis of destination IP address, protocol, port and host（目标信息）
The Requested URI (Uniform Resource Identifier)（链接）
The Request method and Content（方法和内容）
The User-Agent header（请求头）
The Connection control header（请求头）
The Cache control header（请求头）

可以在浏览器中通过F12开发者工具，查看HTTP请求信息。

Java新一代单元测试框架JUnit5速览

Thu, 01 Jan 2026 00:00:00 +0000

为什么学JUnit5

Java技术栈的单元测试框架有两个：JUnit和TestNG，有种说法是TestNG比JUnit更强大，学TestNG就够了，但是当我打开GitHub看到star的时候，犹豫了：

JUnit

TestNG

相差了足足有3K之多。带着这个困惑，我在网上查阅了一番资料，原来JUnit5相较于JUnit4有了重大升级，已经包含了TestNG的所有功能。为了坚定我学JUnit的想法，我咨询了身边做Java开发的朋友，开发写UT都是用的JUnit。这两个理由足以让我开始对JUnit5的学习。

JUnit5是什么

跟之前的JUnit有所不同，JUnit5由三个子项目的模块组成：

JUnit5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

JUnit Platform 在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入。提供了从命令行启动平台的Console Launcher，和支持JUnit4环境的JUnit4 based Runner。IDE一般都集成了JUnit Platform，比如IntelliJ IDEA。
JUnit Jupiter JUnit5新特性，结合了新的programming model和extension model，以便于在JUnit5中编写测试和扩展。提供了在平台上运行基于Jupiter测试的TestEngine。
JUnit Vintage 提供了在平台上运行基于JUnit3和JUnit4测试的TestEngine，照顾老的项目。

JUnit5新特性

使用JUnit Jupiter写测试

示例代码：

import static org.junit.jupiter.api.Assertions.assertEquals;

import example.util.Calculator;

import org.junit.jupiter.api.Test;

class MyFirstJUnitJupiterTests {

    private final Calculator calculator = new Calculator();

    @Test
    void addition() {
        assertEquals(2, calculator.add(1, 1));
    }

}

注意这个导包的路径org.junit.jupiter.api，Jupiter就是JUnit5的新特性。

JMeter全部组件概览

Thu, 01 Jan 2026 00:00:00 +0000

JMeter是性能测试工具，在使用JMeter变多以后，越来越觉得之所以它能成为当今时代最主流测试工具，是因为它太成熟了，举个小例子，编写GET请求的时候，需要把查询参数，也就是?号后面的请求参数添加进去，JMeter竟然有个Add from Clipboard功能，在浏览器复制以后，点这个按钮就填充好了:

JSON转SQL小工具源码分享

Thu, 01 Jan 2026 00:00:00 +0000

将key-value的JSON数据，转换为insert的SQL语句，进而实现网页数据存储到数据库。

pytest快速入门

Thu, 01 Jan 2026 00:00:00 +0000

安装Python和编辑器PyCharm

Python安装包下载地址是： https://www.python.org/downloads/ PyCharm安装包下载地址是： https://www.jetbrains.com/pycharm/download/ 下载后按常规软件安装。

pytest

pytest是Python内置包，无需单独安装，但是需要设置。

创建1个Project和1个test.py来试试，左上角点击 File | New Project | create，创建项目。在项目中右键选择 New | File 创建test.py

在test.py文件中添加代码

def test():
    pass

这个时候def的左边会出现一个绿色的箭头，点击之后就可以使用pytest运行，注意一定要是 pytest for… 才可以，如果只是 Run test.py，是不走pytest执行的（右上角Edit Configurations删掉来解决）

执行之后控制台输出信息就可以了

Testing started at 11:10 AM ...
"D:\Program Files (x86)\Python38-32\python.exe" "D:\Program Files\JetBrains\PyCharm Community Edition 2020.1.2\plugins\python-ce\helpers\pycharm\_jb_pytest_runner.py" --target test.py::test
Launching pytest with arguments test.py::test in D:\PycharmProjects\untitled

============================= test session starts =============================
platform win32 -- Python 3.8.3, pytest-5.4.3, py-1.9.0, pluggy-0.13.1 -- D:\Program Files (x86)\Python38-32\python.exe
cachedir: .pytest_cache
rootdir: D:\PycharmProjects\untitled
collecting ... collected 1 item

test.py::test PASSED                                                     [100%]

============================== 1 passed in 0.14s ==============================

Process finished with exit code 0

至此，pytest的环境就准备好了。

pytest内核测试平台落地初体验

Thu, 01 Jan 2026 00:00:00 +0000

测试平台，有人说它鸡肋，有人说它有用，有人说它轮子，众说纷纭，不如从自身出发，考虑是否要做测试平台：

RabbitMQ消息队列官方教程Java学习笔记

Thu, 01 Jan 2026 00:00:00 +0000

消息队列

RabbitMQ是一个消息队列，它能够接收和转发消息。这个过程就像寄快递一样，把物件打包给快递小哥，快递小哥会负责把物件派送到正确的地址。

生产者和消费者

生产者就是用来生产消息（发送消息）的：

消费者就是用来消费消息（接收消息）的：

在生产者和消费者之间的就是消息队列：

它相当于消息缓冲区，最多能存储多少数据只受限于机器的内存和磁盘。多个生产者可以发送消息给同一个队列，多个消费者也可以从同一个队列接收消息。

Windows安装RabbitMQ

参考mall商城学习教程的RabbitMQ部分内容：

http://www.macrozheng.com/#/architect/mall_arch_09?id=rabbitmq

原文中rabbitmq-server-3.7.14.exe下载地址失效了，改从这里下载：

https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.7.14

安装完成后，确认服务已开启：

进入RabbitMQ安装目录下的sbin目录：

在地址栏输入cmd并回车启动命令行，然后输入以下命令启动管理功能：

rabbitmq-plugins enable rabbitmq_management

RabbitMQ运行在本地机器上：

http://localhost:15672/

默认用户名密码为guest / guest：

Java客户端

amqp-client-5.7.1.jar是RabbitMQ官方提供的Java客户端：

https://www.rabbitmq.com/tutorials/tutorial-one-java.html

既可以直接下载jar包，也可以在Maven中添加依赖：

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.14.2</version>
</dependency>

生产消息

导包：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

创建类Send，定义队列名为hello：

public class Send {
  private final static String QUEUE_NAME = "hello";
  public static void main(String[] argv) throws Exception {
      ...
  }
}

建立连接：

SpringBoot简介与安装

Thu, 01 Jan 2026 00:00:00 +0000

SpringBoot简介

SpringBoot是Java技术栈的一个Web开发框架，在整个Web开发框架领域中，说SpringBoot是最成熟、最稳定、生态最强大的，一点也不为过。它最伟大的变革是让Java的Web框架也变得便捷起来，开箱即用，只需要简单配置就能快速搭建起一个后端应用，这也是它出现后迅速抢占市场，实现技术更替的重要原因。

除了Web应用开发外，SpringBoot还提供了内嵌服务器（Tomcat等）、安全、监控、健康检查等能力。

SpringBoot安装

本文主要介绍Maven这种方式：

第一步，安装Java，SpringBoot 2.5.6版本需要Java8及以上版本，最新的Java17也兼容。
第二步，安装Maven，不需要单独安装，下载一个IntelliJ就可以了，详细步骤可以参考我博客中这篇文章：

001-2021年搭建Java环境最快办法

第三步，在pom.xml中配置SpringBoot：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
    </parent>

    <!-- Additional lines to be added here... -->

</project>

下篇文章《开发你的第一个SpringBoot应用》将继续探究SpringBoot安装后的使用。

参考资料：

https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#getting-started

tep首次开源V0.2.3介绍

Thu, 01 Jan 2026 00:00:00 +0000

『 tep is a testing tool to help you write pytest more easily. Try Easy Pytest! 』

保姆级VSCode入门指南，Python党直接抄作业

Thu, 01 Jan 2026 00:00:00 +0000

今天就来介绍一款开源、免费、颜值高的“瑞士军刀”—— VS Code (Visual Studio Code)

测试人员学Java入门指南

Thu, 01 Jan 2026 00:00:00 +0000

目标读者

本指南特别适合有Python基础的同学学习Java入门，对于没有任何编程经验的同学可能会存在困难。

为什么测试人员要学Java

选择Java，应该不错。TesterHome测试论坛知名大佬基本都是以Java技术栈为主，少部分是Golang和Python。我公司2021年校招的两个同济大学研究生，测试开发，也是以Java为主。有一个测开同事跳槽去了美团，拿了高薪，只会Java。有一个测开同事跳槽去了创业公司做了测试架构师，只会Java。招聘网站搜索测试开发20K以上职位，基本都要求会Java。我接触到的开发，Java程序员占80%以上。

测试人员用Java能干嘛

如果你的公司是以Java技术栈为主，那么你可以用Java做所有事情，而且有些事情只能用Java来做。这个问题挺关键的，学习一门语言肯定是要能够学以致用。在自动化测试，Java会显得稍微有点笨重，而Python会适合一点。你可以用Python来写接口自动化脚本，在小范围内使用，但是当团队变大以后，脚本如何规范如何维护，就成了一个很大的问题，而Java由于静态语言特性和面向对象编程，正好可以用来解决这个问题。在测试平台和性能测试，Java有很成熟的Web开发框架和配套的生态。在测试工具开发，公司封装好的Java库可以拿来即用，碰到问题也可以找开发帮忙。白盒测试，基本上都是要靠Java来做的，看代码，用JaCoCo统计代码覆盖率。其他专项比如流量录制回放、全链路压测、Dubbo接口测试，都只能使用Java来做。

测试人员怎么学Java

我推荐刷完一遍基础语法后，在LeetCode上面刷算法题来加强练习。Java还是有一定的学习门槛的，初学者可能学起来会有些吃力，可以先从Python入手，了解编程语言的底层逻辑，等对编程有些许感知以后，再学习Java。基础语法可以快速浏览一遍，一遍并不会就能记住了，需要在编码中持续加强记忆。光学语法也不行，学习Java和其他编程语言一样，需要多敲多练，刷算法题，既能熟悉Java语法，也能熟悉算法，一举两得，题做不来就先把答案背一遍再做。另外，可以在工作中主动找研发开通下代码权限，尝试Review开发代码，看多了，有些技巧也会知道了。有机会，可以用Java写点工具或者平台，实践出真知。

搭建环境

安装Java

Java的安装包是个.exe文件，特殊地方在于文件名不是java-xxx.exe而是jdk-xxx.exe，比如jdk-8u281-windows-x64.exe，jdk是Java Development Kit 的缩写，指Java开发工具包，包括以下内容：

JDK的最新版本为15，但是国内大多数公司仍然使用的是JDK8，这是因为JDK8是各方面都很成熟稳定的版本，并且基于JDK8开发的业务系统已经具有一定规模，新版本JDK并不能完全无感知的迁移，需要做代码修改和测试，会是一笔巨大开销，为了降低成本和规避兼容问题风险，JDK8沿用到了至今。JDK8的下载地址如下：

https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

选择相应的版本下载：

比如我的电脑是Windows 64位的系统，就选择了Windows x64这个版本，会下载到一个jdk-8u281-windows-x64.exe文件。Java已经被Oracle收购了，需要登录Oracle账号后才能下载，没有账号注册一个也很方便：

下载后可以开始安装了：

安装到默认位置即可，直接下一步。中途会让选择JRE（Java Runtime Environment，Java运行环境）的目标文件夹：

依然保持默认即可。安装结束后就能看到两个新文件夹了：

以前，还需要配置系统环境变量，设置JAVA_HOME和CLASSPATH才能使用Java（具体方法百度有很多）。现在，安装完成即可用，省去了不少麻烦，速度加快。打开cmd输入java -version，命令能执行成功就表示Java已经安装好了：

安装IntelliJ IDEA

JetBrains全家桶中也有专门用来写Java的，叫做IntelliJ IDEA，一般只说后面一个单词“哎迪儿”就知道是这个东西了。下载地址为：

https://www.jetbrains.com/idea/download/#section=windows

个人建议选择旗舰版，看着齐全。下载后双击ideaIU-2020.3.2.exe安装，先别忙着打开。

Maven仓库

Maven是用来管理Java第三方包的主流仓库工具，通过pom.xml文件来配置安装即可，在mvnrepository网站上能检索到所需配置信息：

https://mvnrepository.com/

官方仓库有时候下载速度很慢，本文用国内镜像替代，提高首次打开时同步仓库速度。我们先把Maven中央仓库从Apache替换成阿里云。打开本地目录D:\Program Files\JetBrains\IntelliJ IDEA 2020.3.2\plugins\maven\lib\maven3\conf：

编辑settings.xml文件，找到<mirrors>标签，添加代码：

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

接着可以打开IDEA了，欢迎界面映入眼帘：

新建项目

选择新建Maven项目：

填写项目名和存放位置：

在pom.xml文件中添加仓库配置：

    <repositories>
        <repository>
            <id>public</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </pluginRepository>
    </pluginRepositories>

从300到19999，我买手机的十六年

Thu, 01 Jan 2026 00:00:00 +0000

时间来到2026年夏天，一轮又一轮的手机涨价新闻出现，“华为新款三折叠19999元非常有诚意”，“折叠屏iPhone Ultra的预计标价达到20559元”，“小米18 Fold折叠屏起售价10999元”。我不是以前的我，手机也不是以前的手机了。

2013年7月31日，随着一句“为发烧而生”，红米带着性价比横空出世。这也是我的第一台触屏手机。拆开外包装，拿到手上，打开屏幕的那一刻，我现在还记得，我终于有了一台真正的手机，我内心澎湃地感叹着。手机上的文字看着特别的细腻。我给这台手机换了3次手机壳，一直坚持用到了毕业。

手机市场最疯狂的时代是2015年到2017年，我在这3年换了4部手机，HTC、联想ZUK、小米6、小米Note3，最快的是半年就换。手机越来越漂亮，可是人却越来越不懂得珍惜。

那段时间经常刷中关村在线、IT之家，了解新机的特点，追各种评测。我同学也必看小米发布会，我也是从他那知道，对着小米音响喊一声雷军，它会自动播放are you ok。

那是在江苏常州出差的下午，天下着暴雨，京东快递小哥电话说你的手机到了。我满怀激动地打开了用工资买的第一台手机HTC。我当时的购机需求是外放音质，低音炮特别带感，金属拉丝后盖也有质感。联想ZUK是小巧旗舰用起来很顺手，小米6没用坏是摔坏了。小米Note3雷军没有耍猴，我第一时间在小米之家拿到了首发现货。这台手机的手感是我用过的手感最舒服的，温润如玉。

2021年，从小米Note3换到了小米11。用了5年，也让我再也不想买小米任何产品。

刚开始买小米的时候，我还自嘲说自己要成为米粉了。毕竟有红米1代情节，加上小米Note3的体验加持，我对小米的感官是特别好的。还买了小米电视、小米机顶盒、小米充电宝等一系列小米产品。

我升级了一次系统之后，WIFI用不了，找到小米之家售后。“你的手机是哪个型号”，“小米11”，店员二话不说，给我免费换了主板。不怎么关注手机新闻的我，那时才知道小米11烧主板的事情。我问那个店员你的手机看着挺不错啊，是哪个系列的，他微微一笑，“苹果”。

回顾用过的小米产品，确实性价比挺高，但是质量也并没有那么好。当初1999把价格打下来的“土匪”，现在也摇身一变成为了高不可攀的“贵族”。

2026年，小米11的摄像头聚不起焦了，每次拍照都要甩两下。之前在酒店让前台写评价拍照，我让他甩两下，他开玩笑的说，这么高级。

我已经很久没关注手机的新闻，最近买手机发现价格已经变得离谱。一个手机的价格都够买一台笔记本电脑了。手机的那些乱七八糟的功能很多也用不上。

华为手机要6000+，苹果手机要8000+，新一代更是要突破万元。现在的手机，已经贵得难以下手。老婆追求拍照买了Vivo，我顺理成章地继承了她原来的那台iPhone，换个手机壳，还能继续用3年。

一年又一年，十六年啦。是手机已经买不起了？还是我已经不想买那么贵的手机？

从零开始学mitmproxy抓包工具

Thu, 01 Jan 2026 00:00:00 +0000

Man In The Middle

mitm是Man In The Middle的首字母缩写，意思是位于中间的人，表明mitmproxy是一个代理，可以拦截请求，实现网络抓包。知名的网络抓包工具有Fiddler、Charles、HttpWatch、WireShark、BurpSuite和Postman等，mitmproxy相对来说，没有这么高的知名度，它相比于以上工具的独特优势是，它提供了Python API，可以编写Python代码对网络请求进行流量录制，从而收集接口信息以及转化为接口自动化用例等。mitmproxy官方文档不但有mitmproxy工具使用介绍，还有代理实现原理，对我们学习掌握网络知识有很大帮助。

安装与使用

pip安装

pip install mitmproxy

mitmproxy是Python开发的，用pip就能安装成功。官方给出了二进制安装包等方法，我觉得作为一款用Python开发的工具，用pip直接安装是更Pythonic的。

命令启动

可以通过3种命令启动mitmproxy：

mitmproxy 控制台
mitmweb 网页
mitmdump 命令行

它们的内容都是一样的，只是UI不一样而已。

手动设置代理

打开以后mitmproxy默认会监听http://localhost:8080，需要设置下代理，把代理服务器设置为这个地址。

Windows可以这样设置：

实际上，Charles等网络抓包工具会自动配置代理，而mitmproxy需要手动设置代理，开发团队的解释是因为浏览器版本和配置经常会变化，所以他们建议在网上根据环境搜索方法手动设置。

下载证书

访问http://mitm.it/，如果代理配置没有生效，打开后会是这个界面：

正常的话，会出现证书下载页面：

根据平台选择相应证书安装就OK了。

使用

mitmproxy更其他抓包工具用法类似。

官方用视频演示了mitmproxy如何使用：

https://docs.mitmproxy.org/stable/mitmproxytutorial-userinterface/

并且介绍了5种运行模式：

https://docs.mitmproxy.org/stable/concepts-modes/

读者可以自行阅读下。

mitmproxy工作原理

客户端（本机）连接代理服务器（http://127.0.0.1:8080），代理服务器连接服务器。
客户端给代理服务器发请求，代理服务器把请求发送到服务器。

所有请求经过mitmproxy，就可以实现请求拦截。

对于HTTP来说，直接借助mitmproxy传递请求就可以。而对于HTTPS来说，有个SSL/TLS安全认证，必须安装证书，服务器才会认为mitmproxy的请求是可信任的，请求才会成功传递。

HTTPS的代理过程就要复杂很多，客户端先跟mitmproxy建立连接（1~~2步），然后进行安全认证（3~~6步），最后传递请求（7~8步）。

反向代理

假设在本机使用FastAPI启动了个Mock服务，地址为http://127.0.0.1:5000，通过Postman调接口，怎么使用mitmproxy来拦截请求呢？这就需要用到反向代理。

首先以反向代理模式运行mitmproxy，服务器端口为5000，监听端口为8000：

mitmproxy --mode reverse:http://127.0.0.1:5000 --listen-host 127.0.0.1 --listen-port 8000

然后把请求http://127.0.0.1:5000/login里面的5000端口改成8000，访问：

http://127.0.0.1:8000/login

就能在mitmproxy看到抓到请求了：

这样就能在本地使用Mock服务来调试拦截请求的Python代码了。

Python API

Python API是mitmproxy的特色功能：

代码变形记之模板方法模式

Thu, 01 Jan 2026 00:00:00 +0000

《代码变形记》系列文章基于真实案例，记录实际工作中的代码优化方法。

计算机历史人物之冯·诺依曼

Thu, 01 Jan 2026 00:00:00 +0000

0-5岁就有过目不忘的记忆力，6个月能认出客人，2岁能用德语和母亲交流。6岁已经能读古希腊文献，经常随口报两个8位数，心算除法，结果精确到小数点后几位。8岁就自学完成微积分，阅读44卷本的《世界通史》。10岁进入著名的路德中学，这所学校后来培养出多位诺贝尔奖得主。12岁开始研究集合论和超限数，讨论无穷理论。15岁掌握泛函分析、复变函数、测度论。17岁发表第一篇数学论文《论某类最小多项式的零点位置》

聚焦于任务调度的测试平台pytestx

Thu, 01 Jan 2026 00:00:00 +0000

设计理念

聚焦于任务调度，接口自动化80%本地编写，20%交由平台管理。

如果使用pytest做接口自动化，那么个人认为最好的编写工具是PyCharm，任何低代码测试平台都无法取代。当然不会代码，或者不使用pytest，那低代码测试平台，或者yaml，甚至excel写自动化用例，都是可以接受的。而在使用pytest这个特定场景里面，要做平台化，平台的功能就需要仔细斟酌。既然编写用例最好使用PyCharm，平台也就只能专注于用例编排和任务调度，即创建任务，关联用例，批量运行，以及定时，并行，通知等。

pytestx正是基于此理念设计的一款纯粹的任务调度平台。

平台架构

tep1.0.0的延续

tep1.0.0版本已经封版，在pytestx中对它进行了延续。

从pypi到git

tep是上传到pypi的，通过pip命令安装，使用tep startproject命令创建项目脚手架，代码结构分为项目代码和tep代码。改造后的tep只有项目代码，存放在：

https://gitee.com/dongfanger/tep-project.git

也就是说，在这个项目中，能看到整个tep全貌。之前的tep内核代码，比如fixtures自动寻找、内置fixture、环境变量等，全部迁移到了项目代码里面，尤其是conftest.py的文件内容。pip install tep顺带安装的依赖包，也整理到了requirements.txt，按照说明安装即可。

pytest-html替换allure

由重到轻，化繁为简，pytest-html能够满足数据+日志的报告需要，最新的V3.2.0版本的界面尚可。诚然allure漂亮，但安装Java、下载Allure、配置环境变量、安装pytest-allure、添加pytest hook还是相对麻烦。更重要的是，要支持平台在线查看报告，减少存储占用，pytest-html无疑是更好的选择。

下载脚手架

既可以从使用git clone下载代码，也可以从页面下载，就像spring.io那样：

fastapi到django

之前的示例代码是调用的fastapi启动的应用，pytestx则将示例代码的接口换成了Django自身的mock接口。

teprunner的延续

pytestx的基础代码是从teprunner来的，对数据库设计、代码规范、项目结构做了优化。

任务管理

一、同步项目

同步项目，是把项目配置的Git仓库地址和分支，更新到本地沙箱中，项目之间完全隔离。

并把用例落库：

二、任务关联用例

创建任务，任务关联用例，就形成了新的用例集。

三、容器化运行

当前是假容器，未真正引入Docker，所谓容器，是指每次运行，都将用例拉取到新的目录，批量执行：

四、生成报告

pytest命令生成html报告，存放于reports，借助于Django挂载页面，从页面点击，在线查看报告：

体验平台

下载源码：https://github.com/dongfanger/pytestx

安装依赖：前端（npm install）后端（pip install -r requirements.txt）

启动服务：前端（npm run serve）后端（python manage.py runserver）

即可畅快体验。

学习交流

添加微信cekaigang，加入交流群，欢快讨论吧。

录制脚本与元素定位

Thu, 01 Jan 2026 00:00:00 +0000

UI自动化最麻烦的就是定位元素，好在Playwright支持录制脚本，可以在界面进行操作，快速获取元素定位，生成测试脚本。

如何让文科生5分钟写上Python

Thu, 01 Jan 2026 00:00:00 +0000

序言

这篇文章是转型后发表的第一篇文章，有必要先聊一下我的写文计划。

串行文章和并行文章

我会按照发文顺序分为串行文章和并行文章。Python 语言本身的内容，我会按照入门、进阶、原理的顺序依次展开。由于我的水平有限，为了保证质量不乱讲，我选择站在巨人的肩膀上进行二次创作。入门篇主要参考菜鸟教程的基础教程部分。进阶篇主要参考《流畅的Python》这本书，我是买了实体书的，计划后面会送出来，虽然有些破旧，还望不要嫌弃（当时买的时候书页就坏了，京东还赔了我 1000 京豆）。原理篇主要参考官方文档以及外网资料，有一说一，国外资料确实更多更专业，只不过都是英文的，还好现在已经适应了。Django、算法、pytest、tep、测试成长小说等系列专题会并行发表，也包括其他单篇文章。这两天了解到 Python 之父 Guido van Rossum 从 Google 退休后，又加入微软继续搞 Python 了。有点意思。

有啥不一样？

Python 文章和视频都非常多，我就在想我写的东西对读者而言价值到底在哪？我不是搞培训的，也不是做教程，内容会更偏向于学习笔记和实用经验。看我的文章，说不定能把以前遗漏或遗忘的知识点再次补上。同时我已经有一段时间的写作经验了，我也尽量深入浅出的把知识讲清楚讲透彻，首先写的文章我要自己都理解透，这样别人看的时候才会觉得一目了然。另外就是认真的态度，见过一些为了流量写的教程，不做评价。只是觉得既然写了，既要对得起自己，也要对得起别人。

标题

既为了提高打开率，也是为了新颖，我不会按照比如《Python入门1》、《Python入门2》这种常规的命名，这样的文章实在是太多了。而是会在写完文章后，根据文章内容，选择其中的亮点，作为标题。这个过程也挺有趣，有种点睛之笔的意味。同时我也希望随便摘一篇文章拿出去，也是够看的。

（突然想起来上学写 2000 多条错题笔记的时候，简单又充实）

开篇

为了把这个开篇写好，我专门在 B 站上面找了最火的 Python 教程，全站排行榜最高第1名的《花了2万多买的Python教程全套》，质量很高，也推荐大家看看。不过我不搞培训，也不需要宣扬 Python 的好处促进就业，就不写那么多背景介绍了。身边学财会的朋友之前让我教教 Python，干脆我就以这个为契机，作为开篇，保证 5 分钟内，即便是文科生，也能用 Python 编起程序来！

电脑

Python 并不神秘，它其实就和 QQ 一样，只是一个运行在电脑上的普普通通的软件。只要有一台电脑，就可以写 Python。

安装

打开这个下载网址：

https://www.python.org/downloads/

点击 Download Python 进行下载（Mac 土豪请注意选择版本）。下载后傻瓜式一路点击下一步安装就好。

使用

一般的软件我们都是双击图标打开。Python 在安装以后桌面上不会出现图标。不过可以从开始菜单找到：

点击后就打开了：

Python 毕竟是一门编程语言，它也有它自己的尊严，所以它的界面看起来也有专业的一面，比如那一串密密麻麻的英文。

输入一句话试试：

print("hello")

敲击回车。它马上就会回应一句，hello：

没错，是的，你已经在用 Python 编程了！

小结

本文以极其简单的例子，介绍了如何动手用 Python 编程。我试了下，如果网速快的话，5 分钟内完成是妥妥的。哈哈哈。之所以选择这个简单例子，也是想说明 Python 本来就是很简单的，不用听到编程就被吓到了。先动手，一点一点学习就好。不过言归正传，我们工作中并不是这么写 Python 的，而是用一款叫做 PyCharm 的软件。PyCharm 分为社区免费版和专业旗舰版。日常使用社区版就可以了，个人推荐旗舰版。提示一下，破解的时候注意搜索带上 PyCharm 的版本，比如 2020.2.3，成功率会更高。

事件时间日志，精准工作之道

Thu, 01 Jan 2026 00:00:00 +0000

李笑来在书中谈到了事件时间日志的好处：“它会使你对时间的感觉越来越精确。可以调整我对时间的感觉，在估算任何任务的工作量的时候，都更容易确定真正现实可行的目标。相对准确的估算又使得目标基本上都可以达成，由此可以算是战胜了焦虑”。

刷了80道算法题以后

Thu, 01 Jan 2026 00:00:00 +0000

刷了80道算法题以后，我最大的感受是，自信心倍增。既克服了对算法的恐惧，也加强了Java代码能力，还收集了2068行答案代码。

一个请求的一生

Thu, 01 Jan 2026 00:00:00 +0000

点进Service，全是接口。点进ServiceImpl，前半段在校验业务规则，后半段调了个stockService.deduct()，又得跳到另一个Service。

原创电子书全新重磅升级

Thu, 01 Jan 2026 00:00:00 +0000

电子书，简洁专注的阅读体验。对于技术文章来说，电脑端比手机端更适合阅读，尤其是代码。电子书的左侧目录能快速找到文章，虽然公众号也有文章分类功能，但是不能像目录树一样有“位置感”。电子书还能支持搜索。所以把个人网站做成了电子书。

怎么写Go代码

Thu, 01 Jan 2026 00:00:00 +0000

安装过程略过，网上搜一大把。

中台RPC接口自动化怎么做

Thu, 01 Jan 2026 00:00:00 +0000

RPC接口

我所在的部门是技术中台，主要负责toB业务，上游是业务条线，包括PC、APP、小程序等终端，这些端的后台是HTTP接口层，而在HTTP接口层之下，就是技术中台的RPC接口层。

HTTP是一种超文本传输协议，基于TCP/IP来传输文本、图片、音频、视频等数据。数据包的传输能力不是HTTP提供的，而是TCP/IP干的。HTTP的本质是客户端和服务端约定好的一种通信格式，是一种全世界认可的通用范本。

RPC是一种远程调用，也就是进程间通信，既可以用HTTP协议，也可以用自定义协议。RPC的好处是没有HTTP那么多约束，简化了写法，可以根据公司自定义规范，内部统一即可。 所以在公司内部特别流行，比如阿里的Dubbo接口就是一种RPC接口，我们公司用的JSF接口，自研的服务框架，简称杰夫。

举个例子，本地调用，是调用的本地方法：

 public User getUserById(Long id) {
       return userDao.getUserById(id); // 这叫本地调用
    }

而RPC远程调用，调用的是另外一个服务的方法：

 public User getUserById(Long id) {
       return userConsumer.getUserById(id); // 这是远程调用，逻辑是用户小组的服务实现的。
    }

本地调用和远程调用的比较如下图所示：

左边的本地调用，只在应用内部调用。右边的远程调用，会跨应用在应用之间调用。

RPC和HTTP用法区别

HTTP接口在调用时，输入URL，Method，Headers，Body等等等就可以发送请求了。

RPC接口的调用大同小异，输入：

JSF地址：方法引用路径，比如com.dongfanger.api.service.ShopProvider。

方法名：方法名称，比如queryShopList。

别名：既可以是分组别名，也可以直连IP地址。

方法入参：JSON串。

等等等，就可以发起请求了。

从用法能看出来，RPC和HTTP接口的结构体是差不多的，但是RPC不需要Method和Headers，精简了许多。

接口自动化

首先需要考虑的是目录结构设计，HTTP可以模块菜单创建用例目录，比如：

一级目录：管理端

二级目录：发票管理

三级目录：发票查询

而RPC是无页面的，一般存在很多业务线，所以可以按照功能域和业务线来组织目录，比如：

一级目录：发票

二级目录：提交申请

三级目录：分销

其次就得考虑技术实现了，公司基建比较完善，无论是HTTP还是JSF接口，都能在接口测试平台上编写自动化用例。虽然是Web平台写用例，但是得益于测试平台的优秀设计和使用体验，用起来很方便，效率也很高。交互方式跟JMeter大同小异，只是在细节上做了很多打磨。

然后就是参数构造了，建议是用流量回放的方式来做，省去手工编写参数的崩溃感。流量用例创建好以后，需要做一些参数化处理和接口关联。这样才能够把多个接口串起来。

对于测试数据，通过预设变量来统一管理，自动化用例也尽可能设计成闭环，增加，修改，查询，删除，用例跑完后产生的数据也跟着清理掉。

最后就是断言了。没有断言的自动化用例，不叫做自动化用例。断言一定要加上，否则定时任务跑出结果后，无法判断到底有没有问题。而断言内容不能只是简单的code200，需要加上业务校验。

中台RPC接口自动化最难处理的是接口依赖问题，链路特别长，依赖特别多。我一般通过Mock来解决这个问题，公司的测试平台也提供了这个功能。

需要注意的是，核心用例定时运行监控起来，而一次性用例要及时维护或清理，防止变成僵尸用例。

最后，我准备基于Vue+FastAPI开发一套新的pytest脚本管理平台，集成流量录制创建用例和Mock等功能，并借鉴公司测试平台的设计，感兴趣的同学可以添加微信cekaigang加群讨论哟。

关于

Mon, 01 Jan 0001 00:00:00 +0000

关于测试开发刚哥