开发 on 测试开发刚哥

比 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

生成器的原理就是：

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 块硬编码分派逻辑。」

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 注释：

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 能从序列中提取结构化信息。

Python 函数装饰器高级用法

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

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

关于 Python 闭包的一切

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

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

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 语言最优秀的设计之一，它以非常简洁的方式增强了函数的行为，让崎岖不平之路变得平坦顺畅。

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 官方教程，有些不一样的理解。内容比较散乱，个人意识流笔记。

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 字段）

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
{}

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

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 基本数据类型，实际编码中要用到的也主要是这两类）

原来 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 多个：

深度剖析 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))

集合支持的操作如下：

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。

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关键字。

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

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

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

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：

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

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

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

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

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

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

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，所以下面这个还是函数接口：

对 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.

能取值亦能赋值的 Python 切片

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

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

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

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

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

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; }
}

改为泛型实现：

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

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.

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

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

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

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
}

类实现接口：

JavaWeb 开发进阶 SpringMVC 简介

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

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

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一定会指向两个不同的单独的空列表。

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.

DRF 类视图让你的代码 DRY 起来

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

刚开始写views.py模块的代码，一般都是用def定义的函数视图，不过 DRF 更推荐使用class定义的类视图，这能让我们的代码更符合 DRY（Don’t Repeat Yourself）设计原则：

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 方法，而调的实例方法却是子类的。（如果不是隐式转换，而是直接给父类实例化，那肯定还是调父类方法）

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()方法进行清理。

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

DRF 对 Django 请求响应做了技术升级

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

Django 视图是用来处理请求和响应的，Django 默认是按 Form 和 Template 来设计的，如果要处理以 JSON 格式为主的 RESTful API，那么就需要对 Django 请求和响应的处理代码进行优化改造，本文就来介绍 DRF 在这一部分的技术升级。

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

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;
    }
}

SpringBoot 官方笔记 5Data

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

Spring Boot integrates with a number of data technologies, both SQL and NoSQL.

魔法方法推开 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()函数查看有多少张牌：

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 项目发布流程，

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：

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 来检索用户的会话数据

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.

从函数到包的 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 序列化技术的神秘面纱技术的神秘面纱。

Flask 的 Blueprints 和 Views

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

Flask 的 view 函数是用来对请求作出响应的。单个 URL 能匹配到单个 View，那么多个类似的 URL，比如：

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 参数

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

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.

快用 DjangoRESTframework 写写 API 吧

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

Django 默认是前后端绑定的，提供了 Template 和 Form，现在流行前后端分离项目，Python 大佬坐不住了，于是便有了 Django REST framework：https://github.com/tomchristie

条件循环语句组成了 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。

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 生成和场景/数据管理功能，进一步简化了项目的开发和管理。

Flask 使用 SQLite 数据库

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

SQLite 是一个小型的轻量数据库，特别适合个人学习使用。因为 SQLite 不需要额外的数据库服务器，同时它也是内嵌在 Python 中的。缺点就是如果有大量的写请求过来，它是串行处理的，速度很慢。

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()等。

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：

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.

你知道 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 应用代码，比如：

Java 官方笔记 1 编写运行 Java 程序

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

你可能已经迫不及待想安装 Java，写个 Java 程序跑起来了。但是在这之前，有些概念需要提前了解，因为 Java 跟 C、C++和 Python 都有点不一样。

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()
```

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());
    }
  }

跳过重试：

Python 运算符可不只有加减乘除

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

数学里面的加减乘除，就是运算符，但是 Python 的运算符更多样，更复杂，分为算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符、身份运算符。为了更直观的看到运算符的使用，本文采用代码和注释结合的方式进行讲解。

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.

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

查看本地分支

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类列表：

关于 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 开发的更多细节。

刷完 3 个 Java 教程后不再犹豫

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

成年人最大的底气是你拥有一技之长，人生才不会被动。从事测试开发岗位，需要精通一门编程语言，是核心，是大招，是招牌技能。我内心一直在 Java 和 Python 之间选择，反复横跳。

用 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。

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。

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 只支持单继承，不支持多继承，但可以多重继承：

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 页面

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 即可：

多线程简单斗地主

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

多线程，通道，读写锁（单写多读），随机（洗牌），是本文涉及的主要知识点。

开发你的第一个 SpringBoot 应用

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

创建 SpringBoot 项目最便捷的方式一是在https://start.spring.io/根据步骤选择后，下载项目工程压缩包：

为什么 Kafka 这么快

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

Apache Kafka 是一个开源的分布式事件流处理平台，主要用于高性能数据管道、流式分析、数据集成和关键任务应用。

一文搞懂 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.

Django 匆匆一眼却解答了多年疑惑

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

Django 是 Python 的一款 Web 开发框架，另外还有 Tornado，Flask，Twisted。为什么我要选择学 Django？原因很简单，上家公司来了个网易的测开，就是用 Django 开发的测试平台。

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+。

Flask 一分钟 Mock 一个 API

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

如果安装了 Python，并且安装了 Flask：

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 连接来发送和接收数据的。

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>

生产消息

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 安装后的使用。

保姆级 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 写点工具或者平台，实践出真知。

代码变形记之模板方法模式

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 岁发表第一篇数学论文《论某类最小多项式的零点位置》

录制脚本与元素定位

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 在安装以后桌面上不会出现图标。不过可以从开始菜单找到：

点击后就打开了：

刷了 80 道算法题以后

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

刷了 80 道算法题以后，我最大的感受是，自信心倍增。既克服了对算法的恐惧，也加强了 Java 代码能力，还收集了 2068 行答案代码。

怎么写 Go 代码

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

安装过程略过，网上搜一大把。