一维数组

一维数组声明：type arrayName[ arraySize ];

1
2

// 声明数组
int array1[5];

一维数组初始化：

1
2
3
4

// 初始化数组
float array1[5] = {1, 2, 3, 4, 5};
// 初始化数组（省略数组大小声明，默认大小为初始化时元素的个数）
float array2[] = {1, 2, 3, 4, 5};

一维数组访问：

1
2
3
4
5
6

// 通过索引逐个访问数组元素，并赋值
array1[0];  // 1
array1[1];  // 2
array1[2];  // 3
array1[3];  // 4
array1[4];  // 5

多维数组

多维数组声明：type name[ size1 ][ size2 ]...[ sizeN ];

1
2

// 声明一个三维 5 . 10 . 4 整型数组
int array1[5][10][4];

二维数组初始化：

1
2
3
4
5
6
7
8
9

// 多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。
int a[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

// 内部嵌套的括号是可选的，下面的初始化与上面是等同的：
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

二维数组访问：

1
2
3
4
5
6
7

for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
  for (int j = 0; j < sizeof(a[0]) / sizeof(a[0][0]); j++)
  {
    cout << a[i][j] << endl;
  }
}

二维数组大小及长度获取：

1
2
3
4
5
6
7
8

// 数组总大小：48
sizeof(a)
// 数组第一维大小：16
sizeof(a[0])
// 数组第一维长度：3
sizeof(a) / sizeof(a[0])
// 数组第二维长度：4
sizeof(a[0]) / sizeof(a[0][0])

数组名

数组名是指向数组中第一个元素的常指针（常量指针），因此 arrayName 等价于 &arrayName[0]，验证如下：

1
2
3

int arrayName[] = {0, 1, 2, 3, 4};
cout << arrayName << endl;     // 0x7ffeec364620
cout << &arrayName[0] << endl; // 0x7ffeec364620

由于数组是常指针，因此自身无法执行算术运算：

1
2
3
4
5
6
7
8

// 表达式必须是可修改的左值
// invalid operands to binary expression
arrayName += 1;
arrayName -= 1;
arrayName++;
arrayName--;
++arrayName;
--arrayName;

数组构成

• 存储一个固定大小的相同数据类型元素的顺序集合。
• 由连续的内存地址组成。

验证如下：

1
2
3

for (int i = 0; i < 5; i++) {
  cout << &arrayName[i] << endl;
}

输出如下：

1
2
3
4
5

0x7ffeec364620
0x7ffeec364624
0x7ffeec364628
0x7ffeec36462c
0x7ffeec364630

分析上述输出结果，由于 1 个内存单元的大小是 8 bits，即一个字节。而一个 int 类型的变量占用 4 个字节，因此上述 16 进制表示的内存地址的递增步长为 4。

获取数组大小

通过 sizeof 运算符，确认该数组大小为 20 字节：

1

sizeof(arrayName) // 20

获取数组长度

sizeof 运算符用于获取变量的存储大小（即所占内存字节数），由于数组中每个元素的类型都是一样的、所占字节数亦然，因此可以计算如下：

1

sizeof(arrayName) / sizeof(arrayName[0]);  // 5

参考：C 语言数组传入函数获取数组长度的方法

遍历数组元素

使用数组索引访问数组元素：

1
2
3

for (int i = 0; i < 5; i++) {
  cout << arrayName[i] << endl;	// 1 2 3 4 5
}

指针数组 VS 数组指针

指针数组

指针数组，表示“存储指针的数组”，即定义一个数组，其每个元素都是指针：

1

int *p1[10];

数组指针

数组指针，表示“指向数组的指针”，即定义一个指针，指向数组：

1

int *p2 = new int[10];

常用于定义函数的形式参数：

1

void func(int *p);

优点：数组作为常指针不能执行算术运算，但数组指针可以。下面通过递增指针，以顺序访问数组元素：

1
2
3
4
5
6
7
8

int arrayName[5] = {1, 2, 3, 4, 5};  // &arrayName = 0x7ffee7376620
int *p = arrayName;

for (int i = 0; i < 5; i++)
{
  cout << p << endl;  // 0x7ffee7376620 0x7ffee7376624 0x7ffee7376628 0x7ffee737662c 0x7ffee7376630
  cout << *p++ << endl;  // 1 2 3 4 5
}

传递数组给函数

三种方式

有三种方式传递数组给函数。

方式一：形式参数是一个数组指针（指向数组的指针）。

1
2
3
4

void func(int *p)
{
  cout << sizeof(p) << endl;  // 返回指针长度 8 bytes
}

方式二：形式参数是一个已定义大小的数组。

1
2
3
4
5

void func(int p[5])
{
  // sizeof on array function parameter will return size of 'int *' instead of 'int [5]'
  cout << sizeof(p) << endl;  // 返回指针长度 8 bytes
}

方式三：形式参数是一个未定义大小的数组。

1
2
3
4
5

void func(int p[])
{
  // sizeof on array function parameter will return size of 'int *' instead of 'int []'
  cout << sizeof(p) << endl;  // 返回指针长度 8 bytes
}

注意点

无论使用何种方式，函数内都无法获取数组长度，需要使用单独变量将数组长度作为参数传入。

1
2
3
4
5
6
7

void func(int p[], int length)
{
  for (int i = 0; i < 5; i++)
  {
    cout << p[i] << endl;  // 1 2 3 4 5
  }
}

参考

http://www.cplusplus.com/doc/tutorial/arrays/

https://www.runoob.com/cplusplus/cpp-arrays.html

引用

引用是一个别名，也就是说，它是某个已存在变量的另一个名字。修改引用等同于修改被引用变量自身。

一个变量可以有多个引用。

声明引用

不存在空引用。声明引用的同时，必须初始化，否则报编译错误如下：

1

int &ref;  // declaration of reference variable 'ref' requires an initializer

引用一旦初始化，就不能再指向另一个变量。修改引用等同于修改被引用变量本身。

指针

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。

声明指针

一元运算符 * 用于声明一个指针变量：

1
2
3
4
5

bool   *bp;    // 声明一个布尔型的空指针
char   *ch;    // 声明一个字符型的空指针
int    *ip;    // 声明一个整型的空指针
double *dp;    // 声明声明一个 double 型的空指针
float  *fp;    // 声明一个浮点型的空指针

• 可以声明空指针。
• 除了常指针，其它指针可以在任何时间被初始化。
• 所有指针的值的实际数据类型，不管是布尔型、字符型、整型、浮点型，还是其它的数据类型，都是一样的，其值都是一个代表内存地址的十六进制数。
• 不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同，因此执行递增或递减时的步长不同。

获取指针大小

本机为 64 位操作系统，验证如下：

1
2
3
4
5

sizeof(bool*)  // 8
sizeof(char*)  // 8
sizeof(int*)    // 8
sizeof(float*)  // 8
sizeof(double*) // 8

指针的算数运算

可以对指针进行四种算术运算：++、--、+、-。运算后，指针保存新的地址。

1
2
3
4
5
6
7
8
9
10
11

int a = 0;
int b = 1;
int * p = &a;

p = &b;
p += 1;
p -= 1;
p++;
p--;
++p;
--p;

重点考点

1
2
3
4
5
6
7
8

// 常指针
int* const p = &a;

// 指向常量的指针
const int * p;

// 指向常量的常指针
const int * const p = &a;

常指针

顾名思义，指针本身是个常量，不能修改。

1
2
3
4
5
6
7
8
9
10
11
12
13

int a = 0;
int b = 1;
int* const p = &a;

// 表达式必须是可修改的左值
// cannot assign to variable 'p' with const-qualified type 'int *const'
p = &b;
p += 1;
p -= 1;
p++;
p--;
++p;
--p;

常见的常指针，例如：

• 数组名

指向常量的指针

顾名思义，指针指向的是常量，不能修改其值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int a = 0;
int b = 1;
const int * p = &a;

// 指针本身可以重新赋值
p = &b;

// 但不能修改指针指向的常量的值，否则报编译错误：
// 表达式必须是可修改的左值
// read-only variable is not assignable
*p += 1;
*p -= 1;
(*p)++;
(*p)--;
++(*p);
--(*p);

指向常量的常指针

结合了上述两种特性。

常见指针

字符串指针

1
2

// 字符串指针（指向一个常量字符串，它被存放在程序的静态数据区，一旦定义就不能改变）
char * str = "hello world";

数组指针

1
2
3
4
5
6
7
8

int arrayName[5] = {1, 2, 3, 4, 5};  // &arrayName = 0x7ffee7376620
int * p = arrayName;  // // 数组指针（Pointers to array，即指向数组中第一个元素的地址）

for (int i = 0; i < 5; i++)
{
  cout << p << endl;  // 0x7ffee7376620 0x7ffee7376624 0x7ffee7376628 0x7ffee737662c 0x7ffee7376630
  cout << *p++ << endl;  // 1 2 3 4 5
}

结构体指针

1
2
3
4
5
6
7

product apple;
// 结构体指针（Pointers to struct）
product * p = &apple;
// The arrow operator (->) is a dereference operator that is used exclusively with pointers to objects that have members. This operator serves to access the member of an object directly from its address.
p->weight;
// equivalent to:
(*p).weight;

类指针

1
2
3
4
5
6
7
8
9
10

Rectangle rect(3, 4);
// 类指针（Pointers to classes），主要用于多态性
Shape * p = ▭

// member y of object x
rect.area();  // 12
// member y of object pointed to by x
p->area();    // 12
// equivalent to:
(*p).area();  // 12

引用与指针对比

常见问题，下列代码的区别？

1
2
3
4

*p
&p
*&p
&*p

要解决这个问题，首先需要了解这两个运算符的区别：

代码示例如下：

1
2
3
4
5
6
7

int a = 10;
int& b = a;
int* p = &a;

cout << "a = " << a << ", &a = " << &a << ", *&a = " << *&a << endl;
cout << "b = " << b << ", &b = " << &b << ", *&b = " << *&b << endl;
cout << "p = " << p << ", &p = " << &p << ", *p = " << *p << ", &*p = " << &*p << ", *&p = " << *&p << endl

输出结果如下：

1
2
3

a = 10, &a = 0x7ffee483763c, *&a = 10
b = 10, &b = 0x7ffee483763c, *&b = 10
p = 0x7ffee483763c, &p = 0x7ffee4837628, *p = 10, &*p = 0x7ffee483763c, *&p = 0x7ffee483763c

总结如下：

引用与指针的区别，如下图：

参考

http://www.cplusplus.com/doc/tutorial/pointers/

Difference between pointer and reference in C ?

C++ 中的参数传递方式：传值、传地址、传引用总结

32/64 位系统支持多大内存？

函数定义

函数定义形式如下：

• 函数头

  • 返回类型

  • 函数名称

  • 形式参数

    • 无参数函数

    • 有参数函数

      • 参数默认值（必须从右到左赋默认值）

        1 2 3 4 5 6 7 8 9 10 11

        // 函数默认值，必须从右到左 int max2(int num1, int num2 = 100) { return num1 > num2 ? num1 : num2; } // 否则报编译错误：missing default argument on parameter 'num2' int max3(int num1 = 100, int num2) { return num1 > num2 ? num1 : num2; }

• 函数体

函数声明

函数必须先声明后使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <iostream>
using namespace std;

// 函数必须先声明后使用
int max1(int num1, int num2);
 
int main()
{
  cout << "result is " << max1(1, 10) << endl;  // 否则报错：未定义标识符 use of undeclared identifier 'max1'
  return 0;
}

int max1(int num1, int num2)
{
  return num1 > num2 ? num1 : num2;
}

函数参数

函数的实际参数有三种传递方式：

传址与传引用的使用区别，如下：

函数调用

函数的调用方式：

• 嵌套调用
• 递归调用（直接递归， 间接递归）

参考

http://www.cplusplus.com/doc/tutorial/functions/

一、预处理器

参考：

• C 预处理器
• Preprocessor directives

二、头文件

https://www.runoob.com/cprogramming/c-header-files.html

https://www.runoob.com/cprogramming/c-standard-library.html

三、基础语法

1、标识符（identifier）

是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。

一个标识符只能以：

• 字母 A-Z 或 a-z 或下划线 _ 开始；
• 后跟零个或多个字母、下划线和数字（0-9）。

2、保留字（关键字）

3、注释

单行注释（行注释）：//

多行注释（块注释）：/* ... */

4、变量与常量

C++ 变量类型

C++ 数据类型

C++ 修饰符类型

C++ 变量作用域

4.1、基本数据类型

C 语言的基本数据类型：

C 语言各种数据类型的内存映像（32 位平台）：

参考：

【计算机如何编码大数和小数-哔哩哔哩】 https://b23.tv/8rEeTf0

4.2、修饰符

C++ 允许在 char、int 和 double 数据类型前放置修饰符。修饰符用于改变基本类型的含义，所以它更能满足各种情境的需求。

4.3、作用域

在 C++ 中：

• 作用域可分为：
  • 全局作用域
  • 局部作用域
  • 语句作用域
• 作用域优先级：范围越小，优先级越高
• 如果希望在局部作用域中使用同名的全局变量，可以在该变量前使用：作用域运算符 ::

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>
using namespace std;

// 全局变量
int x = 10;

int main()
{
  // 局部变量
  int x = 100;
  cout << x << endl; // 100
  cout << ::x << endl; // 10
}

4.4、常量定义

在 C++ 中，有两种简单的定义 C++ 常量的方式：

• 使用 #define 预处理器进行宏定义。
• 使用 const 关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
using namespace std;

// 定义常量（使用预处理器）
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
  // 定义常量（使用 const 关键字）
  const int  LENGTH = 10;
  const int  WIDTH  = 5;
  const char NEWLINE = '\n';
  
  return 0;
}

5、运算符

5.1、位运算符

5.2、算术运算符

5.3、赋值运算符

5.4、关系运算符

5.5、逻辑运算符

5.6、其它运算符

6、控制语句

C 语言有九种控制语句。 可分成以下三类：

6.1、选择语句

• if、else 语句
• switch 语句

6.2、循环语句

• while 语句
• do while 语句
• for 语句

6.3、跳转语句

• break 语句
• continue 语句
• goto语句（此语句尽量少用，因为这不利结构化程序设计，滥用它会使程序流程无规律、可读性差）

参考

https://www.cplusplus.com/doc/tutorial/

https://www.cplusplus.com/doc/tutorial/variables/

https://www.cplusplus.com/doc/tutorial/namespaces/

《C 语言入门教程 - 阮一峰》

环境准备

打开 VScode，进入 Extensions，二选一搜索并安装以下扩展：

方式一：官方插件 C/C++

Using Clang in Visual Studio Code 教程指引如何使用官方插件 C/C++ 进行构建与调试。

按教程配置 .vscode 文件夹的三个文件：

• tasks.json （编译器构建设置）
• launch.json （调试器设置）
• c_cpp_properties.json （编译器路径和 IntelliSense 设置）

⇧⌘B 编译源文件：

1

/usr/bin/clang++ -std=c++17 -stdlib=libc++ -g /Users/wuqd/Documents/workspace/cpp/HelloWorld.cpp -o /Users/wuqd/Documents/workspace/cpp/HelloWorld.out

编译成功后：

• 可以在「终端」输入 ./HelloWorld.out 以直接运行编译文件；

• 还可以按 F5 调试。

方式二：三方插件 Code Runner

安装第三方插件：Code Runner

settings.json 新增配置如下，将编译文件的后缀名改为 .out，以便 .gitignore：

1
2
3

"code-runner.executorMap": {
  "cpp": "cd $dir && g++ $fileName -o $fileNameWithoutExt.out && $dir$fileNameWithoutExt.out"
}

⌃⌥N 编译并运行：

1

cd "/Users/wuqd/Documents/workspace/cpp/" && g++ HelloWorld.cpp -o HelloWorld.out && "/Users/wuqd/Documents/workspace/cpp/"HelloWorld.out

常见问题

DIFFERENCE BETWEEN g++ & gcc

GCC 代表 GNU Compiler Collections，主要用于编译 C 和 C++ 语言。它还可以用于编译 Objective C 和 Objective C++。编译源代码文件时需要的最重要的选项是源程序的名称，其余每个参数都是可选的，如警告、调试、链接库、目标文件等。

g++ 命令是 GNU C++ 编译器调用的命令，用于源代码的预处理、编译、汇编和链接以生成可执行文件。

g++	gcc
g++ is used to compile C++ program.	gcc is used to compile C program.
g++ can compile any .c or .cpp files but they will be treated as C++ files only.	gcc can compile any .c or .cpp files but they will be treated as C and C++ respectively.
Command to compile C++ program through g++ is g++ fileName.cpp -o binary	command to compile C program through gcc is gcc fileName.c -o binary
Using g++ to link the object files, files automatically links in the std C++ libraries.	gcc does not do this.
g++ compiles with more predefined macros.	gcc compiles C++ files with more number of predefined macros. Some of them are #define GXX_WEAK 1, #define __cplusplus 1, #define __DEPRECATED 1, etc

DIFFERENCE BETWEEN gcc & make

gcc是编译器 而make不是 make是依赖于Makefile来编译多个源文件的工具 在Makefile里同样是用gcc(或者别的编译器)来编译程序.

gcc是编译一个文件，make是编译多个源文件的工程文件的工具。

make是一个命令工具，是一个解释makefile中指令的命令工具。

make就是一个gcc/g++的调度器，通过读入一个文件（默认文件名为Makefile或者makefile），执行一组以gcc/g++为主的shell命令序列。输入文件主要用来记录文件之间的依赖关系和命令执行顺序。

gcc是编译工具；

make是定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译；

也就是说make是调用gcc的。

cannot edit in read-only editor

GBK to UTF-8 乱码问题

https://www.cnblogs.com/kingsonfu/p/11010086.html

参考

Using Clang in Visual Studio Code

http://www.cplusplus.com/doc/tutorial/introduction/

C++ 在线编译器

C++ Insights

C++ Compiler Explorer

VSCode 其它插件推荐：

• C/C++ Clang Command Adapter
• C++ Intellisense

日志门面：

• Apache Commons Logging (JCL) 是 Apache Commons 的一个开源项目。官网：https://commons.apache.org/proper/commons-logging/
• SLF4J 全称为 Simple Logging Facade for Java，即 Java 简单日志门面。官网：http://www.slf4j.org/

日志门面——SLF4J

优点：

• 通过依赖配置，在编译期静态绑定真正的日志框架库。

  What has changed in SLF4J version 2.0.0?

  More visibly, slf4j-api now relies on the ServiceLoader mechanism to find its logging backend. SLF4J 1.7.x and earlier versions relied on the static binder mechanism which is no loger honored by slf4j-api version 2.0.x. More specifically, when initializing the LoggerFactory class will no longer search for the StaticLoggerBinder class on the class path.

  Instead of “bindings” now org.slf4j.LoggerFactory searches for “providers”. These ship for example with slf4j-nop-2.0.x.jar, slf4j-simple-2.0.x.jar or slf4j-jdk14-2.0.x.jar.

• 不需要使用 logger.isDebugEnabled() 来解决日志因为字符拼接产生的性能问题。SLF4J 的方式是使用 {} 作为字符串替换符。

• 提供了很多桥接方案，以便灵活替换日志库。

缺点：

• 旧版不支持 Lambda 表达式（slf4j-api-2.0.0-alpha 支持但还未 GA）。但日志框架 Log4j 2.4 及以上版本支持 Java 8 Lambda，参考 1、2，例如：

  1	logger.debug("This {} and {} with {} ", () -> this, () -> that, () -> compute());

SLF4J bindings

http://www.slf4j.org/manual.html#swapping

Logback

https://logback.qos.ch/

推荐使用 SLF4J bound to logback-classic 的经典组合：

1
2
3
4
5

<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.3</version>
</dependency>

传递依赖如下：

1
2
3

ch.qos.logback:logback-classic:jar:1.2.3:compile
+- ch.qos.logback:logback-core:jar:1.2.3:compile
\- org.slf4j:slf4j-api:jar:1.7.25:compile

Log4j 2.x

https://logging.apache.org/log4j/2.x/

需引入适配层依赖：

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.16.0</version>
</dependency>

传递依赖如下：

1
2
3
4

org.apache.logging.log4j:log4j-slf4j-impl:jar:2.16.0:compile
+- org.slf4j:slf4j-api:jar:1.7.25:compile
+- org.apache.logging.log4j:log4j-api:jar:2.16.0:compile
\- org.apache.logging.log4j:log4j-core:jar:2.16.0:runtime

参考：

• 《试试这款性能最强的日志框架 Log4j 2》
• <Reasons to prefer logback over log4j 1.x>
  • log4j.properties to logback.xml Translator
• 《突发！Log4j 2 爆“核弹级”漏洞，Flink、Kafka 等至少十多个项目受影响》
• 《Log4j 2 再发新版本 2.16.0，完全删除 Message Lookups 的支持，加固漏洞防御！》

Log4j 1.x

https://logging.apache.org/log4j/1.2/

On August 5, 2015 the Logging Services Project Management Committee announced that Log4j 1.x had reached end of life.

需引入适配层依赖：

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.32</version>
</dependency>

传递依赖如下：

1
2
3

org.slf4j:slf4j-log4j12:jar:1.7.32:compile
+- org.slf4j:slf4j-api:jar:1.7.32:compile
\- log4j:log4j:jar:1.2.17:compile

java.util.logging (JUL)

需引入适配层依赖：

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-jdk14 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>1.7.32</version>
</dependency>

传递依赖如下：

1
2

org.slf4j:slf4j-jdk14:jar:1.7.32:compile
\- org.slf4j:slf4j-api:jar:1.7.32:compile

日志框架——Logback

Configuration

https://logback.qos.ch/manual/configuration.html

Logback 配置文件样例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
    <springProperty scope="context" name="LOG_PATH" source="log.path" defaultValue="/data/logs"/>
    <springProperty scope="context" name="ACTIVE_PROFILE" source="spring.profiles.active" defaultValue="dev" />
    <springProperty scope="context" name="LOG_PATTERN" source="log.pattern" defaultValue="[%d{yyyy-MM-dd HH:mm:ss.SSS}] %5p [%t] %logger{50}:%L [%X{traceId}] --> %m%n" />
    <springProperty scope="context" name="MONGO_URI" source="spring.data.mongodb.uri" />

    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <!-- 每天归档日志文件 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/project-${ACTIVE_PROFILE}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <fileNamePattern>${LOG_PATH}/project-${ACTIVE_PROFILE}-%i.log.%d{yyyyMMdd}</fileNamePattern>
            <!--日志文件保留天数-->
            <maxHistory>90</maxHistory>
            <maxFileSize>100MB</maxFileSize>
            <totalSizeCap>20GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <!-- 自定义 MongoDB Appender -->
    <appender name="MONGO" class="com.test.MongoDBAppender"></appender>

    <logger name="org.springframework" level="WARN"/>

    <root level="INFO">
        <appender-ref ref="FILE" />
        <appender-ref ref="STDOUT" />
        <appender-ref ref="MONGO" />
    </root>

</configuration>

Appenders

有三种 Appenders：

1. Logback 官方提供的 Appenders。
2. 第三方提供的 Appenders（logstash、…）。
3. 自定义 Appenders。

官方 Appenders

Logback 官方提供的 Appenders 如下：http://logback.qos.ch/manual/appenders.html

其中，常用的两个 Appender 继承结构如下：

• ch.qos.logback.core.ConsoleAppender
• ch.qos.logback.core.rolling.RollingFileAppender

其中，ch.qos.logback.core.rolling.RollingFileAppender 可选的策略类如下：

第三方 Appenders

https://github.com/logstash/logstash-logback-encoder

Provides logback encoders, layouts, and appenders to log in JSON and other formats supported by Jackson.

自定义 Appenders

通过自定义 Appenders，可以将日志输出到任意位置，如 MongoDB、Kafka 等服务。

下面演示一个简单的同步 Appender，如需异步 Appender，参考这里。

首先，新建 Appender，继承自抽象类：

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.UnsynchronizedAppenderBase;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoClientDbFactory;

public class MongoDBAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {

    private SimpleMongoClientDbFactory mongoDbFactory;
    private MongoTemplate mongoTemplate;
    private final ReentrantLock lock = new ReentrantLock(false);

    @Override
    public void start() {
        String uri = this.getContext().getProperty("MONGO_URI");
        mongoDbFactory = new SimpleMongoClientDbFactory(uri);
        mongoTemplate = new MongoTemplate(mongoDbFactory);
        super.start();
    }

    @Override
    protected void append(ILoggingEvent eventObject) {
        lock.lock();
        try {
            PayLog log = new PayLog();
            log.setTraceId(eventObject.getMDCPropertyMap().getOrDefault(MDCUtils.LOG_TRACE_ID, null));
            log.setOper(eventObject.getMDCPropertyMap().getOrDefault(MDCUtils.OPER, null));
            log.setLevel(eventObject.getLevel().toString());
            log.setLogger(eventObject.getLoggerName());
            log.setThread(eventObject.getThreadName());
            log.setMessage(eventObject.getFormattedMessage());
            log.setTimestamp(eventObject.getTimeStamp());
            mongoTemplate.insert(log, "payLog");
        } finally {
            lock.unlock();
        }
    }

}

最后，验证 MongoDB 数据。

Encoders & Layouts

https://logback.qos.ch/manual/encoders.html

https://logback.qos.ch/manual/layouts.html

Logback 提供的 ch.qos.logback.core.encoder.Encoder 和 ch.qos.logback.core.Layout 的默认实现如下：

一般有几种使用组合方式：

自定义 Pattern 格式

基于自定义 Pattern 格式，直接使用 ch.qos.logback.classic.encoder.PatternLayoutEncoder 即可：

1
2
3
4
5
6
7

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  ...
  <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
    <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
    <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  </encoder>
</appender>

还可以输出扩展信息，例如 %X{traceId}。

预定义格式

基于预定义格式，需要使用 ch.qos.logback.core.encoder.LayoutWrappingEncoder，并搭配相应 Layout 实现。例如输出成 HTML 格式：

1
2
3
4
5
6

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    ...
    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        <layout class="ch.qos.logback.classic.html.HTMLLayout" />
    </encoder>
</appender>

Mapped Diagnostic Contexts (MDC)

https://logback.qos.ch/manual/mdc.html

To uniquely stamp each request, the user puts contextual information into the MDC, the abbreviation of Mapped Diagnostic Context.

The MDC class contains only static methods. It lets the developer place information in a diagnostic context that can be subsequently retrieved by certain logback components. The MDC manages contextual information on a per thread basis. Typically, while starting to service a new client request, the developer will insert pertinent contextual information, such as the client id, client’s IP address, request parameters etc. into the MDC. Logback components, if appropriately configured, will automatically include this information in each log entry.

Please note that MDC as implemented by logback-classic assumes that values are placed into the MDC with moderate frequency. Also note that a child thread does not automatically inherit a copy of the mapped diagnostic context of its parent.

Logback leverages SLF4J API:

• org.slf4j.MDC
• org.slf4j.MDC.MDCCloseable

MDC And Managed Threads

https://logback.qos.ch/manual/mdc.html#managedThreads

MDCInsertingServletFilter

https://logback.qos.ch/manual/mdc.html#mis

例子

一、创建 MDCUtils

1
2
3
4
5
6
7
8
9
10
11
12
13

import lombok.experimental.UtilityClass;
import org.slf4j.MDC;

@UtilityClass
public class MDCUtils {

    public static final String TRACE_ID = "traceId";

    public MDC.MDCCloseable addTraceId(String traceId) {
        return MDC.putCloseable(TRACE_ID, traceId);
    }

}

二、在合适的位置设置上下文：

• 在 http 接口的拦截器
• 在定时任务执行之前
• …

代码如下：

1
2
3

try (MDC.MDCCloseable mdc = MDCUtils.addTraceId(...)) {
  // TODO
}

三、选择合适的 Appender 并加以配置，参考 Logback 配置文件样例。

参考

https://github.com/logstash/logstash-logback-encoder

《细说 Java 主流日志工具库》

《SpringBoot + MDC 实现全链路调用日志跟踪》

《Java 中打印日志的正确姿势》

《实战总结 | 系统日志规范及最佳实践 | 阿里技术》

《浅析 JAVA 日志中的几则性能实践与原理解释 | 阿里技术》

https://github.com/FasterXML/jackson

https://github.com/FasterXML/jackson-docs

Core modules

Core modules are the foundation on which extensions (modules) build upon. There are 3 such modules currently (as of Jackson 2.x):

• Streaming (docs) (“jackson-core”) defines low-level streaming API, and includes JSON-specific implementations
• Annotations (docs) (“jackson-annotations”) contains standard Jackson annotations
• Databind (docs) (“jackson-databind”) implements data-binding (and object serialization) support on streaming package; it depends both on streaming and annotations packages

Annotations

https://github.com/FasterXML/jackson-annotations

这个页面列出了所有 Jackson 2.0 通用注解，按功能分组。

常用注解如下：

• @JsonProperty
• @JsonIgnore
• @JsonIgnoreProperties
• @JsonInclude
• @JsonFormat
• @JsonSerialize
• @JsonDeserialize
• …

Databind

For all data-binding, we need a com.fasterxml.jackson.databind.ObjectMapper instance:

1

ObjectMapper mapper = new ObjectMapper(); // create once, reuse

参考：

《ObjectMapper，别再像个二货一样一直 new 了！》

Configuration

https://github.com/FasterXML/jackson-databind/wiki/#reference-manual

POJO

The most common usage is to take piece of JSON, and construct a Plain Old Java Object (“POJO”) out of it.

Serialization:

1
2
3
4
5

MyValue value = mapper.readValue(new File("data.json"), MyValue.class);
// or:
MyValue value = mapper.readValue(new URL("http://some.com/api/entry.json"), MyValue.class);
// or:
MyValue value = mapper.readValue("{\"name\":\"Bob\", \"age\":13}", MyValue.class);

Deserialization:

1
2
3
4
5

mapper.writeValue(new File("result.json"), myResultObject);
// or:
byte[] jsonBytes = mapper.writeValueAsBytes(myResultObject);
// or:
String jsonString = mapper.writeValueAsString(myResultObject);

Generic Collections

You can also handle JDK Lists, Maps.

Serialization:

1
2

Map<String, Integer> scoreByName = mapper.readValue(jsonSource, Map.class);
List<String> names = mapper.readValue(jsonSource, List.class);

Deserialization:

1
2

// and can obviously write out as well
mapper.writeValue(new File("names.json"), names);

Generic Type

如果需要将 JSON 字符串反序列化为泛型，有两种方式：

方式一：TypeReference

方式一：使用 com.fasterxml.jackson.core.type.TypeReference<T>：

This generic abstract class is used for obtaining full generics type information by sub-classing; it must be converted to ResolvedType implementation (implemented by JavaType from “databind” bundle) to be used. Class is based on ideas from http://gafter.blogspot.com/2006/12/super-type-tokens.html, Additional idea (from a suggestion made in comments of the article) is to require bogus implementation of Comparable (any such generic interface would do, as long as it forces a method with generic type to be implemented). to ensure that a Type argument is indeed given.

Usage is by sub-classing: here is one way to instantiate reference to generic type List<Integer>:

1	TypeReference ref = new TypeReference<List<Integer>>() { };

which can be passed to methods that accept TypeReference, or resolved using TypeFactory to obtain ResolvedType.

代码如下：

1
2
3
4
5

TypeReference<RespDTO<XxxRespDTO>> typeRef = new TypeReference<RespDTO<XxxRespDTO>>() {};
RespDTO<XxxRespDTO> resp = mapper.readValue(JSON_A, typeRef);

TypeReference<List<XxxRespDTO>> typeRef1 = new TypeReference<List<XxxRespDTO>>() {};
List<XxxRespDTO> resp2 = mapper.readValue(JSON_B, typeRef1);

方式二：JavaType

方式二：使用 com.fasterxml.jackson.databind.JavaType：

Base class for type token classes used both to contain information and as keys for deserializers.

Instances can (only) be constructed by com.fasterxml.jackson.databind.type.TypeFactory.

JavaType 的继承结构如下图：

代码如下：

1
2
3
4
5

JavaType valueType = mapper.getTypeFactory().constructParametricType(RespDTO.class, XxxRespDTO.class);
RespDTO<XxxRespDTO> resp = mapper.readValue(JSON_A, valueType);

JavaType valueType2 = mapper.getTypeFactory().constructParametricType(List.class, XxxRespDTO.class);
List<XxxRespDTO> resp2 = mapper.readValue(JSON_B, valueType2);

JavaType 的调试结果如下图，其值为 JavaType 的子类 CollectionType：

Tree Model (JsonNode)

Tree Model can be more convenient than data-binding, especially in cases where structure is highly dynamic, or does not map nicely to Java classes.

com.fasterxml.jackson.databind.JsonNode 表示一个 JSON 树节点，可以通过 ObjectMapper#readTree 方法反序列化出来，也可以通过 JsonNode 的子类 API 自定义构建：

构建代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

JsonNode jsonNode =
    new ObjectNode(JsonNodeFactory.instance, ImmutableMap.of(
        "hello",
        new ArrayNode(JsonNodeFactory.instance, ImmutableList.of(
            new ObjectNode(JsonNodeFactory.instance, ImmutableMap.of("key", new TextNode("value0"))),
            new ObjectNode(JsonNodeFactory.instance, ImmutableMap.of("key", new TextNode("value1"))),
            new ObjectNode(JsonNodeFactory.instance, ImmutableMap.of("key2", new TextNode("value2")))
        )),
        "test",
        new ObjectNode(JsonNodeFactory.instance, ImmutableMap.of(
            "key3", new TextNode("value3")))));

// {"hello":[{"key":"value0"},{"key":"value1"},{"key2":"value2"}],"test":{"key3":"value3"}}
log.info(jsonNode.toString());

JsonNode 构建完成后，可以灵活的读取其值，例如：

1
2
3
4

// [value0, value1]
log.info(jsonNode.get("hello").findValuesAsText("key").toString());
// value3
log.info(jsonNode.get("test").get("key3").asText());

也可以修改其值：

1

((ObjectNode) jsonNode).put("key", "value");

使用场景

一、对接口响应的 JSON 原文进行验签：

1
2
3
4
5
6
7
8
9
10
11

{
    "response": {
        "head": {
            ...
        },
        "body": {
            ...
        }
    },
    "signature": "..."
}

1
2
3
4

JsonNode jsonNode = objectMapper.readTree(responseJson);
String response = jsonNode.get("response").toString();
String signature = jsonNode.get("signature").toString();
return RsaUtil.verify(response, publicKey, signature);

二、<Compare Two JSON Objects with Jackson>

using the JsonNode.equals method. The equals() method performs a full (deep) comparison.

例子

本例中，我们需要获取以下两个方法的泛型返回值中的实际类型参数 XxxRespDTO 的 Class 类型，以用于 JSON 转换：

1
2
3
4
5
6
7
8
9
10
11
12

public interface ApiService {

    /**
     * 接口一
     */
    RespDTO<XxxRespDTO> get(XxxReqDTO reqDTO);

    /**
     * 接口二
     */
    RespDTO<List<XxxRespDTO>> list(XxxReqDTO reqDTO);
}

定义一个方法，用于转换 JSON：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

private Object getObject(Method method, String json) {
    Object result;
    
    // 获取该方法的泛型返回值，然后获取其第一个实际类型参数
    ParameterizedType returnType = (ParameterizedType) method.getGenericReturnType();
    Type type = returnType.getActualTypeArguments()[0];
    
    // 处理接口一的情况
    if (type instanceof Class) {
        Class<?> clazz = (Class<?>) type;
        result = JsonUtils.fromJson(json, clazz);  // ObjectMapper#readValue(String, Class<T>)
    } else if (type instanceof ParameterizedType) {
        ParameterizedType nestedReturnType = (ParameterizedType) type;
        // 处理接口二的情况
        if (nestedReturnType.getRawType() == List.class) {
            Class<?> clazz = (Class<?>) nestedReturnType.getActualTypeArguments()[0];
            result = JsonUtils.fromJsonToList(decryptedRespData, clazz);
        } else {
            throw new IllegalStateException("未实现的 JSON 解析！");
        }
    } else {
        throw new IllegalStateException("未实现的 JSON 解析！");
    }
    return result;
}

这种用法常常出现在框架之中。下面来看下调试效果：

接口一

下图展示了变量 returnType 为参数化类型 ParameterizedType，其实际类型参数 type 为 Class 类型，值为 XxxRespDTO ：

接口二

下图展示了变量 returnType 的实际类型参数 type 与接口一为 Class 类型不同，接口二为 ParameterizedType 参数化类型，值为 List<XxxRespDTO>：

常见报错

Unrecognized field, not marked as ignorable

该错误的意思是说，不能够识别的字段没有标示为可忽略。出现该问题的原因就是 JSON 中包含了目标 Java 对象没有的属性。

解决方案：

1. 保证传入的 JSON 串不包含目标对象的没有的属性。

2. On deserialization, @JsonIgnoreProperties(ignoreUnknown=true) ignores properties that don’t have getter/setters

3. Deserialization Features 全局配置：

   1 2	// 配置该 `objectMapper` 在反序列化时，忽略目标对象没有的属性。 objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)

缺少默认构造方法

问题：

1

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.***.RespBody` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

解决方案：

• POJO 加上 @NoArgsConstructor

Using Java inner classes for Jackson serialization

https://dev.to/pavel_polivka/using-java-inner-classes-for-jackson-serialization-4ef8

Google Gson

https://github.com/google/gson

1
2
3
4
5
6
7
8
9
10
11

JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("time", LocalDateTime.now().toString());
jsonObject.addProperty("ip", ip);
jsonObject.addProperty("rspMillis", rspMillis);
jsonObject.addProperty("rspCode", rspCode);
jsonObject.addProperty("method", method);
jsonObject.addProperty("path", uriPath);
// Deprecated
// new JsonParser().parse(jsonTrace);
jsonObject.add("body", JsonParser.parseString(jsonTrace));
requestJsonLogger.info(jsonObject.toString());

Deserialization to Generic Type: com.google.gson.reflect.TypeToken

1
2

RespDTO<XxxRespDTO> data = new Gson().fromJson(json, new TypeToken<RespDTO<XxxRespDTO>>() {}.getType());
List<XxxRespDTO> data = new Gson().fromJson(json, new TypeToken<ArrayList<XxxRespDTO>>() {}.getType());

参考

https://www.baeldung.com/category/json/jackson/

• https://www.baeldung.com/jackson-vs-gson
• https://www.baeldung.com/jackson-exception

https://github.com/qidawu/java-api-test/tree/master/src/main/java/json

规范

The Jakarta XML Binding provides an API and tools that automate the mapping between XML documents and Java objects.

规范文档：https://jakarta.ee/specifications/xml-binding/

实现

官方认证实现：https://eclipse-ee4j.github.io/jaxb-ri/

依赖下载：https://mvnrepository.com/artifact/com.sun.xml.bind/jaxb-ri，将传递依赖：

1
2
3
4

<dependency>
  <groupId>jakarta.xml.bind</groupId>
  <artifactId>jakarta.xml.bind-api</artifactId>
</dependency>

示例

本文演示如何生成和解析 XML，主要涉及以下常用注解，更多注解可以自行尝试：

1
2
3
4

@XmlRootElement
@XmlElement
@XmlAttribute
@XmlValue

实体类如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// @Setter 会报错 com.sun.xml.internal.bind.v2.runtime.IllegalAnnotationsException: 4 counts of IllegalAnnotationExceptions
@Getter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
@XmlRootElement(name = "head")
class Head {
    @XmlElement(name = "trade_code")
    private String tradeCode;

    @XmlElement(name = "trade_date")
    private String tradeDate;

    @XmlElement(name = "trade_time")
    private String tradeTime;

    @XmlElement(name = "serial_no")
    private String serialNo;

    @XmlElement(name = "parent")
    private Parent parent;
}

@Getter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
@XmlRootElement
class Parent {
    @XmlElement
    private List<Child> child;
}

@Getter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
class Child {
    @XmlAttribute
    private String key;

    @XmlValue
    private String value;
}

XML 工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

@Slf4j
public class XmlUtils {

    private static final Map<String, JAXBContext> JAXB_CONTEXT_MAP = new HashMap<>();

    /**
     * 传入一个对象，生成对应的 XML
     */
    public static <T> String toXml(T t) {
        if (t == null) {
            log.warn("[XmlUtils toXml] params is null");
            return null;
        }

        JAXBContext jaxbContext = getJAXBContext(t.getClass());
        Marshaller jaxbMarshaller;
        try (StringWriter stringWriter = new StringWriter()) {
            jaxbMarshaller = jaxbContext.createMarshaller();
            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
            jaxbMarshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
            jaxbMarshaller.marshal(t, stringWriter);
            return stringWriter.toString();
        } catch (JAXBException | IOException e) {
            log.error("[XmlUtils toXml] exception", e);
        }
        return null;
    }

    /**
     * 将 XML 解析成指定对象
     */
    public static <T> T unXml(String xml, Class<T> clazz) {
        if (xml == null || xml.isEmpty()) {
            log.warn("[XmlUtils unXml] xml is null");
            return null;
        }

        JAXBContext jaxbContext = getJAXBContext(clazz);
        try {
            Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            StringReader reader = new StringReader(xml);
            @SuppressWarnings("unchecked")
            T unmarshal = (T) unmarshaller.unmarshal(reader);
            return unmarshal;
        } catch (JAXBException e) {
            log.error("[XmlUtils unXml] exception", e);
        }
        return null;
    }

    /**
     * 根据类名称获取 JAXBContext
     */
    private static JAXBContext getJAXBContext(Class clazz) {
        JAXBContext jaxbContext = JAXB_CONTEXT_MAP.get(clazz.getName());
        if (jaxbContext == null) {
            try {
                jaxbContext = JAXBContext.newInstance(clazz);
                JAXB_CONTEXT_MAP.put(clazz.getName(), jaxbContext);
            } catch (JAXBException e) {
                log.error(e.getMessage(), e);
            }
        }
        return jaxbContext;
    }

}

生成 XML

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@Test
public void testToXml() {
    LocalDateTime now = LocalDateTime.now();
    Child child = Child.builder()
        .key("key")
        .value("value")
        .build();

    Parent parent = Parent.builder()
        .child(Arrays.asList(child, child))
        .build();

    Head head = Head.builder()
        .tradeCode("XT-001")
        .tradeDate(now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")))
        .tradeTime(now.format(DateTimeFormatter.ofPattern("HH:mm:ss")))
        .serialNo(UUID.randomUUID().toString())
        .parent(parent)
        .build();
    String xml = XmlUtils.toXml(head);
    log.info(xml);
}

输出结果：

1
2
3
4
5
6
7
8
9
10
11

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<head>
    <trade_code>XT-001</trade_code>
    <trade_date>2020-03-19</trade_date>
    <trade_time>18:39:28</trade_time>
    <serial_no>114d2c0c-30a8-4275-982c-f8eba86cbadb</serial_no>
    <parent>
        <child key="key">value</child>
        <child key="key">value</child>
    </parent>
</head>

解析 XML

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Test
public void testUnXml() {
    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" +
        "<head>\n" +
        "    <trade_code>XT-001</trade_code>\n" +
        "    <trade_date>2020-03-19</trade_date>\n" +
        "    <trade_time>18:39:28</trade_time>\n" +
        "    <serial_no>114d2c0c-30a8-4275-982c-f8eba86cbadb</serial_no>\n" +
        "    <parent>\n" +
        "        <child key=\"key\">value</child>\n" +
        "        <child key=\"key\">value</child>\n" +
        "    </parent>\n" +
        "</head>";
    Head head = XmlUtils.unXml(xml, Head.class);
    log.info(head.toString());
}

输出结果

1

Head(tradeCode=XT-001, tradeDate=2020-03-19, tradeTime=18:39:28, serialNo=114d2c0c-30a8-4275-982c-f8eba86cbadb, parent=Parent(child=[Child(key=key, value=value), Child(key=key, value=value)]))

参考

https://jakarta.ee/specifications/xml-binding/

https://en.wikipedia.org/wiki/Jakarta_XML_Binding

Bean Validation 规范

Bean Validation 为 JavaBean 和方法验证定义了一组元数据模型和 API 规范，常用于后端数据的声明式校验。

RoadMap

Bean Validation 规范最早在 Oracle Java EE 下维护。

2017 年 11 月，Oracle 将 Java EE 移交给 Eclipse 基金会。 2018 年 3 月 5 日，Eclipse 基金会宣布 Java EE (Enterprise Edition) 被更名为 Jakarta EE。因此 Bean Validation 规范经历了从 JavaEE Bean Validation 到 Jakarta Bean Validation 的两个阶段：

Bean Validation 1.0 (JSR 303)

Bean Validation 1.0 (JSR 303) was the first version of Java’s standard for object validation.

It was released in 2009 and is part of Java EE 6.

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/javax.validation/validation-api -->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.0.0.GA</version>
</dependency>

Bean Validation 1.1 (JSR 349)

Bean Validation 1.1 (JSR 349) was finished in 2013. Changes between Bean Validation 1.0 and 1.1

It is part of Java EE 7.

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/javax.validation/validation-api -->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.1.0.Final</version>
</dependency>

Bean Validation 2.0 (JSR 380)

Bean Validation 2.0 (JSR 380) was finished in August 2017. Changes between Bean Validation 2.0 and 1.1

It’s part of Java EE 8 (but can of course be used with plain Java SE as the previous releases).

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/javax.validation/validation-api -->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>

Jakarta Bean Validation 2.0

Jakarta Bean Validation 2.0 was published in August 2019. There are no changes between Jakarta Bean Validation 2.0 and Bean Validation 2.0 except for the GAV: it is now jakarta.validation:jakarta.validation-api.

It’s part of Jakarta EE 8 (but can of course be used with plain Java SE as the previous releases).

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/jakarta.validation/jakarta.validation-api -->
<dependency>
    <groupId>jakarta.validation</groupId>
    <artifactId>jakarta.validation-api</artifactId>
    <version>2.0.2</version>
</dependency>

Jakarta Bean Validation 3.0

Jakarta Bean Validation 3.0 was released in Wednesday, October 7, 2020.

This release is part of Jakarta EE 9.

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/jakarta.validation/jakarta.validation-api -->
<dependency>
    <groupId>jakarta.validation</groupId>
    <artifactId>jakarta.validation-api</artifactId>
    <version>3.0.0</version>
</dependency>

Constraints

Constraints 约束是 Bean Validation 规范的核心。约束是通过约束注解和一系列约束验证实现的组合来定义的。约束注解可应用于类型、字段、方法、构造函数、参数、容器元素或其它约束注解。

一个 constraint 通常由 annotation 和相应的 constraint validator 组成，它们是一对多的关系。也就是说可以有多个 constraint validator 对应一个 annotation。在运行时，Bean Validation 框架本身会根据被注释元素的类型来选择合适的 constraint validator 对数据进行验证。

有些时候，在用户的应用中需要一些更复杂的 constraint。Bean Validation 提供扩展 constraint 的机制。可以通过两种方法去实现，一种是组合现有的 constraint 来生成一个更复杂的 constraint，另外一种是开发一个全新的 constraint。

下表列出了常用 Constraints：

内置 Constraints

表 1. Bean Validation 1.x 内置的 Constraints，如下：

Bean Validation 2.0 内置的 Constraints，参考：https://beanvalidation.org/2.0/spec/#builtinconstraints

Bean Validation 3.0 内置的 Constraints，参考官方新版规范：Jakarta Bean Validation specification

第三方 Constraints

表 2. Hibernate Validator 附加的 Constraints，更多 Constraints 详见：Additional constraints

其它第三方 Constraints：

• Java Bean Validation Extension offers a set of useful constraints (@Alphanumeric, @IPv6, @StartsWith…).
• Collection Validators allows to define constraints on elements of collections.
• ……

核心 API

核心类 Validation 作为 Bean Validation 的入口点，提供了三种引导方式。下面代码演示了以最简单的方式创建默认的 ValidatorFactory，并获取 Validator 用以验证 Java Bean。涉及的 API 如下：

• 核心类 javax.validation.Validation：

  Note:

  • The ValidatorFactory object built by the bootstrap process should be cached and shared amongst Validator consumers.
  • This class is thread-safe.

• 接口 javax.validation.ValidatorFactory：

  Factory returning initialized Validator instances.

  Implementations are thread-safe and instances are typically cached and reused.

• 接口 javax.validation.Validator：

  Validates bean instances. Implementations of this interface must be thread-safe.

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import lombok.experimental.UtilityClass;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import javax.validation.Validator;
import java.util.Set;

/**
 * JavaBean 校验器
 */
@UtilityClass
public class ValidatorUtil {

    private static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();

    /**
     * 校验参数
     * @param obj 参数
     * @return 校验结果
     */
    public <T> Set<ConstraintViolation<T>> validate(T obj) {
        return VALIDATOR.validate(obj);
    }

}

Bean Validation 实现

Hibernate Validator

Hibernate 框架提供了各种子项目，如下：

其中，子项目 Hibernate Validator 是 Bean Validation 规范的官方认证实现。

要在 Maven 项目中使用 Hibernate Validator，需要添加如下依赖项：

• 新版实现。6.x 及以上版本已完全从 Hibernate 持久化框架中剥离并被移至新 group：

  hibernate-validator is entirely separate from the persistence aspects of Hibernate. So, by adding it as a dependency, we’re not adding these persistence aspects into the project.

  1 2 3 4 5 6

  <!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator --> <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> <version>7.0.0.Final</version> </dependency>

• 遗留实现，可以下载到 5.x 及之前的老版本，例如：

  1 2 3 4 5 6

  <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-validator</artifactId> <version>5.4.3.Final</version> </dependency>

下表汇总了 Hibernate Validator 各版本的传递依赖：

引入 Hibernate Validator 后，将传递依赖 Bean Validation API 规范相应的版本，无需重复引入：

Hibernate’s Jakarta Bean Validation reference implementation. This transitively pulls in the dependency to the Bean Validation API.

详见如下

• https://search.maven.org/artifact/org.hibernate.validator/hibernate-validator
• /org/hibernate 该子项目 parent pom.xml 的版本号定义

使用方式

分组约束

如果我们想在新增的情况验证 id 和 name，而修改的情况验证 name 和 password，可以使用分组约束功能。

https://blog.csdn.net/win7system/article/details/51241837

组合约束

参考 Bean Validation 文档：Constraint composition

Constraint composition is useful in several ways:

• Avoid duplication and facilitate reuse of more primitive constraints.
• Expose primitive constraints as part of a composed constraint in the metadata API and enhance tool awareness.

Composition is done by annotating a constraint annotation with the composing constraint annotations.

compose constraints via a logical OR or NOT

参考 Hibernate 文档：Boolean composition of constraints

Jakarta Bean Validation specifies that the constraints of a composed constraint are all combined via a logical AND. This means all of the composing constraints need to return true to obtain an overall successful validation.

Hibernate Validator offers an extension to this and allows you to compose constraints via a logical OR or NOT. To do so, you have to use the @ConstraintComposition annotation and the enum CompositionType with its values AND, OR and ALL_FALSE.

自定义约束

参考 Bean Validation 文档：Constraint validation implementation

Dubbo 参数验证

https://dubbo.apache.org/zh/docs/v2.7/user/examples/parameter-validation/

Spring MVC 参数验证

参考：

Spring MVC 方法参数验证

SpringBoot 中使用 @Valid 注解 + 全局异常处理器 优雅处理参数验证

@Validated 和 @Valid 的区别

• @Valid 由 Bean Validation 提供，由 Hibernate Validator 实现。
• @Validated 由 Spring Validator 提供，是 @Valid 的变种，在使用上并没有区别，但在分组、注解位置、嵌套验证等功能上有所不同。

常见问题

缺少 Expression Language 依赖

以 Hibernate Validator 6.0 series 为例，查看其 pom.xml，会发现 Expression Language 依赖被声明为 provided：

1
2
3
4
5

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.el</artifactId>
    <scope>provided</scope>
</dependency>

这表示该依赖在运行时由 Java EE container 容器提供，因此无须重复引入。但对于 Spring Boot 应用来说，则需要添加此依赖。如果缺少该依赖，则报错如下：

1

HV000183: Unable to load 'javax.el.ExpressionFactory'. Check that you have the EL dependencies on the classpath, or use ParameterMessageInterpolator instead

问题原因：缺少 Unified Expression Language (EL) 规范的实现依赖，即 Glassfish。

解决方案：

Hibernate Validator also requires an implementation of the Unified Expression Language (JSR 341) for evaluating dynamic expressions in constraint violation messages.

When your application runs in a Java EE container such as WildFly, an EL implementation is already provided by the container.

In a Java SE environment, however, you have to add an implementation as dependency to your POM file. For instance, you can add the following dependency to use the JSR 341 reference implementation:

1 2 3 4 5

<dependency> <groupId>org.glassfish</groupId> <artifactId>javax.el</artifactId> <version>3.0.0</version> </dependency>

注意，要使用与 Hibernate Validator 匹配的 Unified Expression Language (EL) 的依赖版本。

参考：https://stackoverflow.com/questions/24386771/javax-validation-validationexception-hv000183-unable-to-load-javax-el-express

参考

https://docs.oracle.com/javaee/7/index.html

https://docs.oracle.com/javaee/7/api/index.html

https://jakarta.ee/

https://jakarta.ee/specifications/bean-validation/

https://beanvalidation.org/

https://beanvalidation.org/2.0/spec/

http://hibernate.org/validator/

baeldung

• https://www.baeldung.com/javax-validation
• https://www.baeldung.com/javax-bigdecimal-validation
• https://www.baeldung.com/javax-validation-method-constraints
• https://www.baeldung.com/spring-mvc-custom-validator

《后台表单校验（JSR303）》

《Spring Boot参数校验以及分组校验的使用》

Jakarta Annotations defines a collection of annotations representing common semantic concepts that enable a declarative style of programming that applies across a variety of Java technologies.

通过在 Java 平台中添加 JSR 175（Java 编程语言的元数据工具），我们设想各种技术将使用注解来实现声明式编程风格。如果这些技术各自为共同概念独立定义自己的注解，那将是不幸的。在 Jakarta EE 和 Java SE 组件技术中保持一致性很有价值，但在 Jakarta EE 和 Java SE 之间实现一致性也很有价值。

本规范的目的是定义一小组通用注解，这些注解可在其它规范中使用。希望这将有助于避免在不同 Jakarta EE 规范中定义的注解之间不必要的冗余或重复。这将允许我们将通用注解集中在一个地方，让技术引用此规范，而不是在多个规范中指定它们。这样，所有技术都可以使用相同版本的注解，并且跨平台使用的注解将保持一致。

这些通用注解详见如下：

• javax.annotation
• jakarta.annotation