技术 on Calendar's Blog

Arch 问题备份

Tue, 04 Nov 2025 00:00:00 +0000

缩放问题

原因其实是因为这些软件默认运行在XWayland下（VSCode、Spotify），有的不支持Wayland（微信）。终端运行xprop，将光标放到软件界面，如变成十字则软件运行在Xwayland。

解决方法

参考：Gnome(Wayland)相关问题

针对缩放模糊问题，目前最好的方法就是不进行分数缩放，而是通过整数缩放+字放大体的方式调整

ArchLinux 安装及初步配置

Mon, 03 Nov 2025 00:00:00 +0000

好几天没写博客了，一是期中考，二是不知道要学些什么了。网上看见推荐 Linux 系统的文章，正好试一试自己装系统。

安装

安装花了大概一天时间，参考了 Arch Linux 简明指南，没什么太大问题。主要是教程中的做法是将 Arch 的 boot 挂载到了 Win 里面，做下来发现 Win 的 EFi 分区已经满了……

然后就是研究怎么挂载到一个新的分区，和挂载顺序有比较大关系。

大体步骤是：

Windows 当中划分出空硬盘区
U盘拷贝镜像，做系统盘，把 Win 的磁盘解密
进 Bios 引导安装
用 cfdisk 对空闲盘进行分区，swap、boot、btrfs
划分子卷，挂载分区
启动！

配置

配置还是比较伤脑筋的，首先是适应安装工具 pacman。大概就是一个官方提供的包管理工具，需要自己换源。后续还添加了yay、paru（第三方包库，资源丰富但是没有镜像站）、flatpak（体验比较好，速度能接受）。

然后是桌面环境。尝试了 gnome、hyprland、niri 以后，都感觉不太适应，还没有从 win 的操作模式转换过来。主要是各个组件都要自己配。从 waybar、swaybg，到 bluez、swaylock，有很多选择，又眼花缭乱。并且每有体系化的教学、整合，就感觉很乱。

比较喜欢 niri 的操作模式，觉得比较酷，就着重配置 niri 的环境了。比较麻烦的是截图，在 firefox 试了半天，发现 firefox 不能贴图……其实截图功能也已经比较完善了，基本能和 win 一样地操作。接下来是网络，被 yay、paru 的下载速度折磨了很久，clash 的机场又不太稳定了，不知道是哪里的问题。半天才发现 shell 需要额外配置代理……但速度还是不太能用，有机会再优化一下吧，先这样。

其他

其实 Linux 也就是一个操作系统，不可能换了个系统就一劳永逸了，还是会有很多问题。算是满足自己的好奇心，去尝试一下新的可能。其实确实能感受到 Linux 的环境已经很完善了，比如现在写博客的流程，就能从 Win 复刻到 Linux 上。可能需要的就是一些解决问题的耐心。

虽然把系统装好了，但是对原理没什么更多的理解，基本就是需求-碰到问题-搜索-解决问题，不能形成整体性的知识。既然装好了就试着用下去吧。

C++ 模板及STL技术

Tue, 14 Oct 2025 00:00:00 +0000

模板

建立通用的模具，提高复用性

函数模板

作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
支持自动类型推导和显式指定类型

//函数模板
template<typenameT>//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void mySwap(T &a,T &b)
{
    T temp = a;
    a=b;
    b = temp;
}
myswap<int>(a,b)

注意：

自动类型推导，必须推导出一致的数据类型T，才可以使用
模板必须要确定出 T 的数据类型，才可以使用（不能不推导）

普通函数和模板函数的区别

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换

调用规则：

优先调用普通函数
可通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配，优先周用函数模板

局限性

需要为特定的类型（如数组、自定义对象等）提供具体化模板

template<>bool myCompare (Person &p1, Person &p2)
{
    if(p1.name == p2.name){
        return true;
    }
    else
    {
        return false;
    }
}

类模板

1
2

teplate<typename T>
class ...

与函数模板的区别

没有自动类型推导
可以有默认参数类型

成员函数创建时机

在模板调用（可以确定类型）时，才创建

类模板对象作参数

指定传入类型
参数模板化
- 对象中的参数变为模板进行传递
整个类模板化

类模板与继承

类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
- 若不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板

类模板成员的类外实现

//构造函数类外实现
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    this->m_Name = name;
    this->m_Age = age;
}

//成员函数类外实现
template<class T1, class T2> 
void Person<T1, T2>::showPerson()
{
    
}

类模板分文件编写

问题：

模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

类模板与友元

类内实现：直接在类内声明友元即可
类外实现：需要提前让编译器知道全局函数的存在

STL

初识

Standard Template Library：标准模板库

主要组件：容器、算法、迭代器
容器和算法通过迭代器连接
STL 采用模板实现

六大组件：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

容器：数据结构
- 序列式：强调值的排序
- 关联式：如树，没有严格的物理联系
算法 Algorithms：实现常用算法
- 质变：与原来不同
- 非质变：查找、计数、遍历等
迭代器：胶合容器和算法
- 类似指针，提供访问容器的接口
- 双向、随机访问
仿函数：行为类似函数，可所谓算法的某种策略
适配器（配接器）：用于修饰容器、算法、迭代器或接口
空间配置器：负责空间的配置和管理

vector 使用

#include <vector>

vector<int> v;
v.pushback()
v.begin(); // 返回迭代器，指向容器中第一个数据
v.end(); // 指向容器最后一个数据的下一个位置
vector<int>::iterator pBegin = v.begin() // 接收
    
//第一种遍历方式:
while (pBegin != pEnd) {
    cout << *pBegin << endl;
    pBegin++;
}

//第二种遍历方式:
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
    cout << *it << endl;
}
cout << endl;

//第三种遍历方式:
//使用STL提供标准遍历算法 头文件 algorithm
for_each(v.begin(), v.end(), MyPrint);

String

string 是 C++ 风格的字符串，本质是一个类

类内部封装 char*，是管理 char* 的容器

构造函数

string();//创建一个空的字符串例如：stringstr;
string(const chan* s);//使用字符串s初始化
string(const string& str）;//使用一个string对象初始化另一个string对象
string(Int n, char c);//使用n个字符c初始化

赋值

string& operator=(const char*s);//char*类型字符串赋值给当前的字符串
string& operator=(const string &s）;//把字符串s赋给当前的字符串
string& operator=(char c);//字符赋值给当前的字符串
string& assign(const char *s);//把字符串s赋给当前的字符串
string& assign(const char *s,int n);//把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s);//把字符串s赋给当前字符串
string& assign(int n,char c);//用n个字符c赋给当前字符串

拼接

string& operator+=(const char*str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& operator+=(const string& str);//重载+=操作符
string& appnd(const char *s);//把字符串s连接到当前字符串结尾
string& append(const char *s,int n);//把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s);//同operator+=(const string&str)
string&append(conststring&s，intpos，intn);/字符串s中从pos开始的n个字符连接到字符串结尾

查找、替换

// 查找 str 第一次出现位置，从 pos 开始查找
int find(const string& str, int pos = 0) const;
// 查找 s 第一次出现位置，从 pos 开始查找
int find(const char* s, int pos = 0) const;
// 从 pos 位置查找 s 的前 n 个字符第一次位置
int find(const char* s, int pos, int n) const;
// 查找字符 c 第一次出现位置
int find(const char c, int pos = 0) const;
// 查找 str 最后一次位置，从 pos 开始查找
int rfind(const string& str, int pos = npos) const;
// 查找 s 最后一次出现位置，从 pos 开始查找
int rfind(const char* s, int pos = npos) const;
// 从 pos 查找 s 的前 n 个字符最后一次位置
int rfind(const char* s, int pos, int n) const;
// 查找字符 c 最后一次出现位置
int rfind(const char c, int pos = 0) const;
// 替换从 pos 开始 n 个字符为字符串 str
string& replace(int pos, int n, const string& str);
// 替换从 pos 开始的 n 个字符为字符串 s
string& replace(int pos, int n, const char* s);

比较

1
2

int compare(const string& s)const; //与字符串s比较
int compare(const char *s) const;//与字符串s比较

字符存取

1
2

char& operator[] (int n);//通过[方式取字符
char& at(int n);//通过at方法获取字符

插入、删除

string& insert(int pos, const char*s);//插入字符串
string& insert(int pos,const string& str);//插入字符串
string& insert(int pos,int n,char c);//在指定位置插入n个字符c
string& erase(int pos,int n = npos);//删除从Pos开始的n个字符

截取

`1`	`string substr(int pos=θ,int = npos)const;`

vector

据结构和数组非常相似，也称为单端数组

数组是静态空间，而 vector 可以动态扩展
动态扩展：不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

构造

vector<T>v;//采用模板实现类实现，默认构造函数
vector(v.begin(),v.end());//将v[begin(),end()区间中的元素拷贝给本身。
vector(n,elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。

赋值

1
2
3

vector& operator=(const vector &vec);//重载等号操作符
assign(beg,end);//将[beg，end)区间中的数据拷贝赋值给本身。
assign(n,elem);//将n个elem拷贝赋值给本身。

容量

empty();//判断容器是否为空
capacity();//容器的容量
size();//返回容器中元素的个数
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
resize（intnum，elem)；//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除

插入、删除

push_back(ele);//尾部插入元素ele
pop_back();//删除最后一个元素
insert(const_iterator pos,ele);//选代器指向位置pos插入元素ele
insert(const_iteratorpos，intcount，ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos);//删除选代器指向的元素
erase(const_iteratorstart，const_iteratorend);//删除迭代器从start到end之间的元素
clear();//删除容器中所有元素

存取

at(int idx);//返回索引lidx所指的数据
operator[];//返回索引lidx所指的数据
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素

呼唤

swap(vec)

收缩空间：vector<int>(v).swap(v)

匿名对象自动被回收

预留空间

reserve(int len)

分配内存，但内存上数据并未初始化，不可访问
用于减少开辟空间次数

C++ 核心编程

Mon, 13 Oct 2025 00:00:00 +0000

内存分区模型

程序运行前

编译后生成 exe 可执行程序，分为两个区域

代码区：

存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令

全局区：

全局变量和静态变量存放在此
- 局部变量（即使用 const 修饰）不在全局区中
全局区还包含了常量区，字符串常量和其他常量也存放在此
- const 修饰的全局常量、字符串常量
该区域的数据在程序结束后由操作系统释放

程序运行后

栈区：

由编译器自动分配释放，存放函数的参数值，局部变量等
- 注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放（如函数的形参、局部变量）

堆区：

由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
在 C++ 中主要利用 new 在堆区开辟内存

int * func ()
{
    //利用new关键字可以将数据开辟到堆区
    //指针本质也是局部变量，放在栈上，指针保存的数据是放在堆区
    int * p=newint(10) ;
    return p;
}

new 操作符

C++中利用new操作符在堆区开辟数据

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
- delete 对应指针
利用new创建的数据，会返回该数据对应的类型的指针

// 创建数组
int* a = new int(length);
//释放数组的时候要加[]才可以,指明一段内存空间
delete[] arr;

引用

给变量起别名

变量的含义：用于指代，操作某块内存

1
2

// 语法：数据类型&别名=原名
int &b = a;

注意事项

引用必须初始化
初始化后不可再改变

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

//1.值传递
void mySwap01（int a,int b）{
    int temp=a;
    a = b
    b = temp;
}
//2.地址传递
void mySwapθ2（int *a,int *b）{
    int temp*a;
    *b;
    *b=temp;
}
//3.引用传递,别名和本名可以相同
void mySwap03（int &a，int &b）{
    int temp =a;
    a = b
    b = temp;
}

引用做返回值

注意：不要返回局部变量引用

用法：函数调用作为左值

//2、函数的调用可以作为左值
int& test02(
{
    staticinta=10;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
	return a;
}
test02() = 1000 // 支持

引用的本质

本质是指针常量，由编译器转换为指针

1
2
3

//自动转换为 int*constref=&a；指针常量是指针指向不可改，也说明为什么引用不可更改
int& ref=a;
ref = 20；//内部发现 ref 是引用，自动帮我们转换为：*ref=20；

常量引用

//常量引用
//使用场景：用来修饰形参，防止误操作
//int& a = 10; 这行错误，非法空间
//加上const之后编译器将代码修改int temp = 10;const int &rettemp;
const int& ref=10；//引用必须引一块合法的内存空间

函数

默认参数

C++中，函数的形参列表中的形参是可以有默认值的

1
2
3

int func(int a,int b = 20 ， int c = 30){
	return a + b + c;
}

如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
如果函数声明有默认参数，函数实现就不能有默认参数

占位参数

//函数占位参数，占位参数也可以有默认参数
void func（int a，int）{
	cout<<“thisisfunc"<<endl;
}

重载

作用：函数名可以相同，提高复用性

函数重载满足条件：

同一个作用域下
函数名称相同
函数参数类型不同或者个数不同或者顺序不同
- 返回值不同不可以作为条件

注意

引用作为重载条件
- 以 const 为标志的区分，是否可写
数重载碰到函数默认参数
- 出现二义性，报错

类和对象

封装

意义：

属性和行为作为一个整体，表现生活中的事物
属性和行为加以权限控制

语法：class 类名 { 访问权限：属性/行为 }；

class circle {
    public:
    	int r;
    	double calculateC(){
            return 2 * PI * r;
        }
}

Circle c1; // 实例化
c1.r = 10; // 给属性赋值

类中的属性和行为统一称为成员

成员属性 –> 成员变量
成员函数 –> 成员方法

访问权限

public：类内可以访问，类外可以访问

protected：类内可以访问，类外不可以访问，继承类可访问

private：类内可以访问，类外不可以访问。

Struct 和 Class

唯一的区别就在于默认的访问权限不同

struct 默认权限为公共
class 默认权限为私有

成员属性私有化

优点：

所有成员属性设置为私有，可以自己控制读写权限
对于写权限，我们可以检测数据的有效性

用 set 、get 方法控制权限、操作

对象的初始化和清理

构造函数和析构函数

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
- 没有返回值也不写void
- 函数名称与类名相同 类名(){}
- 构造函数可以有参数，因此可以发生重载
- 程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
- 没有返回值也不写void
- 函数名称与类名相同，在名称前加上符号 ~
- 析构函数不可以有参数，因此不可以发生重载
- 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

构造函数分类与调用

分类：

按参数分为：有参构造和无参构造
- 使用默认无参构造时，不要加括号，否则会认为是函数声明
按类型分为：普通构造和拷贝构造
- 不要用拷贝构造函数初始化匿名对象，编译器会认为 Person(p3) === Person p3

//拷贝构造函数
Person(const Person& p）{
	age =p.age;
}

调用方式：括号法，显式法，隐式转换法

//1、括号法
Person p1；//默认构造函数调用
Person p2(10)；//有参构造函数
Person p(p2)；//拷贝构造函数

//2、显示法
Person p1; //不能加括号
Person p2=Person(10)；//有参构造
Person p3=Person（p2）；//拷贝构造
Person(10)；//匿名对象特点：当前行执行结束后，系统会立即回收掉匿名对象

1
2
3

//3、隐式转换法
Person p4 = 10;//相当于写了Person p4 =Person(10);有参构造
Person p5 = p4;// 拷贝构造

拷贝构造函数的调用时机

使用一个已经创建完毕的对象来初始化一个新对象
传递的方式给函数参数传值
值方式返回局部对象
- 在函数内部创建的对象被返回时，会创建一个新的对象返回

拷贝构造函数的调用规则

默认情况下，C++编译器至少给一个类添加3个函数：

默认构造函数（无参，函数体为空）
默认析构函数(无参，函数体为空)
认拷贝构造函数，对属性进行值拷贝

定义有参构造函数，C++ 不再提供默认无参构造，但是会提供默认拷贝构造

定义拷贝构造函数，C++ 不会再提供其他构造函数

深浅拷贝

浅：简单的赋值拷贝

默认提供的是浅拷贝

深：在堆内存重新创建一块内存，进行拷贝

涉及到申请堆区时，需要深拷贝

初始化列表

//初始化列表初始化属性
Person(int a, int b,int c) :m_A(a),m_B(b), m_C(c)
{
    ...
}

类作为类成员

当类有嵌套时，会先构造内部对象，析构顺序与构造相反

静态成员

静态成员变量：

所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化

静态成员函数：

所有对象共享同一个函数
只能访问静态成员变量
- 因为调用函数时，无法定位非静态成员变量（属于特定对象）

可以通过对象，也可以直接通过类名访问，有访问权限

内存模型和 this 指针

内存：

类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上

this 指针：

指向被调用的成员函数所属的对象，隐含在每一个非静态成员函数内
当形参和成员变量同名时，可用this指针来区分
- this -> name
在类的非静态成员函数中返回对象本身，可使用 return *this
- 实现链式编程

Person& PersonAddAge(Person &p)
{
    this->age += p.age;
    //this指向p2的指针，而*this指向的就是p2这个对象本体
    return *this;
}

注意返回 Person**&**，值返回会调用拷贝函数创建一个新的对象

空指针访问成员函数

1
2
3

Person * p = NULL;
p->showClassName ();
// 只要所调用的函数中没有使用到 this 即可(包含隐含的 this，用于访问属性)

const 修饰成员函数

常函数：

成员函数后加const后我们称为这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，则在常函数中也可以修改

//this指针的本质是指针常量指针的指向是不可以修改的
const Person * const this; // 设置指针指向的值也无法修改
void showPersonO() const{
    this->m_A = 100;
}
//this=NULL；  //this指针不可以修改指针的指向

常对象：

声明对象前加const称该对象为常对象
对象只能调用常函数

友元

使一个函数或者类访问另一个类中私有成员，关键字friend

三种实现：

局函数做友元
类做友元
成员函数做友元
- friend void clazz::method();

在类中声明 friend，被声明的可以访问本类的私有属性

运算符重载

定义自定义类型的运算方式

成员函数重载：

//1、成员函数重载+号，本质调用：Person p3 =pl.operator+(p2);
Person operator+(Person &p)
{
    Person temp;
    temp.m_A=this->m_A +p.m_A；
    temp.m_B =Ithis->m_B +p.m_B;
    return temp;
}
//2、全局函数重载+号,本质调用：Person p3 = operator+(pl,p2);
Person operator+(Person &pl,Person &p2)
{
    Person temp;
    temp.m_A =pl.m_A +p2.m_A;
    temp.m_B=pl.m_B+p2.m_B;
    return temp;
}

左移

只能通过全局函数重载

//只能利用全局函数重载左移运算符
void operator<<(ostream &cout,Person &p)//本质: operate<< (cout,p)
{
    cout << p.name;
    return cout;
}

递增

//重载前置++运算符返回引用为了一直对一个数据进行递增操作
MyInteger& operator++()
{
    //先进行++运算
    m_Num++;
    //再将自身做返回
    return *this;
}

//重载后置++运算符
//void operator++(int) int代表占位参数，可以用于区分前置和后置递增
MyInteger operator++(int)
{
    //先记录当时结果
    MyInteger temp = *this;
    //后递增
    m_Num++;
    7/最后将记录结果做返回
    return temp;
}

赋值

默认实现为浅拷贝，p1 = p2

// 重载赋值运算符
Person& operator=(Person &p)
{
    if (m_Age != NULL)
    {
        delete m_Age;
        m_Age = NULL;
    }

    // 编译器提供的代码是浅拷贝
    // m_Age = p.m_Age;

    // 提供深拷贝 解决浅拷贝的问题
    m_Age = new int(*p.m_Age);

    // 返回自身
    return *this;
}

注意：返回引用，可以操作自身；返回值，会拷贝出一个对象。目的是为了实现连等

关系

bool operator==(Person &p)
{
    if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }
}

函数调用（）

仿函数

非常灵活

//重载函数调用运算符
void operator() (string test)
{
    cout<< test << endl;
}

继承

下级别的成员除了拥有上一级的共性，还有自己的特性，抽取出父、子

用于减少重复代码

class son : public father
{
    ...
}

继承方式

向下压级，私有被隐藏，但还是会继承

继承的对象模型

父类中所有非静态成员属性都会被子类继承下去

构造、析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

先有父，后有子；析构相反

同名成员处理

父类加作用域
- s.base::func();
- 只要子类有同名，父类函数全都被隐藏（重载也不行）
子类直接访问

同名静态成员

静态成员和非静态成员出现同名，处理方式一致

多继承

class son: type fa1,type fa2

不建议，父类命名可能重复

菱形继承

一出二，二合一

孙类继承了两份父类的相同数据，产生冗余
利用虚继承解决菱形继承

//利用虚继承解决菱形继承的问题
//继承之前加上关键字virtual变为虚继承
//Anima1类称为虚基类
[//羊类
class Sheep0:virtual public Animal{}：
//驼类
class Tuo :virtual public Animal{};
//羊驼类
class SheepTuo :public ISheep, public Tuo{};

多态

基本概念

多态分为两类

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态
- 有派生类时，动态绑定子类重写的虚函数（父类指针指向子类对象）

静态多态和动态多态区别：

静态多态的函数地址早绑定－编译阶段确定函数地址
动态多态的函数地址晚绑定－运行阶段确定函数地址

class Animal
{
public:
    //Speak函数就是虚函数
    //函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

class Cat :public Animal
{
public:
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

原理：

子类重写父类虚函数时：子类中的虚函数表内部会替换成子类的虚函数地址

优点：

满足“开闭原则”

扩展对外开放，修改对外关闭

组织结构清晰，可读性强
可维护性强

纯虚函数和抽象类

virtual 返回值类型函数名（参数列表）= θ；

当类中有了纯虚函数，这个类也称为抽象类

抽象类无法实例化
子类必须重写父类的纯虚函数，否则子类也是抽象类

虚析构与纯虚析构

共性：

解决父类指针释放子类对象
- 原因：父类指针指向子类对象，delete 的时候只调用父类的析构函数
都需要有具体的函数实现

差异：

如果是纯虚析构，该类属于抽象类，无法实例化对象
- 虚析构函数需要被实现

若堆中没有数据，可以不写

文件操作

文本文件

文件以 ASCII 码存储

操作文件的三大类：

ofstream：写操作
ifstream：读操作
fstream：读写操作

写文件

步骤：

包含头文件 #include <fstream>
创建流对象 ofstream ofs;
打开文件 ofs.open("文件路径",打开方式);
写数据 ofs<<"写入的数据";
关闭文件ofs.close()

二进制

ios::binary

Mybatis

Sun, 12 Oct 2025 00:00:00 +0000

Mybatis

介绍

轻量级，性能出色
封装 JDBC
SQL 和 Java 编码分开，功能边界清晰。Java 代码专注业务、SQL 语句专注数据
官网：https://mybatis.org/mybatis-3/zh/#

使用

创建SpringBoot工程、引入Mybatis相关依赖
准备数据库表即对应实体类
配置 Mybatis（在application.properties中数据库连接信息）

编写 Mybatis 程序：编写 Mybatis 的持久层接口，定义 SQL（注解/XML）

@Mapper：应用程序在运行时，会自动的为该接口创建一个实现类对象（代理对象），并且会自动将该实现类对象存入I0C容器

辅助配置

定义注解的语句为 MySQL 语法
IDEA 连接数据库
日志

1
2

#配置mybatis的日志输出
mybatis.configuration.logimpl=org.apache.ibatis.logging.stdout.StdoutImpl

数据库连接池

数据库连接池是个容器，负责分配、管理数据库连接（Connection）
- 资源重用
允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
- 提升系统响应速度
释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏
- 避免数据库连接遗漏

// 引入德鲁伊连接池
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.19</version>
</dependency>

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

底层实现 DataSource 接口

操作

新增

1
2

@Insert("insert insert(username,password,name,age) values (#{username},#{password},#{name},#{age})") // 写的是对象属性名
public void insert(User user2);

删除

1
2
3

@Delete("delete from user where id = #{id}")
public Integer deleteById(Integer id);
// 可以返回影响的行数

修改

1
2

@Update("update user set username=#{username}, password=#{password}, name=#{name}, age=#{age} where id=#{id}")
public void update(User user);

查询

1
2

@Select("select * from user where username=#{username} and password=#{password}")
public User findByUsernameAndPassword(@Param("username") String username, @Param("password") String password);

有多个参数时，需要 @param 注解

XML 映射配置

默认规则：

XML 映射文件的名称与 Mapper 接口名称一致，并且将 XML 映射文件和 Mapper 接口放置在相同包下（ resource 中同包同名）。
XML 映射文件的 namespace 属性为 Mapper 接口全限定名一致。

<mapper namespace="com.itheima.mapper.UserMapper">
    <select id="findAll" resultType="com.itheima.pojo.User">
    	select id，username，password，name，age from user
    </select>
</mapper>

XML 映射文件中 sql 语句的 id 与 Mapper 接口中的方法名一致，并保持返回类型一致。

动态 SQL

IF

<select id="selectAllWebsite" resultMap="myResult">
    select id,name,url from website where 1=1
    <if test="name != null">
        AND name like #{name}
    </if>
    <if test="url!= null">
        AND url like #{url}
    </if>
</select>

choose-when-otherwise

<mapper namespace="net.biancheng.mapper.WebsiteMapper">
    <select id="selectWebsite"
            parameterType="net.biancheng.po.Website"
            resultType="net.biancheng.po.Website">
        SELECT id,name,url,age,country
        FROM website WHERE 1=1
        <choose>
            <when test="name != null and name !=''">
                AND name LIKE CONCAT('%',#{name},'%')
            </when>
            <when test="url != null and url !=''">
                AND url LIKE CONCAT('%',#{url},'%')
            </when>
            <otherwise>
                AND age is not null
            </otherwise>
        </choose>
    </select>
</mapper>

注意：AND 不能省！

WHERE

where 会检索语句，它会将 where 后的第一个 SQL 条件语句的 AND 或者 OR 关键词去掉。

<select id="selectWebsite" resultType="net.biancheng.po.Website">
    select id,name,url from website
    <where>
        <if test="name != null">
            AND name like #{name}
        </if>
        <if test="url!= null">
            AND url like #{url}
        </if>
    </where>
</select>

SET

set 标签可以为 SQL 语句动态的添加 set 关键字，剔除追加到条件末尾多余的逗号

<update id="updateWebsite"
            parameterType="net.biancheng.po.Website">
        UPDATE website
        <set>
            <if test="name!=null">name=#{name}</if>
            <if test="url!=null">url=#{url}</if>
        </set>
        WHERE id=#{id}
   </update>

foreach

foreach 标签用于循环语句，它很好的支持了数据和 List、set 接口的集合，并对此提供遍历的功能

1
2
3

<foreach item="item" index="index" collection="list|array|map key" open="(" separator="," close=")">
    参数值
</foreach>

foreach 标签主要有以下属性，说明如下。

item：表示集合中每一个元素进行迭代时的别名。
index：指定一个名字，表示在迭代过程中每次迭代到的位置。
open：表示该语句以什么开始（既然是 in 条件语句，所以必然以(开始）。
separator：表示在每次进行迭代之间以什么符号作为分隔符（既然是 in 条件语句，所以必然以,作为分隔符）。
close：表示该语句以什么结束（既然是 in 条件语句，所以必然以)开始）。

使用 foreach 标签时，最关键、最容易出错的是 collection 属性，该属性是必选的，但在不同情况下该属性的值是不一样的，主要有以下 3 种情况：

如果传入的是单参数且参数类型是一个 List，collection 属性值为 list。
如果传入的是单参数且参数类型是一个 array 数组，collection 的属性值为 array。
如果传入的参数是多个，需要把它们封装成一个 Map，当然单参数也可以封装成 Map。Map 的 key 是参数名，collection 属性值是传入的 List 或 array 对象在自己封装的 Map 中的 key。

trim

trim 一般用于去除 SQL 语句中多余的 AND 关键字、逗号，或者给 SQL 语句前拼接 where、set 等后缀，可用于选择性插入、更新、删除或者条件查询等操作

1
2
3

<trim prefix="前缀" suffix="后缀" prefixOverrides="忽略前缀字符" suffixOverrides="忽略后缀字符">
    SQL语句
</trim>

bind

bind 标签可以通过 OGNL 表达式自定义一个上下文变量

<select id="selectWebsite" resultType="net.biancheng.po.Website">
    <bind name="pattern" value="'%'+_parameter+'%'" />
    SELECT id,name,url,age,country
    FROM website
    WHERE name like #{pattern}
</select>

实现分页

使用 limit：

<select id="selectWebsite" resultType="net.biancheng.po.Website">
    SELECT id,name,url,age,country
    FROM website
    <trim prefix="where" prefixOverrides="and">
        <if test="site.name != null and site.name !=''">
            AND name LIKE CONCAT ('%',#{site.name},'%')
        </if>
        <if test="site.url!= null and site.url !=''">
            AND url LIKE CONCAT ('%',#{site.url},'%')
        </if>
        ORDER BY id limit #{from},#{pageSize}
    </trim>
</select>

逆向工程

导入依赖：

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.4.0</version>
</dependency>

config 文件夹下创建 genertorConfig.xml 文件，用于配置及指定数据库及表等

<?xml version="1.0" encoding="UTF-8"?>
                    <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!-- Mysql数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/test" userId="root"
                        password="root" />
        <!-- 默认为false，把JDBC DECIMAL 和NUMERIC类型解析为Integer，为true时 把JDBC DECIMAL 和NUMERIC类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>
        <!-- targetProject：生成POJO类的位置 -->
        <javaModelGenerator
                targetPackage="net.biancheng.pojo" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject：mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="net.biancheng.mapper"
                         targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetProject：mapper接口生成的的位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="net.biancheng.mapper" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据表 -->
        <table tableName="website"></table>
        <table tableName="student"></table>
        <table tableName="studentcard"></table>
        <table tableName="user"></table>
    </context>
</generatorConfiguration>

创建 GeneratorSqlmap 类执行生成代码

public class GeneratorSqlmap {
    public void generator() throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        // 指定配置文件
        File configFile = new File("./config/generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);
    }
    // 执行main方法以生成代码
    public static void main(String[] args) {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

SpringBoot

Sun, 12 Oct 2025 00:00:00 +0000

SpringBoot

简介

设计目的：简化Spring应用的初始搭建以及开发过程

Spring 程序缺点

依赖设置繁琐
- 去除 spring-web 和 spring-webmvc 坐标
配置繁琐

SpringBoot 核心功能及优点：

起步依赖（简化依赖配置）
自动配置
辅助功能（内置服务器）

parent 管理版本

由 parent 帮助开发者统一的进行各种技术的版本管理

只控制版本，不负责导入坐标

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
</parent>

starter 依赖组合

starter定义了使用某种技术时对于依赖的固定搭配格式，使用starter可以帮助开发者减少依赖配置。

引导类

这个类在SpringBoot程序中是所有功能的入口，称为引导类，最典型的特征就是当前类上方声明了一个注解 @SpringBootApplication。

用于启动程序
创建并初始化 Spring 容器

内嵌 Tomcat

整合到了：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

基础配置

默认配置文件：application.properties，配置指定属性即可

配置文件间的加载优先级 properties（最高）> yml > yaml（最低）
不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留

指定SpringBoot配置文件

Setting → Project Structure → Facets
选中对应项目/工程
Customize Spring Boot
选择配置文件

YML 数据读取

使用Spring中的注解

@Value读取单个数据

1
2

@Value("${server.port}")
private int port;

使用默认配置类

SpringBoot 提供了一个对象，能够把所有的数据都封装到这一个对象中，这个对象叫做 Environment，使用自动装配注解可以将所有的yaml数据封装到这个对象中

@Autowired
private Environment env;
...
env.getProperty("...");

使用自定义配置类

SpringBoot 也提供了可以将一组 yaml 对象数据封装一个 Java 对象的操作

enterprise 指定加载某一组 yaml 配置

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
private String name;
private Integer age;
private String[] subject;
}

数据引用

baseDir: /usr/local/fire
center:
    dataDir: ${baseDir}/data
    tmpDir: ${baseDir}/tmp
    logDir: ${baseDir}/log
    msgDir: ${baseDir}/msgDir

SSMP 整合

JUnit

@SpringBootTest(classes = Springboot04JunitApplication.class)
// @ContextConfiguration(classes = Springboot04JunitApplication.class)
class Springboot04JunitApplicationTests {
    //注入你要测试的对象
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        //执行要测试的对象对应的方法
        bookDao.save();
        System.out.println("two...");
    }
}

Mybatis

在配置、引入依赖时已经整合

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

#2.配置相关信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
    username: root
    password: root

Mybatis-plus

需要用阿里云的 url 导入

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3</version>
</dependency>

配置所有数据库表名的前缀名：

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_		#设置所有表的通用前缀名称为tbl_

其他

Lombok

简化POJO实体类开发，SpringBoot 目前默认集成了 lombok 技术

可以通过一个注解@Data完成一个实体类对应的getter，setter，toString，equals，hashCode等操作的快速添加

<dependencies>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

SpringMVC

Sun, 12 Oct 2025 00:00:00 +0000

Spring MVC

主要覆盖表述层（Controller）

简化接收前端参数、响应前端数据

工作流程

接收数据

路径设置

RequestMapping("path") 注解

GetMapping("...")
……

接收参数

param

参数名和 param 名相同，直接接收
注解接收 RequestParam(value = "...",required = "...")
多字符串，直接用集合接收
- 必须要注解
封装为对象接收
- 属性名必须等于参数名

路径传参

@RequestMapping("{account}/{password}")
public String login(@PathVariable String account,@PathVariable String password){
	return null;
}

Json 参数

定义接收的实体类
用 RequestBody 接收

原生 Java 不支持接收 Json

handlerMapper 中配置 Json 转换器，EnableWebMVC
- 用于给RequestMappingHandLerMapping、RequestMappingHandLerAdapter 添加Json处理器

@CookieValue

存 Cookie：

public String save(HttpServletResponse response){
    Cookie cookie = new Cookie(name:"cookiellame", value:"root");
    response.addCookie(cookie);
    return "ok";
}

请求头

@RequestHeader

原生 API 对象

共享域对象

Session、ServletContext

原生获取

SpringMVC 提供

model modeLMap map modeLAndView

响应数据

前后端不分离

不用 ResponseBody，配置 Jsp 模板地址，返回

return "forward:/jsp/..."

返回 Json

直接 return User，会被自动封装

需要 @ResponseBody 注解，不会走视图转换器
- ResponseBody + Controller = RestController

返回静态资源

需要配置 Config

//开启静态资源查找
//dispatcherServLet->handLerMapping找有没有对应的handLer->【没有->找有没有静态资源】

@Override
public void configurelDefaultServletHandling(DefaultServletHandlerConfigurer configurer）{
    configurer.enable();
}

Restful 风格

规定路径设计方式、参数传递格式、选择请求方式

风格特点

每一个URI代表1种资源；
客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源；
资源的表现形式是XML或者JSON；
客户端与服务端之间的交互在请求之间是无状态的，从客户端到服务端的每个请求都必须包含理解请求所必需的信息。

用请求方式 + URI 来表示操作、对象
- 路径传参：对应单一资源，如 id

其他扩展

全局异常处理

异常处理分类

编程式：单独细化处理
声明式：统一处理

//全局异常发生，会走此类写的handLer！
//@ControLLerAdvice//可以返回逻辑视图转发和重定向的！
no usages
@RestControllerAdvice//@ResponseBody直接返回json字符串
public class GlobalExceptionHandler{
    //发生异常->ControLLerAdvice注解的类型->@ExceptionHandLer（指定的异常）->handLer
    no usages
    @ExceptionHandler(ArithmeticException.class)
    public ObjectArithmeticExceptionHandler(ArithmeticException e){
    //自定义处理异常即可handLer
    }

拦截器

HandlerIntercepter

拦截器 Springmvc VS 过滤器 javaWeb:

相似点
- 拦截: 必须先把请求拦住，才能执行后续操作
- 过滤: 拦截器或过滤器存在的意义就是对请求进行统一处理
- 放行: 对请求执行了必要操作后，放请求过去，让它访问原本想要访问的资源
不同点
- 工作平台不同
  - 过滤器工作在 Servlet 容器中
  - 拦截器工作在 SpringMVC 的基础上
- 拦截的范围
  - 过滤器: 能够拦截到的最大范围是整个 Web 应用
  - 拦截器: 能够拦截到的最大范围是整个 SpringMVC 负责的请求
- IOC 容器支持
  - 过滤器: 想得到 IOC 容器需要调用专门的工具方法，是间接的
  - 拦截器: 它自己就在 IOC 容器中，所以可以直接从 IOC 容器中装配组件，也就是可以直接得到 IOC 容器的支持

使用

实现 HandlerInterceptor 接口
修改类配置拦截器 SpringMvcConfig impLements WebMvcConfigurer

// 配置拦截
publicvoid addInterceptors(InterceptorRegistry registry){
    //配置方案1：拦截全部请求
    registry.addInterceptor(new MyInterceptor());
    
    //配置方案2：指定地址拦截.addPathPatterns（"/user/data");；
    //*任意一层字符串**任意多层字符串
    registry.addInterceptor(new MyInterceptor())
    .addPathPatterns("/user/**");
    
    //配置方案3：排除拦截排除的地址应该在拦截地址内部！
    registry.addInterceptor(new MyInterceptor())
    .addPathPatterns("/user/**").excludePathPatterns("/user/data1");
}

参数校验

hybernate 框架实现

非空校验 @Validate

NotNull：包装类型不为 null
NotEmpty：集合类型长度大于 0
NotBlank：字符串不为 null，且不为 ""

通过 BindingResult 绑定错误，不直接返回

Spring

Fri, 10 Oct 2025 00:00:00 +0000

概述

Spring FrameWork 特点

非侵入式
控制反转
面向切面编程
容器化管理
组件化
一站式

IOC 控制反转

概述

Inversion of Control

用容器管理所有 Java 对象的实例化和初始化，控制依赖关系，称为 SpringBean

xml 配置文件
抽象 BeanDefinitionReader 读取
装配，读取信息，利用反射实例化
- BeanFactory、ApplicationContex
用 Context.getBean("...") 来获取

基于 xml 管理

获取 Bean

xml 定义

`1`	`<bean id="helloworldone" class="ccom.atguigu.spring6.bean.He11owor1d"></bean>`

Context.getBean("...") 获取

1
2

//根据类型获取接口对应bean
UserDaouserDao= context.getBean(UserDao.class);

依赖注入

set 注入
- xml 中进行配置
构造器注入
- <constructor-arggname="bnamevalue="java开发"></constructor-arg>

是不是只能注入默认值？

特殊值注入
- 对象中注入其他对象（表示关系）
  - 法一：引入外部/内部类，bean 标签中嵌套 ref
  - 法二：级联赋值，直接嵌套对所注入的对象的属性的赋值
数组类型注入
- 配置中的 <array>标签
List 集合属性注入
- 先定义 Bean，再用 <list> 标签注入
map 集合属性注入
- <map><entry><key> 标签
引用集合类型（？util 整合）
p 命名空间注入
- 防止 7.中的util 的名称冲突

引入外部属性

创建外部属性文件 .property

xml 中配置读取即可

作用域

配置 scope 来指定作用域

singleton 单例
prototype 多例，每次获取时创建

生命周期

FactoryBean 机制

根据接口实现 FactoryBean，自定义 getObjet（）方法返回值，来控制产生的对象

用于整合第三方框架(?)

基于注解注解管理

开启组件扫描

1
2

<!--开启组件扫描功能-->
<context:component-scanbase-package="com.atguigu.spring6"></context:component-scan>

注解说明

@Autowired 注入

set 方法注入

@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}

构造方法注入
形参上注入
根据名称进行注入（而非接口名）
- 一个接口有多个实现类时 @Qualifier

@Resource 注入

默认根据 name 标签进行注入

全注解开发

无需使用配置文件，写一个配置类替代配置文件

@configuration
//@componentscan({"com.atguigu.spring6.controller"
//"com.atguigu.spring6.service","com.atguigu.spring6.dao"})
@componentscan("com.atguigu.spring6")
public class Spring6config {}

手写 IoC

反射

获取对象：

public void test01(）{
    //1 类名.cLass
    Class clazz1 = Car.class;
    //2 对象.getCLass()
    Class clazz2 =newv Car().getclass();
    //3 CLass.forName（"全路径"）
    Class clazz3 = Class.forName( className: "......");
    //实例化
    Object o = clazz3.getDeclaredConstructor().newInstance();
}

获取方法：

public void test02() throws Exception {
    Classclazz = Car.class;
    1/获取所有构造
    Constructor[]] constructors = clazz.getconstructors();
    for (Constructor c:constructors) {......}
    // 方法名：c.getname() 参数个数(public)：c.getConstructor()
    // 参数个数(所有)：c.getDeclaredConstructor()
}

构造对象：

1
2
3

Constructorc2=（clazz.getDeclaredConstructor(......)
c2.setAccessible(true);
Car car2 = (Car)c2.newInstance( ..initargs: "捷达"， 15,“白色");

获取属性：

Classclazz = Car.class;
//获取所有pubLic属性
Field[] fields = clazz.getFields();
//获取所有属性（包含私有属性）
Field[] fields = clazz.getDeclaredFields();
for (Field field:fields）{
System.out.println(field.getName());
}

操作方法

private方法
Method[] methodsAll = clazz.getDeclaredMethods();
for (Method m:methodsAll) {
//执行方法 runI
if(m.getName().equals("run")) {
    m.setAccessible(true);
    m.invoke(car) ;
}

实现

步骤

创建注解：@Bean创建对象、@Di属性注入
创建bean容器接口：ApplicationContext
定义方法，返回对象
实现bean容器接口：返回对象、根据包规则加载bean

配置

@Bean

@Target(ElementType.TYPE) // 目标
@Retention(RetentionPolicy.RUNTIME) // 运行范围
public @interface Bean
}

@Di

ApplicationCotext 接口

//创建有参数构造，传递包路径，设置包扫描规则
//扫描当前包及其子包，哪个类有@Bean注解，把这个类通过反射实例化
public AnnotationApplicationContext implement ApplicationContext(String basePackage) {
	// 路径转义,点替换为斜杠
    String packagePath = basePackage.replaceAll("\\.","\\\\")
    // 获取绝对路径
    Enumeration<URL> urls = Thread.currentThread().getContextClassLoader()·getResources(packagePath);
    while(urls.hasMoreElements()) {
        URL url = urls.nextElement();
        String filePath= URLDecoder.decode(url.getFile(), "utf-8");
        loadBean(new File(filePath)); // 实现 loadBean 方法
    }
    
    loadDi(); // 实现 loadDi 方法
}

	public static void loadBean(File file){
        // 1.判断当前内容是否是文件夹
        // 2.是，则获取当前文件夹所有内容      
        // 3.文件夹为空，返回空       
        // 4.文件夹不为空，遍历文件夹所有内容      
        // 4.1.遍历每个File对象，继续判断，如果还是文件，递归        
        // 4.2.不是文件夹，是文件        
        // 4.3.得到包文件 + 类名称部分    	
        // 4.4.判断当前文件类型是否.cLass        
        // 4.5.如果是.cLass类型，把路径\替换成。把.cLass去掉        
        // 4.6.判断类上面是否有注解@Bean，如果有实例化过程        
        // 4.7.把对象实例化之后，放到map集合bearFactory
        }
    private void loadDi() {
    	//实例化对象在beanFactory的map集合里面
    	//1遍历beanFactory的map集合
    	//2获取map集合每个对象（vaLue），每个对象属性获取到
    	//3遍历得到每个对象属性数组，得到每个属性
    	//4判断属性上面是否有@Di注解
    	//5如果有@Di注解，把对象进行设置（注入）
    }

AOP 面向切面

引入

问题：

要抽取的代码在方法内部，无法通过抽取到父类解决

代理模式：

在调用目标方法时，不直接调用，而是通过代理类调用
代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法
目标：代理“套用"了非核心逻辑代码的类、对象、方法

优化：

静态代理：再创建一个代理类，实现其他方法，再调用原有类
- 问题：还是僵化，无法动态调整
动态代理：创建动态代理对象 ProxyFactory，用反射统一管理

AOP：通过预编译和动态代理，在不修改程序源码情况下，给程序添加功能

抽取横切关注点
整合横切关注点为通知方法
将各种通知方法整合为切面类

基于注解实现

分类：

JDK：代理对象和目标对象实现相同接口（目标有接口时）
cglib：通过继承目标类
AspectJ：基于静态代理，将代理逻辑植入编译的字节码文件，效果是动态的，Spring借助了其中的注解

@Aspect//切阻尖
@Component //ioc容器
public class LogAspect {
    //设置切入点和通知类型
    //通知类型：
    //前置 @Before(value = "切入点表达式")
    public void beforeMethod(JoinPoint joinPoint) {
        StringmethodName = joinPoint.getSignature().getName();
        Object[] args = jqinPoint.getArgs();
        // 获取连接点的信息
    }
    //返回 @AfterReturning
    //异常 @AfterThrowing
    //后置 @After()
    //环绕 @Around()
}

@Order 控制切面优先级

基于 xml 实现

<context:component-scanbase-package="com.atguigu.aop.xml"></context:component-scan>
<aop:config>
	<!--配置切面类-->
	<aop:aspect ref="loggerAspect">
	<aop:pointcut id="pointcut"
expression="execution(*com.atguigu.aop.xml.calculatorImpl.*(..))"/>
	<aop:before method="beforeMethod"pointcut-ref="pointcut"></aop:before>
	<aop:after method="afterMethod"pointcut-ref="pointcut"></aop:after>
	<aop:after-returning method="afterReturningMethod"returning="result"pointcut-
ref="pointcut"></aop:after-returning>
	<aop:after-throwing method="afterThrowingMethod"throwing="ex"pointcut-
ref="pointcut"></aop:after-throwing>
<aop:around method="aroundMethod"pointcut-ref="pointcut"></aop:around>
	</aop:aspect>
</aop:config>

事务

JDBC Template

增：

//1添加操作
//第一步编写sqL语句
String Sql = "INSERT INTO t_emp VALUES(NULL,?,?,?)";I
//第二步调用jdbcTempLate的方法，传入相关参数
//Object[］ params ={"东方不败"，20，"未知"};
//int rows = jdbcTemplate.update(sql,params);
int rows = jdbcTemplate.update(sql, ..args:"东方不败"，20，"未知");

改：

1
2
3

//2修改操作
String sql ="update t_emp set name=? where id=?";
int rows =jdbcTemplate.update(sql, ..args: "林平之atguigu",3）;

删：

1
2
3

//3删除操作
String sql'deletefromt_empwhere id=?";
introws=jdbcTemplate.update(sql, ..args: 3);

查：

public void testSelectObject() {
    String sql="select*from t_emp
    List<Emp>list = jdbcTemplate.query(sql,
    new BeanPropertyRowMapper<>(Emp.class));
}

基于注解的声明式事务

保证事务的一致性、隔离性、持久性、原子性

Transactional 标签声明事务，可以设置：

只读
超时
回滚策略，哪些异常不回滚
隔离级别
传播行为，事务方法之间调用的处理逻辑

全注解

不用 XML，改用配置类

JavaWeb-Servlet

Thu, 09 Oct 2025 00:00:00 +0000

Tomcat

服务器容器，将服务部署（deploy）到容器内

目录结构：

bin 可执行文件目录
conf 配置文件目录
webapps 项目部署的目录
- 项目内容存放到 webapps-name-WEBINF 文件夹下，即可访问
work 工作目录

Servlet

获取参数

在 web.xml 中定义 servlet-mapping，指定接收 url 请求对应的类
1. 现在支持注解注册 @WebServlet("\...")
定义类，继承 HttpServlet ，实现 doPost 方法
再调用 DAO、DAOImpl 更改数据库

继承关系

Servlet 接口

void init（config）初始化方法
void service(request,response) 服务方法（收到请求自动调用）
void destory() 销毁方法

Servlet 父类、抽象类

genericServlet 抽象类，用于处理子类没有实现的方法（抛错误）
- httpServlet 实现类，具体处理逻辑

生命周期

默认情况下：

第一次接收请求时，这个servlet会进行实例化（调用构造方法）、初始化（调用init())）、然后服务（调用service()）
- 默认只会有一个 Servlet 示例
- 单例的，线程不安全的 –> 尽量不在 Servlet 中定义、修改成员变量
第二次请求开始，每一次都是服务
当容器关闭时，其中的所有的 servlet 实例会被销毁，调用销毁方法

Http 协议

超文本传输协议，是无状态的

请求内容

请求行
- 方式、URL、HTTP版本
请求头
- Host、Referer、Cookie……
请求体

响应内容

响应行
- 协议、状态码（200）、响应状态（ok）
响应消息头
- Server、Content-type……
响应体

Session

会话跟踪技术，解决 http 的无状态问题。

request.getSession，获取、自动分配 Session

session.setAttribute，保存 session 作用域

服务器端内部转发和客户端重定向

内部转发：同一请求、不同服务组件之间转发处理

getdepatcher…

重定向：返回客户端一个新的服务，使其重新请求

redirect…

Thymeleaf 视图模板技术

辅助渲染从 DAO 获取的数据到前端

引入模板
将查询的数据动态显示

th: if... unless... each... text...

保存作用域

request：一次请求有效
session：一次会话范围有效
application：一次应用程序范围内有效（上下文）

小项目

编辑、修改特定信息

变量的获取 url/(fid=${name.fid})
跳转到编辑页面，获取数据

MVC Servlet优化

Servlet 整合

问题：

Servlet 组件过多

优化：

将各种 Servlet 整合到一个 Controller 中，作为方法
用路径区分操作要求
通过 Switch ... case ... 进行跳转，执行 DAO
- 再用反射优化，this.getClass().getDeclaredMethods();

DispatcherServlet 中央控制器

抽取路径、反射代码

拦截、处理指定请求，修改路径再传输到 Controller

将每个 Controller 的反射代码再抽取到父类

注意，这样的 Controller 继承 DispatcherServlet，不能再自动调用 Init（），需要另外处理

解析 xml 配置文件
定位指定 Controller
读取 bean 配置，整合为 map<id,object>，寻找指定方法

抽取重定向

Controller处理后，return 一个字符串，再交给 DispatcherServlet 处理

抽取传入参数

获取参数的过程同一抽取到 DispatcherServlet

jdk 8 新特性，通过反射获取方法参数的方法名
将得到的参数拆包、赋值、类型转换后，再传递给 Controller

初始化

重写 init（）方法，通过注解或 xml，向初始化方法中添加参数

Service

model：模型层
- pojo/vo、DAO（数据访问对象，单精度方法）、BO（业务对象）
- 在 Controller 与 DAO 间添加 Service 层
controller：控制
view：视图

IOC 控制反转

实现 Bean 的自动装配，整理 xml 映射文件

将解析出的实例创建并存放在 beanmap 中，beanmap 存放在 BeanFactory 中，改变示例生命周期（存放到 IOC 容器中），需要时取用即可

1
2
3

Field propertyField = beanClazz.getDeclaredField(propertyName);
propertyField.setAccessible(true);
propertyField.set(beanobj,refobj);

Filter 过滤器

拦截请求、响应

实现 Filter 接口，@WebFilter("...")
改写 doFilter，后放行（执行 Service）filterchain.doFilter(...)
接收到 Service 后，继续执行完 doFilter

过滤器链

执行顺序：根据全类名、xml 配置的顺序

事务管理

一个 Service 需要作为一个整体，操作多个数据库时要保证同时成功或失败

将 try …… catch 放到 Filter 当中处理，统一回滚
用 ThreadLocal 来保证对象、线程（Connection）的同一性

OpenSessionInViewFilter 的实现

事务管理封装为 TransactionManager，实现开启、提交、回滚事务的方法

本来分开的 commit、rollback 等，手动进行管理
注意内部不能 catch 异常，需要都交给 Filter 处理
- 或者 catch 为新的异常抛出

ThreadLocal 的实现源码

public void set(T value)
    Thread t=Thread.currentThread();//获取当前的线程
    ThreadLocalMap map = getMap(t);//每一个线程都维护各自的一个容器(ThreadLocalMap)
    iff (map != null)
    map.set((this)value);//用map，支持多个对象存储
    else
    createMap(t, value) ;
}

Listener 监听器

监听各种对象的创建、销毁；保存作用域的变化；对象在 Session 中的创建与移除、序列化与反序列化

将 IOC 整合到 Listener 中（监听上下文启动），提前初始化，提高响应速度（减慢启动速度）

QQZone 笔记

数据库

设计

先写出功能，再分析：

抽取实体：用户登录信息、用户详情信息、日志、回贴、主人回复
分析其中属性
1. 用户登录信息：账号、密码、头像、昵称
2. 用户详情信息：真实姓名、星座、血型、邮箱、手机号
3. 日志：标题、内容、日期、作者
4. 回复：内容、日期、作者、日志
分析实体之间关系
- 一对一 or 一对多 or 多对多

范式

第一范式：列不可再分（空间尽量小）

第二范式：一张表只表达一层含义

第三范式：表中每一列和逐渐都是直接依赖关系（与多表连接查询权衡）

根据数据库查询频次、量，调整规范性

主键尽量不与业务产生联系

直接用自增组件

实体类 - POJO

定义对应属性，有关系的要对应

1
2

private UserDetail userDetail//1:1
private List<Topic> topiqList//1:N

数据层 - DAO

接口、impl，实现查询

业务层 - Service

接口、impl，整合 DAO 层

ElasticSearch

Sat, 04 Oct 2025 00:00:00 +0000

初识

分布式的开源搜索引擎
提供 Restful 接口，所有语言均可调用

ELK技术栈：

结合 kibana（可视化）、Logstash、Beats
用于日志分析、事实监控等

倒排索引

正向索引：

传统数据库使用，查询需要逐一遍历

倒排索引：

document：文档，每条数据就是一个文档
term：词条，由文档按语义划分，有限且唯一
先搜词条，再根据词条找文档

IK分词器

作为 ES 插件导入

根据现有词典（可拓展）对文档进行划分

基础概念

索引库：

相同类型的文档（Json存储）的集合

映射：

索引库中对文档的约束

mapping 属性

type：字段数据类型
index：是否创建索引
analyzer：分词器
propertis：嵌套的子字段

索引库操作

RESTFUL 规范

不同请求方式对应不同请请求类型

创建索引库和mapping的请求语法如下：

PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名1": {
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2": {
        "type": "keyword",
        "index": "false"
      },
      "字段名3": {
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // …略
    }
  }
}

支持 put、get、delete

文档操作

新增文档：

POST /索引库名/_doc/文档id
{
  "字段1": "值1",
  "字段2": "值2",
  "字段3": {
    "子属性1": "值3",
    "子属性2": "值4"
  },
  // …
}

修改

put 全量修改，先删除再新建
post 增量修改

批处理

POST /_bulk
{ "index" : { "_index" : "索引库名", "_id" : "1" } }
{ "字段1" : "值1", "字段2" : "值2" }
{ "index" : { "_index" : "索引库名", "_id" : "1" } }
{ "字段1" : "值1", "字段2" : "值2" }
{ "index" : { "_index" : "索引库名", "_id" : "1" } }
{ "字段1" : "值1", "字段2" : "值2" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

DSL 查询

分类：

叶子查询：特定字段查询特定值
复合查询：逻辑方式组合叶子查询

基本语法：

GET /indexName/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

叶子

全文检索：分词
- match 查询
- mult_match 允许同时查询多个字段
精确查询：不分词，直接精确匹配
- term 查询，整体到词条中寻找
- range
地理查询：用于搜索地理位置

复合

基于逻辑运算组合叶子
- bool：子句must、should、must_not、filer
基于算法修改查询时的文档相关性算分，从而改变排名
- function_score
- dis_max

排序和分页

排序：

添加 sort 标签，默认按照 _score 排序

分页：

添加 from 、size

深度分页问题：

es 一般对数据进行分片存储，导致查询数据时需要汇总各个分片的数据

解决方案：

search after，分页时需要排序，每次查询从上一次的排序值开始。但只能向后逐页查询
scrool，将排序数据形成快照，保存在内存
设置上限

高亮显示

在搜索结果中把搜索关键字突出显示

field标签加上pre_tags、post_tags

Java 客户端

JavaRestClient

初始化

1
2
3

RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
       HttpHost.create("http://192.168.150.101:9200")
));

Mapping 映射

结合业务分析所需字段（区分是否需要和是否搜索）

搜索字段
排序字段
展示字段

索引库操作

基于 RestFul格式：

@Test
void testCreateHotelIndex() throws IOException {
    // 1. 创建Request对象
    CreateIndexRequest request = new CreateIndexRequest("items");
    // 2. 请求参数，MAPPING_TEMPLATE是静态常量字符串，内容是JSON格式请求体
    request.source(MAPPING_TEMPLATE, XContentType.JSON);
    // 3. 发起请求
    client.indices().create(request, RequestOptions.DEFAULT);
}

文档操作

新增文档的 API

@Test
void testIndexDocument() throws IOException {
    // 1. 创建request对象
    IndexRequest request = new IndexRequest("indexName").id("1");
    // 2. 准备JSON文档
    request.source("{\"name\": \"Jack\", \"age\": 21}", XContentType.JSON);
    // 3. 发送请求
    client.index(request, RequestOptions.DEFAULT);
}

文档批处理

add 多个 index，然后统一请求即可

完成批量导入数据

void testBulk() throws IOException {
    // 1. 创建Bulk请求
    BulkRequest request = new BulkRequest();
    // 2. 添加要批量提交的请求：这里添加了两个新增文档的请求
    request.add(new IndexRequest("indexName")
            .id("101").source("json source", XContentType.JSON));
    request.add(new IndexRequest("indexName")
            .id("102").source("json source2", XContentType.JSON));
    // 3. 发起bulk请求
    client.bulk(request, RequestOptions.DEFAULT);
}

准备文档数据
准备请求参数
发送请求

RTL 查询

SearchRequest 对象，发请求
解析结果
得到 Hits 属性，结果是数组

复合、排序、分页

用指定对象、设置指定参数即可

boolquery、source

@Test
void testBool() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.准备bool查询
    BoolQueryBuilder bool = QueryBuilders.boolQuery();
    // 2.2.关键字搜索
    bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.3.品牌过滤
    bool.filter(QueryBuilders.termQuery("brand", "德亚"));
    // 2.4.价格过滤
    bool.filter(QueryBuilders.rangeQuery("price").lte(30000));
    request.source().query(bool);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

分页：

@Test
void testPageAndSort() throws IOException {
    int pageNo = 1, pageSize = 5;

    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.搜索条件参数
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.2.排序参数
    request.source().sort("price", SortOrder.ASC);
    // 2.3.分页参数
    request.source().from((pageNo - 1) * pageSize).size(pageSize);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

高亮：

@Test
void testHighlight() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.query条件
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.2.高亮条件
    request.source().highlighter(
            SearchSourceBuilder.highlight()
                    .field("name")
                    .preTags("<em>")
                    .postTags("</em>")
    );
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

数据聚合

对文档数据进行统计、分析

桶：对文档做而非女足
度量 Metric：计算某些特定值
管道 Pipeline：以其他聚合的结果为基础做聚合

DSL

aggs 定义聚合

GET /items/_search
{
  "query": {"match_all": {}}, // 可以省略
  "size": 0, // 设置size为0，结果中不包含文档，只包含聚合结果
  "aggs": { // 定义聚合
    "cateAgg": { // 给聚合起个名字
      "terms": { // 聚合的类型，按照品牌值聚合，所以选择term
        "field": "category", // 参与聚合的字段
        "size": 20 // 希望获取的聚合结果数量
      }
    }
  }
}

RestClient 构造聚合

指定名称、类型、字段

request.source().size(0);
request.source().aggregation(
        AggregationBuilders
                .terms("brand_agg")
                .field("brand")
                .size(20)
);

MQ

Thu, 02 Oct 2025 00:00:00 +0000

初识 MQ

服务调用类型

同步调用

服务 A 同时请求多个服务，导致服务种类的不断扩增，服务的等待耗时增加。

缺点：

扩展性差
性能下降
级联失败问题

异步调用

基于消息通知的方式，包含：

消息发送者：即原来的调用者
消息接收者：接收和处理消息的人
消息代理：管理、暂存转发消息

不再同步调用业务关联度第的服务，而是分别发送消息到 Broker

接触耦合，扩展性强
无需等待，性能好
故障隔离
缓存消息，流量削锋填谷

技术选型

RabbitMQ、ActiveMQ、RocketMQ、Kafka

部署

Docker安装即可

整体架构：

publisher：消息发送者
consumer：消息消费者
queue：队列，存储消息
exchange：交换机，负责路由消息
vertual-host：虚拟主机，用于数据隔离

消息发送给交换机，再由交换机分发给对应的 queue，交换机没有消息存贮的能力。

Java客户端

AMQP：无协议传输

封装为 Spring AMQP
再封装为 SpringRabbit，RabbitTemplate包装类

收发消息

发送：

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testSimpleQueue() {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, spring amqp!";
    // 发送消息
    rabbitTemplate.convertAndSend(queueName, message);
}

接收：

@Slf4j
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        log.info("spring 消费者接收到消息: [" + msg + "] ");
    }
}

Work Queues

多个消费者绑定到一个队列

一条消息只能被一个消费者处理
多条消息，默认轮流接收
通过添加消费者来处理超量数据

修改配置

修改 prefetch 来控制消费者预取的消息数量，使性能高的服务器多处理

交换机

Fanout

广播模式，将接收到的消息路由到每一个与其绑定的 queue

Direct

定向路由，根据规则路由到指定的 queue

设置 BindingKey 和 RoutingKey

Topic

基于 RoutingKey，但其通常是多个单词的组合，且以.分割，可以使用通配符# *

声明队列交换机

用代码自动完成队列、交换机的创建

基于Bean声明

在消费者端声明：

@Configuration
public class FanoutConfig {
    // 声明FanoutExchange交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("hmall.fanout");
    }
    // 声明第1个队列
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }
    // 绑定队列和交换机
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
    // ... 略，以相同方式声明第2个队列，并完成绑定
}

基于注解声明

优化 Bean 声明中绑定 Key 的冗余代码。

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue1"),
        exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
        key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者1接收到Direct消息: ["+msg+"] ");
}

消息转换器

负责将对象转换为字节格式传输

问题：

默认序列化由安全风险
信息体积变大
可读性差

解决：

用 Jackson 序列转换器
注意收发一致

进阶

改进消息可靠性问题

发送者可靠性

重连

由于网络波动，可能出现发送者连接 MQ 失败。

配置中开启重连机制即可

注意性能损耗
使用合理的重连机制

确认

MQ 接收到消息后，返回 ACK 给发送者。（对性能影响较大）

不同的返回情况、强度
其他情况返回 NACK，告知投递失败

使用：

先开启配置 public confirm type
配置类

@Slf4j
@AllArgsConstructor
@Configuration
public class MqConfig {
    private final RabbitTemplate rabbitTemplate;

    @PostConstruct //只在启动时初始化依次
    public void init(){
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returned) {
                log.error("触发return callback,");
                log.debug("exchange: {}", returned.getExchange());
                log.debug("routingKey: {}", returned.getRoutingKey());
                log.debug("message: {}", returned.getMessage());
                log.debug("replyCode: {}", returned.getReplyCode());
                log.debug("replyText: {}", returned.getReplyText());
            }
        });
    }
}

发送方：

@Test
void testPublisherConfirm() throws InterruptedException {
    // 1.创建CorrelationData
    CorrelationData cd = new CorrelationData();
    // 2.给Future添加ConfirmCallback
    cd.getFuture().addCallback(new ListenableFutureCallback<CorrelationData.Confirm>() {
        @Override
        public void onFailure(Throwable ex) {
            // 2.1.Future发生异常时的处理逻辑，基本不会触发
            log.error("handle message ack fail", ex);
        }

        @Override
        public void onSuccess(CorrelationData.Confirm result) {
            // 2.2.Future接收到回执的处理逻辑，参数中的result就是回执内容
            if(result.isAck()){ // result.isAck()是boolean类型，true代表ack回执，false代表nack回执
                log.debug("发送消息成功，收到 ack!");
            }else{ // result.getReason()是String类型，返回nack时的异常描述
                log.error("发送消息失败，收到 nack，reason：{}", result.getReason());
            }
        }
    });
    // 3.发送消息
    rabbitTemplate.convertAndSend("hmall.direct", "red1", "hello", cd);
}

若发送失败，则尝试重发

MQ可靠性

问题：

数据丢失
内存空间有限，可能导致消息阻塞、堆积

数据持久化

交换机、队列、消息

消息：内存到上限后，才写出到磁盘，阻塞
- 一直写出到磁盘

Lazy Queue

惰性队列

接到消息不再写到内存，直接存入磁盘
消费消息时，从磁盘中读取并加载到内存

消费者可靠性

确认

消费者处理消息结束后，向 MQ 发送回执，告知消息处理状态

ack：成功处理
- 配置`acknowledge-mode
- none 接到后直接返回。不安全
- manual 手动编写返回逻辑
- auto
nack：处理失败，需要重发
reject：处理失败并拒绝，MQ 从队列中删除该消息

失败重试

问题：消费者反复调用 MQ 导致性能损耗

解决：消费者出现异常时利用本地调试机制，无需调用 queue

重试耗尽后的策略

直接 reject（默认）
返回 nack，重新入队
将失败消息投递到指定的交换机

业务幂等

程序开发时，同一个业务执行一次和多次对业务状态的影响是一致的。用于确保消息不被多次执行。

解决方案：

给每个消息设置唯一 id ，配置SetMessageId，然后将 id 写入数据库
业务判断：基于业务本身
- 保证服务间一致性

延迟消息

实现一致性的兜底方案。

发送者发送消息时指定时间，消费者在指定时间后才收到消息

如支付超时取消

死信交换机

死信：

requeue = false
消息无人消费、过期 –> 用于实现延迟消息
消息堆积满了，最早的消息成为死信

死信交换机：

接收死信

消息延迟插件

RabbitMQ的插件，docker部署

计时需要占用 CPU，产生资源消耗
尽可能延时缩短

网关及配置中心

Wed, 01 Oct 2025 00:00:00 +0000

网关

介绍

网络的关口，负责请求的路由、转发、身份检验。分为阻塞式、响应式。微服务将服务注册到注册中心，网关进行服务拉取返回给前端。

使用

创建新模块
引入网关依赖
编写启动类
配置路由

spring:
  cloud:
    gateway:
      routes:
        - id: item # 路由规则id，自定义，唯一
          uri: lb://item-service # 路由目标微服务，lb代表负载均衡
          predicates: # 路由断言，判断请求是否符合规则，符合则路由到目标
            - Path=/items/** # 以请求路径做判断，以/items开头则符合
        - id: xx
          uri: lb://xx-service
          predicates:
            - Path=/xx/**

另有各种路由种类、路由过滤器。

登录校验

需要在网关转发之前进行校验，即添加过滤器。

网关底层流程：

HandlerMapping 路由映射器
WebHandler 请求处理器，即过滤器处理器
PRE（在这里实现） + POST 阶段

Q: 网关如何将用户信息传递给微服务？

Http 传送 –> 用请求头

Q: 微服务之间如何传递用户信息？

自定义过滤器

GatewayFilter：指定路由生效
GlobalFilter：全局过滤器，作用于所有路由

@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求
        ServerHttpRequest request = exchange.getRequest();
        // 2.过滤器业务处理
        System.out.println("GlobalFilter pre阶段 执行了。");
        // 3.放行
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        // 过滤器执行顺序，值越小，优先级越高
        return 0;
    }
}

网关拦截逻辑：

获取 request
根据 URL 判断是否需要拦截
获取 Token，解析校验

网关传递服务

用 ServerWebExchange 类下的 API 来给请求头添加鉴权信息，再发送给后续服务。
将登录检验封装为工具模块（配置类），统一扫描调用。
配置类的配置：@ConditionalOnClass(DispatcherServlet.class) 只拦截到后端 SpringMVC 的请求（否则其他模块扫描不到），绕过网关。

微服务间传递信息

利用 OpenFeign 的 RequestTemplate 类更改请求头传递，保存请求头。

配置管理中心

问题：

微服务重复配置过多，维护成本高
更改配置不方便，需要重启服务、网关

解决：

通过配置管理实现热更新、配置共享

配置管理

NACOS 可视化编辑共享配置

包含：

数据库
日志
Swagger
……

微服务拉取共享配置

流程：

启动，加载 bootstrap 引导类
拉取 Nacos 配置
初始化 ApplicationContext上下文
加载 application.yml ，拉取共享配置，合并配置

配置热更新

前提条件

nacos 中要有于微服务名有关的配置文件
微服务中要以特定方式读取需要热更新的配置属性

动态路由

要求：

监听 Nacos 配置变更信息

private final NacosConfigManager nacosConfigManager;

public void initRouteConfigListener() throws NacosException {
    // 1.注册监听器并首次拉取配置
    String configInfo = nacosConfigManager.getConfigService()
            .getConfigAndSignListener(dataId, group, 5000, new Listener() {
                @Override
                public Executor getExecutor() {
                    return null;
                }

                @Override
                public void receiveConfigInfo(String configInfo) {
                    // TODO 监听到配置变更，更新一次配置
                }
            });
    // TODO 2.首次启动时，更新一次配置
}
再定义 UpdateConfigInfo(),删除旧的路由、重新读取新路由

微服务拆分

Wed, 01 Oct 2025 00:00:00 +0000

为什么需要拆分？

单体架构不适合于用户量大、开发人员多的项目访问资源难以分配，无法分解并发压力 –> 把单体架构拆分为多个独立项目

颗粒度小，团队自治，服务自治，数据隔离

服务拆分

前置知识

首先熟悉项目、模块，看流程。

拆分时机

创业型项目先采用单体结构，随规模扩增

拆分原则

高内聚（关联度、完整度高），低耦合（减少对其他服务依赖）
纵向：按业务模块
横向：抽取公共服务，提高复用性

拆分类型

独立 project：适用于大型项目
Maven 聚合，分开打包：较小型项目

注册中心

整合服务调用、服务提供者
提供负载均衡，心跳续约、推送变更（防失效）

Nacos

需要提供数据库，配置服务注册

服务发现 -> 挑选示例（负载均衡） -> 调用

OpenFeign

声明式http客户端，简化http请求书写

使用步骤：导入 client 模块 -> 打开开关 -> 写接口
接口的作用是转发 http 请求，作为各个服务间请求数据的中介
连接池：底层请求用的是 Client，效率较低，用连接池优化
最佳实践：1. 将查询接口放到服务提供方 2 . 封装为统一的api模块（耦合度较高）
日志记录：定义类、定义日志级别，声明到注解

拆分步骤

先按模块分析，将实体类区分开
选择拆分类型，建立模块或项目，改依赖
导入并修改启动类、配置类、各种实体类，根据报错再修改
导入service、impl、controller、mapper
重建数据库、配置启动项进行测试

注意

若 service 中还需要注入其他模块的 service，就要配置注册中心。接入 feign 的 api 接口来调用指定服务。在拆分的同时不断完善 feign 的接口（从目标服务的 controller 中抽取）。

配置docker

Mon, 29 Sep 2025 00:00:00 +0000

CentOS7

查看是否已安装

`1`	`docker --version`

若已安装：

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

安装依赖工具 yum

`1`	`sudo yum install -y yum-utils device-mapper-persistent-data lvm2`

错误：yum-config-manager：找不到命令

yum -y install yum-utils

错误：更新 yum 报错

sudo tee /etc/yum.repos.d/CentOS-Base.repo «-‘EOF’ [base] name=CentOS-$releasever - Base baseurl=http://mirrors.aliyun.com/centos/$releasever/os/$basearch/ gpgcheck=1 gpgkey=http://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7

[updates] name=CentOS-$releasever - Updates baseurl=http://mirrors.aliyun.com/centos/$releasever/updates/$basearch/ gpgcheck=1 gpgkey=http://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7

[extras] name=CentOS-$releasever - Extras baseurl=http://mirrors.aliyun.com/centos/$releasever/extras/$basearch/ gpgcheck=1 gpgkey=http://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7

EOF

安装docker

添加 docker 官方仓库

sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 阿里云：
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

安装

`1`	`sudo yum install -y docker-ce docker-ce-cli containerd.io`

启动、设置开机自启

1
2

sudo systemctl start docker
sudo systemctl enable docker

docker 拉取镜像源配置

添加多个镜像源

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://alzgoonw.mirror.aliyuncs.com",
    "https://docker.m.daocloud.io",
    "https://dockerhub.icu",
    "https://docker.anyhub.us.kg",
    "https://docker.1panel.live"
  ]
}

EOF

重新加载并重启

1
2

sudo systemctl daemon-reload
sudo systemctl restart docker

测试

`1`	`docker pull hello-world`

Ubuntu

删除无效的密钥文件

`1`	`rm -f /etc/apt/trusted.gpg.d/docker.gpg`

更换方式获取 Docker GPG 密钥

`1`	`curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg \| gpg --dearmor -o /etc/apt/trusted.gpg.d/docker.gpg`

替换 Docker 源为国内镜像

# 删除原有Docker源
rm -f /etc/apt/sources.list.d/docker.list
# 添加阿里云Docker源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/trusted.gpg.d/docker.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

更新源并安装 Docker

`1`	`apt update && apt install -y docker-ce docker-ce-cli containerd.io`

docker 配置

1
2

sudo systemctl start docker
sudo systemctl enable docker

添加多个[镜像源](国内可用 Docker 镜像源 - 长期维护更新 | 解决 Docker Hub 拉取慢/失败 - 土薯在线工具)

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://alzgoonw.mirror.aliyuncs.com",
    "https://docker.m.daocloud.io",
    "https://dockerhub.icu",
    "https://docker.anyhub.us.kg",
    "https://docker.1panel.live"
  ]
}

EOF

重新加载并重启

1
2

sudo systemctl daemon-reload
sudo systemctl restart docker

测试

`1`	`docker pull hello-world`

配置 clash

克隆安装脚本

1
2
3

git clone --branch master --depth 1 https://github.com/nelvko/clash-for-linux-install.git \
   && cd clash-for-linux-install \
   && sudo bash install.sh

检查安装状态

`1`	`clashctl status`

获取 Web 控制台地址

`1`	`clashctl ui`

其他

Tun模式：clashctl tun on

docker 的代理需要额外配置

LXC 中使用 docker

参考：SOLVED - Docker inside LXC (net.ipv4.ip_unprivileged_port_start error) | Proxmox Support Forum

可能在启动时会有问题，要找指定版本！

版本选择依据

避开有 bug 的版本：论坛明确 1.7.28-2 及更高版本（如 1.7.29-1、2.1.5-1）会触发 LXC 中 Docker 修改 net.ipv4.ip_unprivileged_port_start 的权限错误，必须选择低于 1.7.28-2 的版本。
选择最接近的稳定版本：1.7.28-1~ubuntu.24.04~noble 是 1.7.28-2 的前一个版本，仅差小版本修复，功能完整且无该兼容性 bug，比更旧的 1.7.27-1/1.7.26-1 更推荐（减少版本回退带来的其他兼容性问题）。

微服务保护及分布式事务

Mon, 08 Sep 2025 00:00:00 +0000

微服务保护

问题：

雪崩问题：某个服务故障，导致整个链路失效
- 微服务相互调用
- 没有做好异常处理
- 所有服务级联失败

解决思路：

尽量避免服务故障、阻塞
做好异常的后备方案

方案：

请求限流
线程隔离：控制业务可用线程数量
服务熔断：将异常比例过高的接口断开，直接走 fallback
失败处理：定义 fallback 处理逻辑

Sentinel

整合到微服务中，配置控制台

簇点链路：默认情况下，Sentinel 拦截的只是 Controller 的请求路径，故需要配置其拦截请求方法。

请求限流

设置 QPS，每秒最多请求线程数

Jmeter

请求模拟工具，用于测试压力

线程隔离

服务 B 出现阻塞或故障时，调用服务 B 的服务 A 的资源也可能因此被耗尽，故必须限制服务 A 中调用服务B的线程数。保护服务 A 中其他接口。

Fallback

将 FeignClient 添加到服务，若超限，则调用其中的 FallFactory 的接口。

服务熔断

解决雪崩问题的重要手段。有断路器统计服务调用的异常比例、慢请求比例，若超出阈值则熔断改服务。

分布式事务

分布式系统中，一个业务需要多个服务共同完成，则这多个服务需要同时成功或失败。

解决思路：

各个子事务之间能感知到彼此的状态

Seata

Seata架构

TC：事务协调者，协调全局事务提交或回滚

TM：事务管理器，定义全局事务的范围，开始提交或回滚（入口）

RM：资源管理器，与 TC 交谈以注册事务状态

部署 TC 服务

seata 用 docker 部署，然后注册到 Nacos 上

微服务集成 Seata

在 application.yml 中添加配置，让微服务找到 TC 地址

抽取共享配置到 nacos、划分事务组

seata:
  registry: # TC服务注册中心的配置，微服务根据这些信息去注册中心获取tc服务地址
    type: nacos # 注册中心类型 nacos
    nacos:
      server-addr: 192.168.150.101:8848 # nacos地址
      namespace: "" # namespace，默认为空
      group: DEFAULT_GROUP # 分组，默认是DEFAULT_GROUP
      application: seata-server # seata服务名称
      username: nacos
      password: nacos
  tx-service-group: hmall # 事务组名称
  service:
    vgroup-mapping: # 事务组与tc集群的映射关系
      hmall: "default"

XA 模式

步骤：

RM 注册分支事务到 TC
RM 执行 sql 但不提交
RM 报告执行状态到 TC
TC 检查各分支执行状态，RM 等待 TC 指令

问题：

需要锁定数据库资源，需要等待，性能较差

AT 模式

弥补 XA 模式中资源锁定周期过长的缺陷

步骤：

注册分支事务
记录数据快照
执行 sql 并提交
报告事务状态
删除快照 / 根据快照恢复数据

问题：

短暂的数据不一致

使用：

对每个服务创建一个 undo_log 表