withdong02

笔试收获

Sun, 29 Mar 2026 13:38:33 +0000

参加了一次笔试，收获颇多。

不同的输入方法

和力扣不一样，一些大厂的笔试包括面试时的算法题都是 ACM 模式，也就是需要自己处理输入，然后对输入处理并输出，而力扣是核心代码模式，不用你管输入，只需要实现指定方法，平台自会调用你的方法。在参加之前，我去卡码网上了解了一下，发现还是 Scanner 那一套，也就没在意，但当我真正开始做的时候感到有点不对，Scanner 恐怕不太够用。这篇博客主要讲一下 Java 里的输入流。

Java 的输入体系建立在流的概念之上，主要有两个抽象基类：InputStream 和 Reader ，前者为字节流，处理原始字节数据，如图片、音频等；后者为字符流，处理字符数据，如文本文件、控制台输入等。两者之间通过 InputStreamReader 作为桥梁，将字节流转换为字符流。

InputStream 字节流

InputStream 类定义了所有字节输入流必须实现的核心办法。包括 int read() , int read(byte[] b) , void close()等方法。

Java 的 IO 体系采用了装饰器模式，意味着可以通过组合不同的流来实现复杂的功能。这里将 InputStream 的子类大致分为两类。

第一种，这种类直接与特定的数据源进行交互，比如 FileInputStream ByteArrayInputStream 。

第二种，这种类不直接连接数据源，而是通过继承装饰器基类 FilterInputStream 来包装一个已存在的 InputStream ，给它提供一些额外的功能，比如缓冲、数据类型转换等。这种类的典型代表有 BufferedInputStream DataInputStream 等。

Reader 字符流

Reader 类是字符输入流的抽象基类，定义的方法有 int read() , int read(char[] cbuf) , void close() 等。

它的子类和 InputStream 一样，也分两种，这里不再多说。但它有一个特别的子类： InputStreamReader 从它的类名就能看出来，它是字节流到字符流的单向桥梁，它可以读取字节，然后根据指定的字符编码将其解码为字符。

System.in

它是 System 类里的一个静态变量，类型是 InputStream ，所以它是一个字节流。如果需要按字符或行读取，通常需要对其包装，比如刚才提到的 InputStreamReader 和常见的 Scanner。通常情况下，System.in 默认连接到控制台（键盘），同时它读取数据也是阻塞式的，程序会一直等待，直到有数据可读或者流被关闭。

权限模型

Mon, 16 Mar 2026 19:41:31 +0000

常见的权限模型有两种：RBAC 和 ABAC。

两种模型介绍

RBAC 模型

Role-Based Access Control，翻译为基于角色的访问控制。角色拥有某些权限，通过赋予用户某种角色来达到给用户授予相关权限的目的，这就是基于角色。实现较简单。在一些大型组织中，角色可能爆炸式增长，导致管理复杂、权限冗余。

ABAC 模型

Attribute-Based Access Control，翻译为基于属性的访问控制，它比 RBAC 更加灵活，因为在 ABAC 模型中，一个操作是否被允许是基于对象、资源、操作和环境信息共同动态计算决定的。它的控制更细粒度，比如它能实现“仅允许大学生在水课上睡觉”的控制。

派聪明的权限控制

派聪明是二哥的一个项目。

派聪明的权限模型是改进版的 RBAC，或者说简化版的 ABAC。设计了 admin 和 user 两种角色，管理员拥有管理知识库，查看用户列表等权限，普通用户拥有查看私有知识库等权限。但单纯的 RBAC 有两种局限性：权限控制力度不够细和没办法基于数据属性做动态授权，所以添加了组织标签机制。

在上传文件时，给每份文档标记上传者所属的标签，这样用户访问知识库，系统能够动态的基于当前用户的组织标签和文档的组织标签进行匹配过滤。从而实现更细粒度的数据隔离和动态授权。

此外，派聪明还考虑到了多级组织，设计了组织标签树。比如有这样三个层级标签：总部、研发部、后端部。一个拥有后端部组织标签的员工可以访问研发部、总部这两个父组织的资料。我个人在这一部分绕了很久，总感觉设计反了，现在是这样理解的，抛弃父标签级别高，所以权力大的想法，这样想：

父标签（如“总公司”）：它定义的是一个最基础、最通用的权限范围。就像一张“员工卡”，让你能访问公司的基础公共资源。
子标签（如“技术部”、“财务部”）：它在父标签的基础上，增加了更具体、更细分的权限。就像一张“技术部员工卡”，它包含了“员工卡”的所有权限，还额外增加了进入技术部专属区域的权限。

这就是派聪明中有关权限模块的设计。

转转统一权限系统的设计与实现

经过分析，转转技术部门选择了基于 RBAC 模型来实现，但它也有所改动，在原有基础上，新增了给用户直接增加权限的能力，也就是说既可以给用户添加角色，也可以给用户直接添加权限。所以用户最终的权限为所拥有角色带来的权限和用户独立配置的权限的并集。

转转的技术文章里还从权限系统自身和具体业务系统两层设计了六种身份，这里不再多说。

参考文章：

手写简单IoC容器

Sat, 07 Mar 2026 15:22:01 +0000

学习 Spring，跟着二哥简单写个 IoC 容器。

@Target(ElementType.FIELD)  
@Retention(RetentionPolicy.RUNTIME)  
@interface MyAutowired {  
}  
  
@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
@interface MyComponent {  
}  
  
public class SimpleIoC {  
    Map<Class<?>, Object> beans = new HashMap<>();  
  
    //扫描  
    public void scan(String packageName) {  
        List<Class<?>> classes = getClassesInPackage(packageName);  
        for (Class<?> clazz : classes) {  
            if (clazz.isAnnotationPresent(MyComponent.class)) {  
                registerBean(clazz);  
            }  
        }  
        di();  
    }  
  
    //获取包下的类，简化实现  
    private List<Class<?>> getClassesInPackage(String packageName) {  
        // 实际实现需要扫描classpath，这里简化处理.  
        return Arrays.asList(UserDao.class, UserService.class);  
    }  
  
    //注册bean  
    private void registerBean (Class<?> clazz) {  
        try {  
            Object instance = clazz.getDeclaredConstructor().newInstance();  
            beans.put(clazz, instance);  
        } catch (Exception e) {  
            throw new RuntimeException("创建bean失败");  
        }  
    }  
    //获取bean  
    @SuppressWarnings("unchecked")  
    public <T> T getBean(Class<T> clazz) {  
        return (T)beans.get(clazz);  
    }  
    //依赖注入  
    private void di() {  
        for (Object bean : beans.values()) {  
            Field[] fields = bean.getClass().getDeclaredFields();  
            for (Field field : fields) {  
                if (field.isAnnotationPresent(MyAutowired.class)) {  
                    field.setAccessible(true);  
                    Object dependency = getBean(field.getType());  
                    try {  
                        field.set(bean, dependency);  
                    } catch (Exception e) {  
                        throw new RuntimeException("依赖注入失败");  
                    }  
                }  
            }  
        }  
    }  
}  
//DAO层  
@MyComponent  
class UserDao {  
    public void save(String user) {  
        System.out.println("保存用户: " + user);  
    }  
}  
  
// Service层  
@MyComponent  
class UserService {  
    @MyAutowired  
    private UserDao userDao;  
  
    public void createUser(String name) {  
        userDao.save(name);  
        System.out.println("用户创建完成");  
    }  
}  
  
class Test {  
    public static void main(String[] args) {  
        SimpleIoC ioc = new SimpleIoC();  
        ioc.scan("package");  
        UserService bean = ioc.getBean(UserService.class);  
        bean.createUser("dong");  
    }  
}

参考链接：

LeetCode155.最小栈

Thu, 26 Feb 2026 14:17:10 +0000

第二次碰到这道题了，又学了两种解题方法，记录一下。

题目介绍

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

解法一：使用辅助栈

这个也是最简单的，题目没有空间限制，考虑使用两个栈，主栈正常记录元素进出，辅助栈记录每个元素对应最小值的进出，辅助栈的栈顶保持为主栈所有元素的最小值。

当元素入栈时，比较该元素和辅助栈的栈顶，如果该元素更小，那么将其推入主栈的同时也将其推入辅助栈。

当元素出栈时，如果主栈栈顶元素值和辅助栈的栈顶元素值相等。那么将该元素从两个栈里同时弹出，否则正常弹出主栈栈顶元素。

class MinStack {
    Deque<Integer> stack1;
    Deque<Integer> stack2;
    public MinStack() {
        stack1 = new ArrayDeque<>();
        stack2 = new ArrayDeque<>();
    }
    
    public void push(int val) {
        stack1.push(val);
        if (stack2.isEmpty() || val <= stack2.peek()) {
            stack2.push(val);
        }
    }
    
    public void pop() {
        int num = stack1.pop();
        if (num == stack2.peek()) stack2.pop();
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int getMin() {
        return stack2.peek();
    }
}

解法二：使用自定义链表

评论区有评论说面试官要求使用栈以外的数据结构来设计，所以找到这种方法。

LeetCode8.字符串转换整数

Sun, 15 Feb 2026 14:04:24 +0000

一切源于一道题目：8. 字符串转换整数 (atoi) - 力扣（LeetCode）

考虑这样一个问题：给你一个数字字符串，如何在32位环境下安全的处理可能超过[-2^31, 2^31 - 1]范围的数字，不能使用64位变量临时存储。

因为我熟悉Java，所以下面提到的数据类型都为 Java 中的数据类型。

Integer.MAX_VALUE = 2^31 - 1 = 2147483647;
Integer.MIN_VALUE = -2^31 = -2147483648;

首先题目说不能使用64位变量，所以 Long 类型不能使用，那就一步一步累加，具体思路就是设置两个变量 digit, res，从头到尾遍历字符串每一位，同时计算 res = res * 10 + digit。但这样的话，累加过程中 res 可能会无征兆直接溢出，程序直接抛异常。那怎么办，介绍一下从 K神题解里学来的方法。

整体思路也是一步一步累加，但提前预判溢出。

这里有个核心变量 bndry = 2^31 / 10 = 214748364，，它是32位有符号整数最大值去掉最后一位的结果。

在执行 res = res * 10 + digit 之前，先检查 res 与 bndry 的关系，有下面两种溢出的可能。

情况一：res > bndry ，意味着 res 乘10后，即使加上最小的数字0，结果也会超过 2147483647，溢出。
情况二：res == bndry，此时是否溢出取决于要累加的数字 digit。
- 如果 digit <= 7，此时正数负数都不会溢出，但等于七对正数来说已经达到最大值。
- 如果 digit = 8，拼接后值为 2147483648，比 Integer.MAX_VALUE 大 1，而负数即 -2147483648 还未溢出。
- 如果 digit > 8，正数负数都溢出。

思路还是很清晰的，在下一位拼接前进行判断可以很好的避开溢出问题。下面看一下题解代码

Java集合源码阅读

Mon, 26 Jan 2026 16:49:05 +0000

先附上二哥网站上关于集合框架的结构图

版本为JDK21

ArrayList 扩容机制

先介绍一下 ArrayList 中的关键变量：

transient Object[] elementData 底层用来存储元素的数组
private int size; 表示集合中元素的实际数量
private static final int DEFAULT_CAPACITY = 10; 默认初始容量
private static final Object[] EMPTY_ELEMENTDATA = {}; 当用户调用 new ArrayList(0) 时，elementData 会引用该数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 当用户调用默认构造参数时会引用该数组。

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                                                  minCapacity - oldCapacity, /* minimum growth */
                                                  oldCapacity >> 1           /* preferred growth */);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

private Object[] grow() {
    return grow(size + 1);
}

上面是有关扩容的源代码。

MySQL锁机制八股整理

Sat, 06 Dec 2025 16:17:23 +0000

整理一下MySQL锁的八股，全文整理自二哥博客。

在MySQL数据库中，锁是用来协调多个进程或线程并发访问同一资源的机制。锁不仅保证了数据的一致性和有效性，而且是影响数据库并发访问性能的一个重要因素。

共享锁与排他锁

共享锁也叫 S(shared) 锁，允许多个事务进行读操作，阻塞写操作。

排他锁也叫 X(exclusive) 锁，只允许一个事务进行读写操作，阻塞其他事务的读写操作。

兼容性如下：

表锁与行锁

表锁：锁定整个表，资源开销小，加锁快，但并发度低，不会出现死锁，适合查询为主、少量更新的场景（如 MyISAM 引擎）。可以细分为表级S锁、表级X锁。

行锁：锁定单行或多行，开销大、加锁慢，可能出现死锁，但并发度高（InnoDB 默认支持）。可以细分为记录锁、间隙锁、临键锁，也可以分为共享锁和排他锁（与表级S锁、表级X锁一个意思，前提是行锁）。

表锁详细版：

表锁常见于 MyISAM 引擎， InnoDB 也可手动加锁，适合读多写少、全表扫描或者表结构变更的场景。

LOCK TABLES table_name READ; -- 显式加读锁
select...                    -- 其他会话可读，不可写
UNLOCK TABLES;               -- 释放锁

LOCK TABLES table_name WRITE;    -- 显式加写锁 
INSERT/UPDATE/DELETE table_name; -- 其他会话读写均阻塞 
UNLOCK TABLES;

MyISAM 在执行 SELECT 时会自动加读锁，执行 INSERT/UPDATE/DELETE 时会加写锁。

对于 InnoDB 引擎，无索引的 UPDATE/DELETE 可能会导致锁升级为表锁。执行 ALTER TABLE 时会自动加表锁，阻塞所有读写操作。

行锁详细版：

行锁是 InnoDB 存储引擎中最细粒度的锁，它锁定表中的一行记录，允许其他事务访问表中的其他行。

底层是通过给索引加锁实现的，这就意味着只有通过索引条件检索数据时，InnoDB 才能使用行级锁，否则会退化为表锁。

MySQL索引八股整理

Mon, 24 Nov 2025 15:14:51 +0000

整理一下MySQL索引的八股。

索引介绍

索引是数据库中用于加速查询的数据结构，通过对表中某列或多列的值进行排序，可以快速定位所要查找的数据。就像小时候在汉语字典里查字时，会先根据偏旁笔画数找到偏旁，然后根据剩余笔画找到目标字，这比在整个字典中一个一个查找是快很多的。

索引分类

索引有以下分类

索引详细介绍

主键索引：

主键索引用于唯一标识表中的每条记录，其值必须唯一且非空。每个表只允许有一个主键索引，一般为表中的自增id。

创建主键时，数据库会自动生成主键索引。若没有指定主键，MySQL的InnoDB存储引擎会优先选择一个非空的唯一索引作为主键，如果没有符合条件的索引，MySQL会自动生成一个隐藏的聚簇索引。

唯一索引：

主键索引 = 唯一索引 + 非空，每个表可以有多个唯一索引，同时唯一索引允许值为NULL，这是和主键索引不同的地方。唯一索引强制字段值的唯一性，插入或更新时会触发唯一检查，适用于业务唯一性约束的字段，比如邮箱。在建表定义唯一键时，会自动生成唯一索引。

键和索引的区别在于键是逻辑概念，而索引是物理实现，在磁盘中有着实际的存储。

普通索引：

普通索引仅用于加速查询，不会限制字段值的唯一性。

全文索引

全文索引是MySQL一种优化文本数据检索的特殊类型索引，适用于CHAR, VARCHAR, TEXT等字段。MySQL 5.7 及以上版本内置了 ngram 解析器，可处理中文、日文和韩文等分词。全文索引底层不再是 B+ 树索引。

建表时通过 FULLTEXT (title, body) 来定义。通过 MATCH(col1, col2) AGAINST('keyword') 进行检索，默认按照降序返回结果，支持布尔模式查询。

+ 表示必须包含；
- 表示排除；
* 表示通配符；

-- 使用布尔模式查询
SELECT * FROM articles 
WHERE MATCH(title, content) AGAINST('+MySQL -Oracle' IN BOOLEAN MODE);

这样查询性能比LIKE '%keyword%'高很多。对于复杂的中文场景可以用Elasticsearch等专业搜索引擎替代。

B+ 树索引：

B+ 树是一种高度平衡的多路查找树，能有效降低磁盘的 IO 次数，并且支持有序遍历和范围查询。

Java泛型

Tue, 14 Oct 2025 14:40:44 +0000

泛型定义

先看这样一个例子：

public static void main(String[] args) {
	List list = new ArrayList();
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	for (int i = 0; i < list.size(); i++) {
		System.out.println((String)list.get(i));
	}
}

ArrayList集合中可以加入任何类型的对象，我本意是用这个集合来存储字符串（因为ArrayList默认存储的是Object类型的对象，所以输出时需要强转），但我粗心的写错了list.add(123)，在我运行后发现报错java.lang.ClassCastException，显然报错原因就是输出时Integer类型并不能强转为String类型。那么如何避免这种情况呢，答案就是泛型。

借用一下维基百科的定义：

泛型程序设计是程序设计语言的一种风格或范型，泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。

说一下我的理解，泛字让我联想到了一个词语：泛泛而谈，指那些浮浅平淡，不深入的谈话。这里也可以这样理解，定义时我模糊的说明一下参数，不指明参数具体是哪种类型，等我使用时再说明。

有这样一种说法：泛型的本质就是“参数化类型”。想象一下，定义一个方法需要形参，待你调用时，又需要传递实参。泛型亦是如此，定义时形式上意思意思，真正使用时再说明。其实都一个意思。

下面我将从泛型类、泛型方法、泛型接口、通配符、类型擦除五个方面来对Java泛型进行详细说明。

泛型类

来看一下ArrayList这个类的定义

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{...}

相比其他普通类，这个类的类名称后面多了个<E>，这就是泛型类的核心标识，其中 E 为类型参数，理论上可以为任何字母，但有一些约定俗成的习惯

T：代表一般的任何类
E：element 元素的意思
K：代表 key 的意思
V：代表 value 的意思，经常和 K 搭配作为键值对

关于类型参数怎么用，来看个例子。

正则表达式

Mon, 22 Sep 2025 16:40:40 +0000

介绍

正则表达式（regular expression），常简写为regex，用简单字符串来描述、匹配文中全部匹配指定格式的字符串。人话讲就是根据一些规则制定一个字符串，然后你可以用这个字符串来筛选满足规则的字符串。许多程序设计语言都支持用正则表达式操作字符串，这里主要介绍正则表达式在Java中的运用。

不同编程语言的正则表达式引擎有所不同，这里提供一个链接，里面详细介绍了不同语言对各种特性的支持程度。

快速使用

先说明一下\的使用。

在Java普通字符串中，反斜杠\本身就是转义字符，比如\n被转义为"换行符"，又比如\\被转义为\。而正则表达式也有自己的语法，它也使用反斜杠作为转义字符，比如\d表示“匹配一个数字”。

那么二者结合起来呢🧐。以"\\d"为例。编译器看到字符串"\\d"会根据字符串规则将其转换为两个字符，一个\，一个d。接下来正则表达式引擎会对其进行解析，最终生效的正则模式就是\d。可以这样理解：正则表达式需要 \d 来匹配数字。但在Java字符串里，一个 \ 需要写成 \\。所以，要把正则的 \d 放到Java字符串里，就变成了 \\d。

到底需不需要两个\\，idea会给你答案。

java.util.regex包是Java标准库中用于支持正则表达式操作的包，主要涉及到Pattern和Matcher这两个类的操作。这里有个简单的例子：

String pattern = "java\\d";
String text1 = "java1";
String text2 = "javaBad";

Pattern p = Pattern.compile(pattern);

Matcher m = p.matcher(text1);
System.out.println(m.matches());//true
m = p.matcher(text2);
System.out.println(m.matches());//false

先调用Pattern类的静态方法compile（参数为正则表达式）生成一个实例对象，通过调用该对象的matcher方法（参数为待匹配文本）生成一个Matcher实例。接下来就有很多方法供你选择，这里我调用的是matches方法来输出布尔值，在例子中体现为字符串Java后面能否匹配上数字。Matcher类里还有个find方法也很常见，下文会提到。

匹配规则详解

简单匹配

为方便演示，接下来的示例代码使用String类的matches方法，该方法底层原理仍然是Pattern和Matcher这两个类的使用，后面有详细说明。下面示例参考廖雪峰和菜鸟教程。

匹配任意字符：.可以匹配除\r\n之外的任何单个字符。如a.c可以匹配abc但不能匹配abbc和ac

匹配数字：\d匹配 0~9 的数字，同样只匹配一个字符。匹配非数字：\D匹配非数字。

匹配常用字符：\w可以匹配一个字母、数字或下划线

匹配空格字符：\s可以匹配任何空白字符，包括空格、制表符、换页符等。与[\f\n\r\t\v]等效。\W和\S和\D同样是反着来的。

重复匹配：

*可以匹配任意个字符，包括0个字符。

+可以匹配至少一个字符。比如A\d+可以匹配A11111和A0。但不能匹配A,因为至少一个字符。

?可以匹配0个或一个字符。

如果想精确指定n个字符，使用{n}，比如A\d{3}可以匹配到A123。指定匹配n~m个字符，用{n,m}，例如A\d{3,5}可以精确匹配A123 A1234 A12345。{n,}表示可以匹配至少n个字符。m和n为非负整数，其中n <= m。再举一个例子:o{2}和Bob中的一个o不匹配，而匹配food中的两个o。不同表达式可能是等效的，比如o{0,1}和o?

来个综合点的例子：假如电话号码规则如下:3~~4位数字表示区位，7~~8位数字表示电话，中间用-连接。答案：\\d{3,4}-\\d{7,8}。对于连字符-，一般情况下只是一个普通字符，不需要进行转义，当然写上两个反斜杠也是对的，idea会给出提示移除多余的反斜杠。

String pattern = "\\d{3,4}-\\d{7,8}";//不知道需不需要写\？idea会给你的答案
String text1 = "0123-123456";
String text2 = "010-1234567";
System.out.println(text1.matches(pattern));//false
System.out.println(text2.matches(pattern));//true

复杂匹配：

匹配开头和结尾：^匹配输入字符串开始的位置，$匹配输入字符串结束的位置。他们俩的作用是将匹配过程限制在整个字符串上，避免了在子串中成功匹配的情况。其实matches()方法的行为已经隐含了^...$锚点的效果，而find()方法则没有。matches方法尝试将整个输入序列与模式匹配，而find方法会在输入序列中查找下一个与模式匹配的子序列。仔细品味这两个方法的名字，你也许会理解。

Java反射

Sun, 10 Aug 2025 15:06:57 +0000

什么是反射

在spring项目中，只需要写个@Service或者@Component，然后在别的地方用@Autowired声明一个接口变量，Spring就能返回给我们一个实现了该接口的具体对象。这是如何实现的呢？它不可能在编译时就知道加了注解的类与类之间的关系，所以只能是在程序启动运行时，Spring动态地发现了这些类，读取了他们的结构，然后创建对象。这背后的技术支撑又是什么？答案就是反射。

反射是Java提供的一种在程序运行时

检查/获取类、接口、字段、方法、构造器等结构信息的能力。
操作/调用对象、字段、方法的能力。

它就像一面镜子，让程序在运行时“照见”自己的结构。

反射的基石：`Class`对象

编译器在编译 Java 源代码时会生成 .class 文件（字节码文件）。当 JVM 需要用到某个类时，它的类加载器会读取并解析对应的 .class 文件，在方法区（或元空间）构建该类的运行时数据结构，同时在堆内存中创建一个代表该类的 java.lang.Class 对象。每个被加载的类在 JVM 中都有且只有一个对应的 Class 对象（在同一个类加载器命名空间内）。

这里的Class是一个类的名字，不要和class关键字搞混。

有三种方法获取Class对象

Person person = new Person("me", 20);
//法一：通过对象实例
Class< ? extends Person> clazz1 = person.getClass();
//法二：自带属性（基本数据类型也有）
Class<Person> clazz2 = Person.class;
//法三：Class类的静态方法 forName
try {
	Class<?> clazz3 = Class.forName("org.myblog.reflection.Person");
} catch (ClassNotFoundException e) {
	throw new RuntimeException(e);
}

解释一下这三种方法泛型的使用：法一使用Class<? extends Person> 因为Class对象是在运行时从Person实例获取的，而Person实例的具体类型只能在运行时创建和确定，编译阶段无法判断，所以使用通配符，又因为person可能是Person实例，也可能是Person的子类实例，所以最终写成Class< ? extends Person>；法二使用Class<Person>因为编译时已知具体类型；法三使用Class<?>因为通过字符串动态加载类，编译时无法确定具体类型，所以使用通配符。这三个 Class 对象都是同一个（上面也提到了，一个类唯一对应一个 Class 对象）。

遇到的奇葩BUG

Sat, 02 Aug 2025 11:16:00 +0000

此篇博客记录我学习过程中遇到的奇葩BUG

`SpringBoot`项目启动失败

如上图，SpringBoot项目启动失败。

虽然说是端口占用，但我执行相关命令后没有任何输出，修改启动端口不行，尝试了很多办法都未成功，那只好使出我的终极大招：重启idea。还是不行。幸好我还有终极终极大招：重启电脑。嘿，你猜怎么着，成了！🤣

接口测试报错`getaddrinfo ENOTFOUND https`

一次简单的接口测试，出现报错getaddrinfo ENOTFOUND https，搜索后得到答案：这通常意味着应用程序无法解析主机名或域名。这可能是由于DNS配置问题、网络连接问题或拼写错误等原因导致的。前两个果断排除，开始以为参数错，但一想那不应该试着错误，后来想可能域名错，但也没找到错误。最后发现是https:后面多了个空格。😑

mysql容器连接报错

情况描述：本机为windows系统，装有wsl。在配置一个项目时使用docker-compose命令构建项目所需容器。构建好容器后，我测试mysql是否连接成功，结果出现报错2013 - Lost connection to server at 'handshake: reading initial communication packet', system error: 0.

于是到网上搜索解决方案，有注释掉bind-address = 127.0.0.1的，有添加配置skip-name-resolve的，还有换系统的，但都无法解决我的问题。直到看见这篇博客CSDN博客。于是我直接修改docker-compose.yaml文件，添加network_mode: host，同时从豆包处得知：使用 host 网络模式后，容器会直接使用宿主机的网络栈，因此 ports 配置会被忽略。如果需要 MySQL 监听 3307 端口，需在 MySQL 配置文件（/etc/my.cnf 目录下的配置）中添加 port=3307，照做后问题解决。

还要记得修改application.yml中的端口设置。

Java序列化与反序列化

Mon, 07 Jul 2025 21:03:57 +0000

什么是序列化和反序列化

序列化，人话讲就是将对象转换为字节序列（也可以是JSON、XML等文本格式），反序列化就是把这个过程倒置。

下面是维基百科关于序列化的介绍

序列化（serialization）在计算机科学的资料处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。

对于Java这种面向对象的编程语言来说，是对实例化后的对象进行序列化，而对于C++这种半面向对象的编程语言来说，序列化的目标不仅有对象（class）还有数据结构（struct）

序列化的使用场景

数据存储：比如序列化可以将存储在 JVM 堆区中的对象转换成字节序列，从而实现持久化。
网络通信：将对象转换为字节序列方便其在网络中进行传递和接收。

使用Java实现序列化

以 JDK 自带序列化方法为例，实现java.io.Serializable接口

@Data
public class Cat implements Serializable {
    private int age;
    private String name;
    private Date birth;
}

序列化演示：

public class serializeTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("tom");
        cat.setAge(2);
        cat.setBirth(new Date());
        //使用ObjectOutputStream将cat对象序列化并存入test1.txt文件中
        try (FileOutputStream fileOutputStream = new FileOutputStream("test1.txt");
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream)) {
            objectOutputStream.writeObject(cat);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

反序列化演示：

我的第一篇文章

Sun, 20 Nov 2022 09:03:20 -0800

简介

这是粗体文本，这是斜体文本。

访问 Hugo 网站！