lllirunze

Android Permission

Fri, 06 Feb 2026 00:00:00 GMT

最近在忙着进行新产品功能的冲刺，傻逼测试为了讨好领导，打着为使用者体验好的旗号一直提出一些正常人类根本不会执行出来的问题来给我们这帮开发提单子。其中有一个最傻逼的单子，它的内容是这样的：

当 APP 在运行过程中，临时进入后台修改应用权限，例如关闭位置权限，会导致软件重启。

测试执拗的认为这是一个崩溃问题。这个傻逼单子让我们一堆开发围着这个问题看了一整天，最后一个大佬从安卓开发者文档才得出结论：

为了让系统取消应用对权限的访问权限，必须终止与应用关联的所有进程。当您调用该 API 时，系统会确定何时可以安全终止这些进程。通常，系统会等待应用有较长时间在后台运行，而不是在前台运行时。

也就是说，任何一个安卓APP在后台修改应用权限都会导致应用重启，tb，zfb，dy等应用都是如此，这才让我们解决这个问题。（虽然这本来就不是问题）

希望测试体谅一下开发，保持最起码的专业能力，不要提出傻逼问题。

:::note[Reference]

请求运行时权限 :::

Linux Command Cheatsheet-1

Fri, 24 Oct 2025 00:00:00 GMT

Linux命令是用于与Linux操作系统进行交互的指令，通常通过终端或命令行界面输入。这些命令可以用于执行各种任务，如文件管理、系统监控、用户管理、程序执行等。每个命令通常有一个特定的功能，并且可以带有选项或参数来改变命令的行为。

Linux目录结构

linux目录是以树状管理的，我们可以输入ls /获得根目录内容。

根目录内容	功能
`bin`	存放基本的系统命令和二进制可执行文件
`boot`	包含启动系统所需的文件，例如Linux内核文件和启动加载器相关文件
`dev`	存储设备文件
`etc`	存放系统配置文件和管理文件
`home`	存储普通用户的个人目录
`lib`	存放系统和应用程序所需的共享库文件。这些库文件包含程序运行所需的函数和资源。
`media`	用于挂载可移动媒体设备（如USB驱动器、CD/DVD等）
`mnt`	也是一个用于挂载临时文件系统的目录，通常用于挂载网络文件系统或其他临时设备。
`opt`	存放第三方应用程序和软件包的目录
`proc`	包含了关于系统内核、进程、硬件等的虚拟文件
`root`	超级用户（root）的个人目录，类似于 `/home` 目录下普通用户的目录。这个目录通常只由超级用户访问。
`sbin`	存放系统管理员使用的二进制可执行文件
`usr`	存放系统用户程序、共享库、文档和其他资源，包括应用程序、开发工具、文档等内容

终端颜色含义

当我们进行ls操作时候，会看到不同的文件(夹)的颜色不同，不同颜色具有不同含义：

白色：普通文件
蓝色：目录
绿色：可执行文件
青色：链接文件
红色：压缩包
黄色：设备文件
灰色：其他文件

Linux终端常用快捷键

ctrl+b：保证不撤回字符的情况下，向左移动一个光标
ctrl+f：向右移动一个光标
ctrl+a：光标移动至行首
ctrl+e：光标移动到行尾
ctrl+d：移除光标后面第一个字符
ctrl+u：删除光标之前的所有字符（不包含光标所在字符）
ctrl+k：删除光标之后的所有字符（包含光标所在字符）
ctrl+w：删除光标所在的整个单词
ctrl+y：恢复之前一个删除的内容（撤销）
双击tab：列出所有以当前输入内容作为前缀的命令/文件(夹)全称
单击tab：补全命令/文件(夹)内容（如果你输入的命令为正确）

文件权限

通过ls la命令，我们可以看到每一行对应一个文件(夹)，但是前面第一列有一些d, r, w, x, -之类的内容，这些被称为权限。

r：可读
w：可写
x：可执行
-：无权限

我们可以看到，每个文件的前面包含总共10个字符，一般来说，第2-4位代表用户权限，第5-7位代表组权限，第8-10位代表其他权限。

通配符

*：匹配0个或者多个字符串
?：匹配1个字符
[abcd]：匹配方括号内（a, b, c, d）内任意一个字符
[a-z]：匹配a-z范围内的任意一个字符
[!abc]：不匹配方括号里的任意一个字符，与[^abc]一致

帮助命令

`man`

man是一个非常有用的命令，用于查看各种命令的手册页面（manual pages）。

man <command>           # 查看命令的手册页
man <section> <command> # 查看特定章节的手册页
man -f <command>        # 显示给定关键字的简短信息
man -k <command>        # 根据关键词搜索帮助手册
man -w <command>        # 显示手册文件所在位置

{% note green fa-circle-info %}良好的英文是必备的。{% endnote %}

`info`

info命令是另一个用于查看Linux命令和工具文档的命令，与man命令类似，但它提供了更详细和结构化的帮助信息。info命令可以提供比man更丰富的内容，包括更全面的选项和说明，并且通常具有超链接式的导航功能。

info <command> # 查看命令的详细帮助信息

`whatis`

whatis命令是一个用于显示命令简短描述的工具，它可以快速告诉你一个命令或程序的基本功能。

whatis <command> # 查看命令的简短描述

文档操作命令

`touch`

touch 命令主要用于更改文件的时间戳（修改时间和访问时间）或者创建空文件。它不会修改文件的内容，只会影响文件的时间属性。

touch <file>             # 如果文件不存在，创建空文件；如果存在，更新文件的时间戳
touch -t <time> <file>   # 设置特定时间戳
touch -a <file>          # 只更新文件的访问时间(atime)
touch -m <file>          # 只更新文件的修改时间(mtime)
touch -r <file1> <file2> # 将file2的时间戳与file1的时间戳相同

`mkdir`

mkdir命令主要用于创建新目录。

mkdir <dir>                  # 创建一个目录
mkdir -p <dir1/dir2/xxx/xxx> # 创建递归目录
mkdir -m <permission> <dir>  # 设置新目录的权限，默认775
mkdir -v <dir>               # 创建目录的时候显示详细信息

`rm`

rm命令是用于删除文件或目录的命令。

{% note red fa-triangle-exclamation %}一般来说删除的文件和目录是不可恢复的，因此在使用 rm 命令时需要小心。{% endnote %}

rm <file>    # 删除一个文件
rm -r <dir>  # 删除目录以及里面的所有内容
rm -rf <dir> # 递归并强制删除目录
rm -i <dir>  # 删除时提示确认

`rmdir`

rmdir 命令用于删除空目录。它与 rm 命令类似，但只适用于删除空目录，而不能删除包含文件或子目录的目录。使用 rmdir 删除目录时，如果目录中包含任何内容，命令会失败并显示错误信息。

rmdir <dir> # 删除空目录
rmdir -p <dir1/dir2/dir3> # 删除目录及其所有空父目录

`mv`

mv命令是用于移动文件或目录的命令，它也可以用来重命名文件或目录。

mv <file|dir1> <dir2>    # 移动文件或目录到目录
mv <oldfname> <newfname> # 重命名文件或目录
mv -f <file> <dir>       # 强制覆盖文件
mv -i <file> <dir>       # 在覆盖文件时提示确认
mv -v <file> <dir>       # 显示详细信息

`cp`

cp是用于将文件或目录从一个位置复制到另一个位置。

cp <file> <dir>     # 复制文件
cp -r <dir1> <dir2> # 递归复制目录
cp -i <file> <dir>  # 提示覆盖文件

`cd`

cd 是Linux中用于切换当前工作目录的命令，是文件系统操作中最常用的命令之一。

cd <dir>  # 切换到目标目录（可以是绝对路径或相对路径）
cd        # 切换到主目录
cd /      # 切换到根目录
cd ..     # 切换到上一级目录
cd .      # 在当前目录，不会移动
cd -      # 返回上一次所在的目录

`pwd`

pwd 用于打印当前工作目录，显示的是目前所在的绝对路径。

pwd       # 显示当前目录的绝对路径
pwd -P    # 显示物理路径
pwd -L    # 显示逻辑路径

`ls`

ls 用于列出目录内容，显示当前目录或者指定目录下的文件和文件夹名称，并通过选项显示更多信息（如权限、大小、修改时间等）。

ls <option> <dir>

option: 控制显示方式
- -a: 显示所有文件
- -l: 以长列表格式显示
- -lh: 以人类可读的方式显示文件大小，例如KB、MB
- -la: 同时显示隐藏文件与长列表格式
- -R: 递推显示子目录内容
- -t: 按修改时间排序
- -S: 按文件大小排序
- -r: 反向排序
dir: 查看的目录，默认为当前目录

`tree`

tree 用于以树状结构显示目录内容。它可以清晰地展示文件夹之间的层级关系，非常适合查看项目结构、配置文档或代码目录。

tree <option> <dir>

-a: 显示所有文件
-d: 只显示目录，不显示文件
-L n: 限制显示层级为n层
-f: 显示每个文件的完整路径
--dirsfirst: 让目录优先显示在文件之前
-I pattern: 忽略匹配的文件或目录

输出的结果如下：

project/
├── data
│   ├── input.csv
│   └── output.csv
├── src
│   ├── main.py
│   └── utils.py
└── README.md

`stat`

stat 用于显示文件或文件系统的详细状态信息。

stat example.txt

输出：

  File: example.txt
  Size: 2048       Blocks: 8          IO Block: 4096   regular file
Device: 802h/2050d Inode: 1234567     Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 501/ ryan)   Gid: (  20/   staff)
Access: 2025-10-24 21:52:30.000000000 +0800
Modify: 2025-10-24 21:45:18.000000000 +0800
Change: 2025-10-24 21:45:19.000000000 +0800
 Birth: 2025-10-22 09:12:00.000000000 +0800

Access: 最后一次读取文件的时间
Modify: 最后一次修改文件的时间
Change: 文件元数据（权限、所有者等）最后一次被更改的时间

`rename`

rename 是 Linux 中用于批量重命名文件的命令，特别适合一次性修改多个文件名（比如批量替换、添加前缀/后缀、大小写转换等）。

rename 's/原模式/新模式/' <file_list>
rename 's/\.txt$/.md/' *.txt  # 把所有.txt文件改为.md
rename 's/^/new_/' *          # 把所有文件名前面加上前缀new_
rename 's/ /_/g' *            # 所有文件名中的空格改为下划线_
rename 'y/A-Z/a-z/' *         # 把所有大写字母改为小写
rename 's/^test_//' test_*    # 去掉所有文件名的前缀test_

`file`

file 用于判断文件类型。它不会依赖文件拓展名（比如.txt, .jpg）而是通过读取文件头magic number来识别文件的真实类型。

file <option> <filename>

`md5sum`

md5sum计算文件的MD5校验值，用于验证文件完整性。

md5sum file.txt
# 输出类似：
# d41d8cd98f00b204e9800998ecf8427e  file.txt

`find`

find递归查找文件或目录，可以按名称、大小、修改时间等条件搜索。

find <path> [option] <expression>
find /home -name "*.txt"  # 在 /home 下查找所有 .txt 文件
find . -type f -size +10M # 查找当前目录下大于 10MB 的文件
find /var/log -mtime -3   # 查找 3 天内修改过的日志文件

-name <pattern>：按文件名匹配
-type <f|d>：搜索文件(f)或目录(d)
-size +10M：搜索大于 10MB 的文件
-mtime -3：搜索 3 天内修改的文件

`which`

which显示命令的可执行文件路径。

which python3
# 输出：/usr/bin/python3

`whereis`

whereis查找命令的二进制文件、源代码和手册页位置。

whereis ls
# 输出：ls: /bin/ls /usr/share/man/man1/ls.1.gz

`chown`

chown修改文件或目录的所有者与所属组。

sudo chown user:group file.txt      # 将 file.txt 所有者改为 user，组改为 group
sudo chown -R admin:staff /var/www  # 递归修改 /var/www 目录及其子文件权限

`chmod`

chmod修改文件或目录的读、写、执行权限。

chmod [OPTION] <mode> <filename>
chmod 755 run.sh    # 所有者可读写执行，其他人可读执行
chmod u+x script.sh # 给文件拥有者添加执行权限
chmod -R 644 *.txt  # 递归设置所有 txt 文件为只读

r（读）= 4
w（写）= 2
x（执行）= 1

`grep`

grep在文件中搜索匹配字符串。

grep [OPTION] <pattern> <file>
grep "error" log.txt                 # 查找 log.txt 中包含 “error” 的行
grep -i "warning" log.txt            # 忽略大小写搜索 “warning”
grep -rn "main()" ./src              # 递归搜索源码目录中包含 main() 的文件

常用选项：

-i：忽略大小写
-n：显示行号
-r：递归搜索目录
-v：显示不匹配的行

`cat`

cat查看文件内容或合并多个文件。

cat [OPTION] <filename>
cat file.txt                         # 显示 file.txt 内容
cat -n code.c                        # 显示带行号的 code.c 文件
cat part1.txt part2.txt > all.txt    # 合并两个文件为 all.txt

-n：显示行号

`head`

head显示文件开头的若干行。

head [OPTION] <filename>
head -n 10 data.csv                  # 显示 data.csv 前 10 行
head -n 1 users.txt                  # 显示文件首行

`tail`

tail显示文件末尾的若干行，常用于查看日志。

tail [OPTION] <filename>
tail -n 20 access.log                # 查看 access.log 最后 20 行
tail -f /var/log/syslog              # 实时跟踪系统日志输出

:::note[Reference]

JDK21新特性

Sat, 18 Oct 2025 00:00:00 GMT

JDK21是LTS（长期支持版），共有15个新特性：

8个正式特性
6个预览版特性
1个处于孵化阶段特性

我们在这里介绍这些正式特性。

JEP 431 有序集合

JDK21在集合框架中新增了SequencedCollection, SequencedSet, SequencedMap接口。

SequencedCollection定义的方法如下。它主要定义了在两端添加、删除、获取元素，以及reverse()方法。同理，SequencedMap也定义了类似方法。

public interface SequencedCollection<E> extends Collection<E> {
    // 新引入的方法
    SequencedCollection<E> reversed();
    
    void addFirst(E);
    void addLast(E);
    E getFirst();
    E getLast();
    E removeFirst();
    E removeLast();
}

JEP 439 分代ZGC

ZGC 拥有极致的性能，有几个重要特性

并发收集，并且使用了染色指针、读屏障等技术
低延迟，承诺停顿时间小于 1ms (刚开始引入时是 10ms)
基于 Region，支持的堆内存范围是 16MB ~ 16TB
与 G1 相比，ZGC 对应用程序吞吐量的影响小于 15%

在 Java 21 之前，ZGC 是不分代的，不区分新生代和老年代，都使用同一套回收算法。虽然整体性能很出色，但是仍然有性能优化的空间，因为新生代的对象存活时间较短，具有更高的回收价值。

Java 21 对此做了性能优化，实现了 ZGC 的分代收集，更频繁地对新生代进行垃圾收集。在 ZGC 的基础上，分代 ZGC 有以下新特性。

引入了写屏障技术
分配停顿风险更小
堆内存开销更小
GC CPU 开销更小

目前，分代 ZGC 是更好的解决方案，适用于绝大多数场景。在后续的版本中，非分代 ZGC 会逐渐废弃，以减少维护成本。

在JVM参数中配置如下参数即可开启分代ZGC

-Xmx100m
-Xlog:gc:file=/Users/jason315/Desktop/gc/zgc-gen.log
-Xlog:gc*:file=/Users/jason315/Desktop/gc/zgc-gen-detail.log
-XX:+UseZGC
-XX:+ZGenerational

JEP 440 Record模式

Records表示一种特殊的类，极大地简化了不可变类的定义。Record 模式增强了 Java 编程语言以便于解构 Record 对象的值，这可以嵌套 Record 模式和 Type 模式，实现强大的、声明式的和可组合的数据处理形式.

record Point(int x, int y) {}

// Java 21 写法
static void printSumInJava21(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println(x+y);
    }
}

public static void main(String[] args) {
    Point point = new Point(3, 6);
    printSumInJava21(point);
}

JEP 441 switch模式匹配

switch 表达式支持更多的类型，并且支持模式匹配，自动解构赋值。

static String formatterPatternSwitch(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> obj.toString();
    };
}

JEP 444 虚拟线程

虚拟线程是 Java 21 最受关注的正式特性。虚拟线程，也就是轻量级线程。虚拟线程极大地降低了高吞吐量应用的开发和维护成本。

平台线程（原有线程）是在 OS 线程上做的封装，它的创建和切换成本很高，可用的线程数量也有限制。对于并发较高的应用，想要提高系统的吞吐量，之前一般是做异步化，但这种方式很难定位线上问题。

虚拟线程的资源分配和调度由 Java 平台实现，它不再直接与 OS 线程强关联，而是直接将平台线程作为载体线程，这使得虚拟线程的可用数量大大增加。

应用场景

虚拟线程在如下两种场景下，才能大幅提高应用系统的吞吐量

并发任务量很大（万级）
线程工作量不会使 CPU 受限（不是 CPU 密集型任务）

虚拟线程创建方式

class Task implements Runnable{
    @Override
    public void run() {
        Thread currentThread = Thread.currentThread();
        long threadId = currentThread.threadId();
        System.out.printf("[%d]Task start to run...\n", threadId);
        int sum = IntStream.range(0, 100).sum();
        System.out.printf("[%d]sum=%d, 线程名称: '%s', 是否虚拟线程: %s\n", threadId, sum, currentThread.getName(), currentThread.isVirtual());
        System.out.printf("[%d]Task end.\n", threadId);
    }
}

// 方式一：直接启动，虚拟线程名称为空
private void way1() {
    Thread.startVirtualThread(new Task());
}

// 方式二：Builder 模式构建
private void way2() {
    Thread vt = Thread.ofVirtual()
        .name("VirtualWorker-", 1)
        .unstarted(new Task());
    vt.start();
}

// 方式三：Factory 模式构建
private void way3() {
    ThreadFactory factory = Thread.ofVirtual()
        .name("VirtualFactoryWorker-", 1)
        .factory();
    Thread vt = factory.newThread(new Task());
    vt.start();
}

// 方式四：newVirtualThreadPerTaskExecutor
private void way4() {
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        executor.submit(new Task());
    }
}

// 方式五：构建"虚拟线程池"
private void way5() {
    ThreadFactory factory = Thread.ofVirtual()
        .name("VirtualFactoryWorker-", 1)
        .factory();
    ExecutorService executorService = Executors.newThreadPerTaskExecutor(factory);
    executorService.submit(new Task());
}

JEP 449 废弃32位x86架构Windows移植

Java 21宣布废弃对32位x86架构Windows的移植。

JEP 451 准备禁用代理的动态加载

当代理在运行中的 JVM 中动态加载时，会发出警告。这些警告的目的是让用户为将来的版本做好准备，将来的版本默认不允许动态加载代理，以提高 Java 安全性。

在任何版本中，Java 自带的工具在启动时加载代理不会发出警告。

JEP 452 密钥封装机制API

KEM（Key Encapsulation Mechanism，密钥封装机制）是一种加密技术，它允许两个通信方安全地共享一个秘密密钥，而无需通过不安全的通道直接传输密钥。KEM 通常与对称加密算法结合使用，以实现高效的数据加密和安全通信。

加密时，传统方法是使用公钥随机生成一个对称密钥，但这需要填充，也难以保证安全性。而密钥封装机制（KEM）则利用公钥的属性派生出一个相关的对称密钥，这种方法不需要填充。

Java 平台传统的加密方式无法抵御量子攻击，而 KEM API 则可以有效弥补这个短板。

KEM API

KEM API 相关的接口和类都位于javax.crypto包下。

Java 21 新增了KEMSpi（KEM Service Provider Interface），其中包括EncapsulatorSpi和DecapsulatorSpi。Java 提供的默认实现是 DHKEM，即 Diffie-Hellman KEM。

public interface KEMSpi {
    EncapsulatorSpi engineNewEncapsulator(PublicKey var1, AlgorithmParameterSpec var2, SecureRandom var3) throws InvalidAlgorithmParameterException, InvalidKeyException;

    DecapsulatorSpi engineNewDecapsulator(PrivateKey var1, AlgorithmParameterSpec var2) throws InvalidAlgorithmParameterException, InvalidKeyException;

    public interface DecapsulatorSpi {
        SecretKey engineDecapsulate(byte[] var1, int var2, int var3, String var4) throws DecapsulateException;
        int engineSecretSize();
        int engineEncapsulationSize();
    }

    public interface EncapsulatorSpi {
        KEM.Encapsulated engineEncapsulate(int var1, int var2, String var3);
        int engineSecretSize();
        int engineEncapsulationSize();
    }
}

:::note[Reference]

SpringBoot的定时任务实现方式

Sat, 11 Oct 2025 00:00:00 GMT

在现代软件开发中，定时任务是一种常见的需求，用于执行周期性的任务或在特定的时间点执行任务。这些任务可能涉及数据同步、数据备份、报表生成、缓存刷新等方面，对系统的稳定性和可靠性有着重要的影响。SpringBoot提供了强大且简单的定时任务功能，使开发人员能够轻松地管理和执行这些任务。

本文讲述SpringBoot中定时任务的基本用法、高级特性以及最佳实践，帮助开发人员更好地理解和应用定时任务，提高系统的稳定性和可靠性。

@Scheduled注解

@Scheduled注解是Spring提供的一个注解，用于标记方法作为定时任务执行。@Scheduled注解在源码中包含一些重要属性：

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Repeatable(Schedules.class)  
public @interface Scheduled {
    String cron() default "";
	long fixedDelay() default -1;
	long fixedRate() default -1;
	long initialDelay() default -1;
}

cron: 标准的Unix Cron表达式，用于定义复杂的计划执行时间
fixedRate: 以固定的频率执行任务，指定两次执行之间的间隔时间（单位是毫秒）
fixedDelay: 在每次任务完成后等待一定的时间再进行下一次执行，指定连续执行之间的延迟时间
initialDelay: 首次执行前的延迟时间

用例如下：

/**
 * cron属性可以设置指定时间执行  
 */  
@Scheduled(cron = "0 45 14 ? * *")  
public void fixTimeExecution() {  
	System.out.println("指定时间 "+dateFormat.format(new Date())+"执行");  
}

SchedulingConfigurer基于接口

首先在项目中导入依赖包

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.0.4.RELEASE</version>
</parent>
 
<dependencies>
    <dependency><!--添加Web依赖 -->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency><!--添加MySql依赖 -->
         <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency><!--添加Mybatis依赖 配置mybatis的一些初始化的东西-->
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency><!-- 添加mybatis依赖 -->
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

开启本地数据库mysql，打开一个查询窗口，执行脚本内容，例子如下：

DROP DATABASE IF EXISTS `socks`;
CREATE DATABASE `socks`;
USE `SOCKS`;
DROP TABLE IF EXISTS `cron`;
CREATE TABLE `cron`  (
  `cron_id` varchar(30) NOT NULL PRIMARY KEY,
  `cron` varchar(30) NOT NULL  
);
INSERT INTO `cron` VALUES ('1', '0/5 * * * * ?');

最后在项目中的application.yml添加数据源

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/socks
    username: root
    password: 123456

在数据库里准备好数据后，开始编写一个定时任务：

@Configuration      // 1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling   // 2.开启定时任务
public class DynamicScheduleTask implements SchedulingConfigurer {
    @Mapper
    public interface CronMapper {
        @Select("select cron from cron limit 1")
        public String getCron();
    }
 
    @Autowired      //注入mapper
    @SuppressWarnings("all")
    CronMapper cronMapper;
 
    /**
     * 执行定时任务.
     */
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
            //1.添加任务内容(Runnable)
            () -> System.out.println("执行动态定时任务: " + LocalDateTime.now().toLocalTime()),
            //2.设置执行周期(Trigger)
            triggerContext -> {
                //2.1 从数据库获取执行周期
                String cron = cronMapper.getCron();
                //2.2 合法性校验.
                if (StringUtils.isEmpty(cron)) {
                    // Omitted Code ..
                }
                //2.3 返回执行周期(Date)
                return new CronTrigger(cron).nextExecutionTime(triggerContext);
            }
        );
    }
}

启动应用即可定时执行任务。这里的好处是指需要在数据库里对执行周期进行修改即可，而不需要重启应用。如果使用第一部分的注解的话，需要先停止应用，修改代码再重启应用才能调整周期。

多线程定时任务

可以基于注解设定多线程定时任务

@Component
@EnableScheduling   // 1.开启定时任务
@EnableAsync        // 2.开启多线程
public class MultithreadScheduleTask {
    @Async
    @Scheduled(fixedDelay = 1000)  //间隔1秒
    public void first() throws InterruptedException {
        System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
        System.out.println();
        Thread.sleep(1000 * 10);
    }
 
    @Async
    @Scheduled(fixedDelay = 2000)
    public void second() {
        System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
        System.out.println();
    }
}

两个定时任务互不影响。

:::note[Reference]

人工智能基础

Sun, 03 Aug 2025 00:00:00 GMT

机器学习

假设用p来评估计算机程序在某任务t上的性能，若一个程序通过利用经验e在t中任务上获得了性能改善，则我们就说关于t和p，该程序对e进行了学习。

机器学习的目标是，从假设空间中，即从输入空间到输出空间的模型映射空间中，寻找一个最优模型。

机器学习算法的典型分类：

有监督学习：通过训练数据学到或建立一个“函数”并依此函数推测新的实例。
无监督学习：通过无标签的训练数据推断一个“函数”用于描述数据中的隐藏结构。
强化学习：在与环境的交互过程中通过学习策略函数以达成回报函数最大化。

线性回归

线性回归是利用数理统计中回归分析，来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法。主要步骤如下：

收集数据
选择模型
定义模型评价标准
找到模型最优参数

决策树

决策树可以认为是if-then规则的集合，其主要优点是模型可解释性好，分类速度快。

K均值聚类

k均值聚类是一种迭代求解的聚类分析算法，该算法将数据分为k组，随机选取初始的聚类中心，然后计算每个对象与各种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。

深度学习

深度学习是一种主要使用深度神经网络为工具的机器学习算法。深度学习源于人工神经网络的研究。深度学习通过组合低层特征形成更加抽象的高层来表示属性类别或特征，以发现数据的分布式特征表示。

人工神经网络参照生物神经网络，模仿其结构和功能的数学模型或计算模型，来对函数进行估计或近似。

全连接神经网络

全连接神经网络（Fully Connected Neural Network）为ai领域种最早发明的简单人工神经网络类型。在内部，参数从输入层向输出层单向传播，有异于循环神经网络，它的内部不会构成有向环。

深度卷积神经网络

卷积神经网络（Convolutional Neural Network, CNN）是一种前馈神经网络，它的人工神经元可以响应一部分覆盖范围内的周围单元，对于图像处理问题有出色表现。

卷积convolution本质上是信号/图像处理领域内的互相关（cross-correlation），一般用来提取局部特征。使用cnn的好处在于：局部链接和权值共享；平移不变性。

池化pooling思想来自于视觉机制，是对信息进行抽象的过程，用来增大感受野，降低模型的参数量。

循环神经网络

循环神经网络（Recurrent Neural Network, RNN）是一类以序列数据为输入，在序列的演进方向进行递归且所有节点按链式连接的神经网络。

循环神经网络具有记忆性，因此在对序列的非线性特征进行学习时具有一定优势。rnn在语音识别、语言建模、机器翻译等领域有应用，也被用于各类时间序列预报。随着跨度的增加，rnn变得难以对信息之间的关联进行有效学习。

长短期记忆网络（Long Short-Term Memory, LSTM）是为了解决一般的rnn存在的长期依赖问题而设计的。

lstm中常规的神经元被储存单元替代，适合于处理和预测时间序列中间隔和延迟非常长的事件。
遗忘门forget gate决定了前一时刻中memory中的是否会被记住。
输入门input gate决定当前的输入有多少被保留下来。
输出门output gate决定当前memory的信息有多少会被立即输出。

开发者测试入门

Wed, 23 Jul 2025 00:00:00 GMT

单元测试介绍

单元测试（Unit Test, UT）/模块测试，是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。在过程化编程中，一个单元就是单个程序、函数、过程等；对于面向对象编程，最小单元就是方法，包括基类（超类）、抽象类、或者派生类（子类）中的方法。

单元测试可以看作是编码工作的一部分，是由程序员自己来完成，最终受益者是程序员自己。程序员有责任编写功能代码，同时也有责任为自己的代码编写单元测试。执行单元测试，就是为了证明这段代码的行为和我们期望的一致。

单元测试能帮助开发人员更高效的发现问题，保证代码健壮，打算能源测试在集成测试之前做，并且每次修改代码后也需要跑单元测试，保证修改代码对其他逻辑无影响。

单元测试的重要性：

高效、低成本
保证质量
促进代码优化

单元测试原则-FIRST原则

fast快速：测试的运行速度将直接决定自动化的反馈速度，速度越快，越能提早发现问题；省去不必要浪费的时间，提高工作效率。
isolated独立：每一个测试用例需要保证完全独立运行，互不依赖，这样才能保证测试运行不被干扰，从而能够并行运行甚至分布式运行，使得测试运行更加fast。
repeatable可重复：每一个测试用例在运行条件不变的情况下，无论重复运行多少次，运行结果必须完全一致。
self-validating自验证：测试用例必须能够自动告知（断言）运行结果，而不依赖人工判断结果正确还是错误。
timely及时：编写自动化测试是一种好的习惯，为了保证能够及时得到反馈，必须及时编写自动化测试而不拖延，一旦拖延，就很难补回来。

软件测试基础

什么是测试

测试是通过实验方法，获得产品知识，以进行产品评估的过程。实验方法包括一定程度的：提问、学习、建模、观察和推论。

测试是一个包含计划、准备、和测量活动的过程。其目的时确认被测系统的特性，并指出需求和实现之间的差异。

测试的目标是减少风险差距。差距越大，测试越困难。

软件测试的目标（ISTQB）：

预防缺陷
发现缺陷
为决策者提供信息
消减风险
评估产品质量
验证需求实现
确认达成客户期望
建立质量信心

软件测试的目标（ISO29119）：

提供风险信息
提供质量信息
评估缺陷修复
评估实现变更
评估需求实现
评估客户期望

华为测试的目标：

需求验证：发现缺陷、评估缺陷修复、评估实现变更、验证需求实现
评估质量：消减风险、确认达成客户期望、评估产品质量
提升质量：预防缺陷、建立质量信心
提供信心：为决策者提供信息

测试原则

ISTQB（国际测试资质认证委员会）提出，所有测试的指导仿真，测试的7条基本原则：

测试可以显示缺陷defect的存在，但不能证明系统不存在缺陷
穷尽测试是不可能的
测试尽早介入
缺陷具有集群性
杀虫剂悖论
测试活动依赖于测试背景，测试背景决定测试活动
"Absence of errors"谬误，系统发布取决于是否满足客户需求，而不是是否还有缺陷

测试模型

测试的基本模型为T-IBO。

测试的依据包括业务需求、合同标准、法律标准和行业标准。

在计算、软件工程和软件测试中，test oracle是一种决定一项测试是否通过的判断机制。test oracle的使用会要求将被测试系统的实际输出与我们所期望的输出进行比较，从而判断是否有差异。如果有差异，可能就存在缺陷。

测试不仅仅局限于软件程序的测试，测试活动贯穿于软件开发过程的整个周期中。因此，需求分析、概要设计、详细设计以及编码各阶段所得到的交付件，包括设计文档、源代码、应用程序乃至随软件版本发布的资料、license、证书，都是测试的对象。

测试是研发团队所有人的职责，不只是测试人员的事。

测试越早开始，代价越低越好。在开发过程中越晚修正缺陷，代价就会越高。

何时停止测试，需要从多个维度进行综合评估：

当达到了必要的信心级别，风险可以接受的时候
当发现缺陷的代价高于缺陷发生引起的代价时
当达到测试完成标准（退出/成功标准）时

测试可以发生在产品生命周期的各个环节/活动的环境上：

在需求分析、系统设计评审/交流的时候
在开发人员本地的仿真环境
在分支/主干持续集成环境
在研发测试实验室
在用户beta环境
在正式的生产环境

测试的基本过程为：

计划：识别测试的任务；定义测试的目标；为实现测试目标和任务定义规格说明。
控制：通过对测试进展和测试计划之间的比较，报告测试的状态，包括与计划之间存在的误差，包括在必要的时候采取必要的措施来满足测试的任务和目标。
分析和设计：分析测试目标和形成测试设计；将测试条件转化为测试用例、测试件；测试环境的搭建。
执行和评估：将测试的执行结果和已经定义的测试目标进行比较，在各个测试级别上都需要进行评估。
结束：从完成的测试活动中收集资料，巩固测试经验、测试件、影响测试的因素和其他数据。

测试术语

bug：是指组件或系统中的缺陷，可能导致组件或系统无法执行其所需功能，而造成功能不正常、司机、数据丢失、非正常中断等现象。

error错误：人为错误，不仅指代码逻辑错误，包括产品生命周期中任何人可能的错误。

fault内部缺陷/故障：期望结果与实际结果的差异。

failure外部失效：是缺陷导致的后果，通常系统不能完成最初的功能、性能等。

verification验证：评估产品、服务或系统是否正确实现既定的需求、规格。

validation确认：保证产品、服务或系统满足客户和其他利益相关者的需求。

软件质量：反应实体满足明确和隐含的需求的能力的特征的总和。软件质量是产品、组织和体系或过程的一组固有特性，反映它们满足顾客和其他相关方面要求的程度。

人们通常把影响软件质量的特性称为软件质量属性，用质量模型来描述，并定义为分层模型，最基本的叫做基本质量特性，它可以由一些子质量特性定义和度量。

ISO25010产品质量属性：

功能适应性：完整性、正确性、适合性
性能效率：时间行为、资源利用、容量/规格
兼容性：共存、互操作
易用性：可识别性、易学性、易操作性、误操作保护、ui美观度、可接入性
可靠性：成熟度、可使用性、容错性、可恢复性
安全：保密性、完整性、不可抵赖性、可追溯性、真实性
可维护性：模块化、重用度、可分析性、可修改性、可测试性
可移植性：适应性、可安装性、可替换性

测试分类

围绕测试的目标，人们开发了多种的测试活动与技术：

按是否运行程序划分
- 静态测试
- 动态测试
按阶段划分
- 单元测试
- 集成测试
- 系统测试
- 验收测试
按测试用例的测试设计方法划分
- 白盒测试
- 黑盒测试
按测试针对的质量目标划分
- 功能测试
- 适用性测试
- 性能测试
- 安全测试
- 可靠性测试

测试流程

阶段测试活动：

开发者测试：UT->IT/MST->BBIT
系统集成与验证：SDV->SIT->SVT
客户化测试：比拼测试->准入测试->客户验收测试

关键测试交付：

测试策略
测试分析：测试需求
测试设计：测试方案、测试用例
测试实现：测试用例、测试脚本、测试工具
测试执行：用例手工执行、用例自动化执行
测试评估：测试评估、测试报告、产品缺陷

测试设计技术

黑盒测试

等价类EP（Equivalence Partitioning）

等价类划分法是一种最基础的黑盒测试用例设计方法。它不考虑程序内部结构，唯一依据是软件需求规格说明书。等价类是输入条件的一个子集，该子集种的数据对于揭示程序种的错误是等价的。从每一个子集种选取具有代表性的数据生成测试用例。

有效等价类：指对于系统的规格来说是合理的，有效输入数据构成的集合。

无效等价类：指对于系统的规格来说是不合理或无意义的输入（即不正确的输入值）。

简单等价类划分的一般规则如下：

输入条件是布尔量
按照数值集合划分
按照区间划分
按照数值划分

边界值BVA（Boundary Value Analysis）

边界值分析是一种常用的软件测试技术，旨在通过对输入参数边界值的测试，来发现程序边界条件下可能存在的错误。

黑盒测试仅仅关注程序的输入，不考虑软件内部实现细节。

数据组合Combinatorial Test

数据组合将被测系统输入参数的取值进行组合，来生成测试用例。它可以覆盖任意n个因素所有取值组合，理论上可以发现由n个因素共同作用引发的缺陷。

数据组合测试设计技术针对系统的需求进行分析，识别出测试因子及其可能取值，采用数据组合覆盖技术生成测试数据组合，最后生成测试用例。

EC（Each Choice）组合：所有参数（因子）的可能取值至少被一个测试用例覆盖。

BC（Base Choice）组合：以测试因子的基本组合为基础，每次修改一个因子的取值，直到该因子的所有取值被覆盖。

N-wise组合：从多个测试因子中取n个因子进行组合，不考虑组合的顺序，当n=2时是pairwise组合，n为测试因子个数时为全组合。

Pairwise组合：只考虑两个因子之间的组合，可以有效地发现因子的交互作用。
全组合：考虑所有因子之间的所有组合，测试覆盖率最高，但测试用例数量也最多。
n-wise组合：介于pairwise和全组合之间，可以通过调整n值来平衡测试覆盖率和测试用例数量。

数据组合优化策略：

无效值：针对选择因子中的无效值，一般不进行组合。
约束条件：明确定义约束关系，并利用组合测试用具生成有效的测试用例集。
复合组合策略：为了降低测试用例数量，提高测试效率。

判定表DTT

判定表是一种充分考虑被测系统输入因子组合、约束，以及输入和输出之间因果关系的测试用例设计方法，特别适用于输入条件与输出结果之间存在明确因果关系的系统。

判定表可以与因果图结合，分析所有输入组合和它们对应的输出。对于简单的系统也可以直接适用判定表进行设计。分析步骤如下：

分析需求
定义条件与动作
列出条件项
生成判定表
简化判定表

判定点DPT

判定点逻辑覆盖通过对系统内部逻辑结构的深入分析，确保每个判定点及其所有可能条件都被测试覆盖。它与其他黑盒测试方法相比，更关注实现细节和业务逻辑，是一种偏白盒的测试分析方法。

判定decision：在程序执行过程中，根据条件判断结果选择不同的执行路径的分支点。
条件condition：判定点中包含一个或多个逻辑表达式，这些表达式通过逻辑运算（与、或、非）组合而成，最终结果为真或假。
逻辑覆盖：通过设计测试用例，使得流程中的每个判定点的所有可能结果都被执行到，以及每个条件的所有可能取值都被覆盖到。

处理周期PCT

路径覆盖：软件系统功能的业务逻辑可以适用流程图进行描述，系统的业务逻辑流程图往往包含一条或多条业务路径，路径覆盖的对象就是这些路径的组合。

处理周期测试设计技术：是一种针对系统业务进行测试的方法，它利用系统的业务逻辑流程图，并结合路径组合技术来生成测试用例。步骤如下：

针对被测对象分析，采用结构化的流程图描述其系统功能流程。
适用路径覆盖技术识别测试条件（即路径组合）。
创建测试用例。

状态转换测试STT

N-switch覆盖是指对被状态图中的所有n+1次连续状态转换的序列的覆盖。通过对进行被测系统分析，得到系统业务逻辑的状态迁移图，n-switch覆盖的对象就是状态迁移图中的状态转换序列。

白盒测试

白盒测试是根据被测对象的结构设计测试用例的一种方法。这里的结构包括：

代码的结构（控制流图）
数据的结构
模块间相互调用的结构
业务流程的结构

语句覆盖：要求每条可执行语句至少执行一次。

判定覆盖：也叫分支覆盖，每个判断的真值和假值至少执行一次。

条件覆盖：要求程序中的每个条件的真值和假值至少执行一次。

判定-条件覆盖：要求每个判定的真值和假值至少执行一次，并且每个条件的真值和假值也至少执行一次。

条件组合覆盖：也叫多重条件覆盖，每个判定的条件取值组合至少执行一次。

MC/DC（Modified Condition/Decision Coverage）修正条件/判定覆盖，是一种严格的逻辑覆盖准则。它要求：

每个条件在判定中至少被赋值为真和假一次
每个判定的每个结果至少被触发一次
每个条件必须能够独立影响判定的输出

路径覆盖：覆盖程序中所有可能的路径。路径是指程序从入口到所有出口的执行路径。

Java语言编程规范

Thu, 10 Jul 2025 00:00:00 GMT

规范刷新流程：提交评论/mr -> 规范组讨论 -> 达成一致 -> 修改/合入mr -> 发布评审 -> 发布正式版本

代码风格

命名

类别	命名风格
接口、类、注解、枚举类型	大驼峰，测试类加Test后缀，文件名为`顶层类名.java`
类的属性、局部变量、方法、方法参数	小驼峰，测试方法可以有下划线
静态常量、枚举值	全大写，下划线分割`_`
泛型类型变量	单个大写字母，可借一个数字或者接下划线加若干个大写字母
异常	加后缀Exception或Error

规范中的常量是指不可被修改的field和枚举常量。“不可被修改”需要同时满足以下两个条件：

field的值/对象不可被修改为其他的值/对象
field为对象类型时，对象在初始化完成后其属性不能被修改

常量定义的一般格式为[访问修饰符] static final 类型常量名 = 常量值;

常量有一些注意事项：

常量的命名要尽量表达完整的语义。
避免使用魔鬼数字（难以理解的数字或字符串），要使用有意义的常量来代替。
不建议使用常量类集中管理所有的常量，推荐按功能进行管理，就近定义常量。
mutable对象禁止定义为常量。

注释

注释使用的总体原则是：按需注释。

要从读者的角度触发，按需注释。
注释要简洁、明了、无歧义，信息全面但不冗余。
不要添加无效、重复的注释。
注释要与代码同步修改。

JavaDoc中有几个要求：

要对public、protected修饰的元素添加JavaDoc修饰。
顶层public类的JavaDoc应该包含功能说明和创建日期/版本信息。
方法的JavaDoc中应该包含功能说明，根据时机需要按顺序使用@param, @return, @throws标签对参数、返回值、异常进行注释。
不要添加空有格式的方法头注释。
涉及线程安全时，要进行相关的说明。

代码注释的时候，

非首行代码的注释应该与前面的代码之间加一空行。
代码右侧的注释，代码、注释符、注释之间至少留一个空格。
正式交付的代码不应包含TODO/FIXME注释。

格式

在编码规范的指导下，审慎地编排代码以使代码尽可能清晰、风格统一。

源文件排版

Java源文件一般按顺序包含版权、package、import、顶层类，其用空行分隔。
import包应该按照先安卓、其他商业组织、其他开源第三方、net/org开源组织、最后java的分类顺序出现，并用一个空行分组。
一个类的声明部分应该按照类变量、静态初始化块、实例变量、实例初始化块、构造方法、方法的顺序排列，且用空行分隔。

大括号：推荐使用K&R风格

条件语句和循环块中要使用大括号。
左大括号不换行。
右大括号自己单独一行。
右大括号后，可以跟逗号、分号等，也可以跟随else、catch、finally等关键字语句。
对于空块，除了K&R风格外，也可以在大括号打开后立即关闭，但是要保持空块风格一致。

行宽和可读性

代码行宽上限不取决于屏幕宽度，而是人眼跟踪范围。每行建议不要超过120个窄字符。

换行：换行时建议操作符、连接符放在新的一行

当在非赋值运算符处断行时，中断点出现在符号之前。这也适用以下“类似运算符”的符号：
- 点分隔符.
- 方法引用的两个冒号::
- 类型限定中的&符号<T extends Foo & Bar>
- catch块中的管道catch (FooException | BarException e)
方法或构造方法名称与紧跟在其后面的左括号保持在同一行。
逗号断点出现在逗号之后。
在lambda表达式中，如果箭头后面时单个表达式，可以在箭头后面出现断点，如果箭头后是程序块，可以在大括号后出现断点。

水平空格

代码中的水平空格只能使用单个空格或多个空格的组合：

缩进时使用4个空格，不要使用制表符（tab）；代码块的缩进级别应该与上下文代码相同。
使用空格突出关键字和重要信息。单个空格应该分隔关键字与其后的左括号、与其前面的大括号，出现在任何二元/三元运算符/类似运算符的两侧，, : ;或类型转换结束括号)之后使用空格。
行尾和空行不应有空格。
不建议使用空格使代码垂直对齐。

字面量

数字字面量应该设置合理的后缀来指定数值的类型：

float类型的字面量，可以使用F, f作为后缀。
double类型的字面量，可以使用D, d作为后缀。
long类型的字面量，只能使用L作为后缀，防止l与数字1混淆。

对于较大数值，可以考虑使用数字下划线分隔符来增加代码的可读性，例如30_000_000_000L。

Java实战应用

Mon, 28 Apr 2025 00:00:00 GMT

变量应用进阶

变量类型汇总

Java是一种强类型语言，通过变量的类型限制了变量可以持有值（以及表达式可以产生的值），限制在各类值上支持的操作，并确定操作的含义。Java也是一种静态语言，在编译时检测数据类型是否匹配，便于开发者及时发现编码错误。

基本数据类型：byte, short, int, long, float, double, char, boolean
引用数据类型：类、接口、数组、枚举、注解

所有变量在使用前必须声明和初始化。

// 基本格式
type identifier [= value][, identifier [= value]...];

类变量、实例变量支持默认初始化，局部变量必须显示初始化。

Java基本类型的长度固定，与操作系统位宽无关。
long、float、double类型可以在数值后添加L、f、d表示数字代表的类型。
默认值时类变量、实例变量，以及数组元素的默认初始化的赋值，而其他变量（如临时变量）必须显示初始化。
由于程序中存储数值是存在边界的，如果计算过程中导致超过这个边界，则会得到期望之外的结果。

数据类型转换

Java中进行赋值时，要求等号左边和右边的类型要一致，如果不一致，就需要进行数值类型转换：

自动类型转换：容量小的类型自动转换为容量大的类型
强制类型转换：大转小
隐含强制类型转换（初始化）：在类型初始化时，int会隐含强制转换成低级别的byte和short类型
其他类型转换：包装类、字符串、基本类型直接的转换

无论自动和强制类型转换，都要遵循如下基本原则：

不能对boolean类型进行类型转换
不能把对象类型转换成不相关的类对象
大转小必须使用强制类型转换
类型转换过程中，可能会导致溢出和损失精度
浮点数到整数的转换是舍弃小数，而不是四舍五入

引用类型和拆装箱

基本数据类型部分场景下不能使用，为了扩展8种基本数据类型相关的常用功能，JDK为每个基本数据类型涉及了一个对应类，叫做包装类。包装类的主要用途由2种：

作为基本数据类型对应的类型在，方便有关对象的操作。
可以用设定每种基本数据类型的属性大小和使用方法。

装箱：基本类型->包装类，拆箱：包装类->基本类型。拆装箱影响性能，应尽量避免反复拆装箱。

表达式

基本运算符存在的风险

对于int multi(int n1, int n2) { return n1 * n2; }中，当n1和n2的绝对值较大，两者的乘积越界溢出时，方法就无法正确的计算结果。当无法预判乘积结果是否会溢出时，可以使用Java 8新增的Math.multiplyExact()方法，该方法在乘积运算不产生溢出时会返回运算结果，溢出时抛出ArithmeticException。

由于计算机中的精确缺失，浮点符不能直接使用==或!=判断是否相等，而应该基于两者之差与极小值比较大小的方式判断是否相等。

逻辑运算符存在“短路”场景，即如果基于操作符和第一个操作数和就可以得到结果，则不会再执行第二个操作数的计算。

运算符注意优先级：https://blog.csdn.net/sunshihua12829/article/details/47912123

Lambda表达式

Lambda表达式可以替换匿名类，简化代码。Java Lambda表达式中可以使用局部变量，但是不可修改，相当于局部变量为final类型，遵循“无副作用”。

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。Lambda表达式是延迟执行的，这正好可以作为解决方案提升性能。

如果Lambda表达式实现体只调用了一个外部已经存在的方法时，就可以使用方法引用简化调用。

类型	语法	Lambda表达式
静态方法引用	类名::staticMethod	`(args)->类名.staticMethod(args)`
实例方法引用	inst::instMethod	`(args)->inst.instMethod(args)`
对象方法引用	类名::instMethod	`(inst, args)->inst.instMethod(args)`
构建方法引用	类名::new	`(args)->new 类名(args)`

面向对象

多态

对于多态，有几个注意事项：

如果子类重写了父类的方法，则执行子类的方法，否则执行父类的方法。
执行方法的优先级为（从高到低）：
1. this.method(Obj)（前提是父类有相同的定义）
2. super.method(Obj)
3. this.method((super)Obj)（前提是父类有相同的定义）
4. super.method((super)Obj)

类加载顺序

Java的类加载机制中最重要的就是程序初始化过程，其中包含了静态资源、非静态资源、父类子类、构造方法，它们存在执行顺序：最先执行带有static关键字的属性/代码块，其次是非static关键字的属性/代码块、构造方法；同时，先父类再子类；同级别的按照代码顺序（自上而下）。具体地：

父类的静态属性值、代码块
子类的静态属性值、代码块
父类的属性值、代码块
父类的构造方法
子类的属性值、代码块
子类的构造方法

权限修饰符

Java中可以使用权限修饰符控制类、类成员变量、类成员方法的访问权限：

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
(default)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

对于class的权限修饰只能用public和缺省default，其中，default类只可以被同一个包内部的类访问。

密封类

密封类sealed class，可以设置子类名称，密封类的子类只能是final class，sealed class或non-sealed class。非permits列表中的类不能被继承。

interface I {}

sealed class C implements I permits D, E, F {}

non-sealed class D extends C {}
final class E extends C {}
sealed class F extends C {}

注解

Java注解提供了一种安全的类似注释的机制，用来将任何的信息或元数据与程序元素进行关联。注解可以应用在：

生成文档
在编译时进行格式检查
跟踪代码依赖性，实现替代配置文件功能
在反射的class、method、field等函数中，有许多与Annotation相关的接口，可以在反射中解析并使用Annotation。

异常

不合理使用异常会引导大量安全问题。

如果抛出的异常对象属于catch子句中的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。
每个catch子句依次检查，一旦有子句匹配，则后面的被忽略。
finally子句必定会在其他代码结束之后执行，除非程序/线程提前退出。
finally执行时机在try/catch代码块退出前，即所有代码块后，跳出逻辑前。
finally执行语句不会影响原有返回值，除非finally中直接return。
支持自定义异常。

throw与throws的区别：

throw用于语句中抛出异常
throws用于方法签名中声明可能抛出的异常

JDK-8支持try-with-resources方式，资源相关代码直接写在try后的括号内，异常时自动关闭相关资源，极大简化代码写法。

try (read; br) {
  
} catch (Exception e) {
  
}

采用try-with-resources写法，当try中的代码执行结束之后就会调用try括号中的对象的close()方法来关闭资源，如果我们对try-with-resources语法代码进行反编译，可以看到里面依然是try-catch-finally写法。try-with-resources方式处理的资源类应实现了AutoCloseable接口的close()方法。

JDK-9引入了更加易读的try-with-resource写法，避免try后括号内代码过多，不易读。

在传递异常的时候，未对其中的敏感信息进行过滤，会导致信息泄露。

代码组织管理

包管理Package

Java提供了包机制，用于区别类名的命名空间，从而更加清晰分层地组织所有类/源码文件。包的作用：

把职责相关的类或接口组织在同一个包中，方便类的查找和使用。
包采用了树形目录的存储方式，可以避免类的名字冲突。
包限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

一般通过import引入包名后，代码中可以直接使用类名，特殊地，如果同一个文件中要使用名字冲突地类时，需要通过显示添加包名的方式指定。

模块化Module

模块化系统的主要目的如下：

更可靠的配置，通过指定明确的类依赖关系代替以前那种易错的类路径class-path加载机制。
强大的封装，允许一个组件声明它的public类型中，哪些可以被其他组件访问，哪些不可以。

反射（动态代理）

反射reflection是指在程序的运行状态中，动态获取类信息以及动态调用对象的功能。反射就像给开发者提供了一面镜子，可以反向看到某个类中的结构信息，进而调用执行。反射常用于创建动态代理或开发通用框架，提供系统的通用性、灵活性，如Spring的IOC。

public class ReflectionDemo {
  // 用反射来创建类对象
  public void create_class_object() throws xxxException {
    Class<Person> personClass = Person.class;
    Person person = personClass.getConstructor().newInstance();
    System.out.println(person.sayHi());
    
    // 其他得到personClass的方法
		Class<Person> personClass = Class.forName("com.huawei.core.reflection.bean.Person");
    Class<? extends Person> personClass = person.getClass();
    Class<?> personClass = this.getClass().getClassLoader().loadClass("com.huawei.core.reflection.bean.Person");
  }
  
  // 用反射来获取类的构造方法
  public void get_class_constructor() throws xxxException {
    Class<Person> personClass = Person.class;
    Constructor<Person> constructor = personClass.getConstructor(String.class, xxx); // 取决于构造方法的参数有什么，另外，如果构造方法不是public的话会报错
    System.out.println("constructor.getName() = " + constructor.getName());
    
    Person person = constructor.newInstance("Tony", xxx);
    System.out.println(person.sayHi());
    
    // 其他获取类构造方法的方式
    Constructor<Person> constructor = personClass.getDeclaredConstructor(String.class, LocalDate.class); 
    constructor.setAccessible(true); // getDeclaredConstructor方法可以无视类构造方法的修饰符，例如private
  }
  
  // 用反射来获取类的成员方法
  public void get_class_methods() throws xxxException {
    Class<Person> personClass = Person.class;
    Method sayHi = personClass.getMethod("sayHi(成员方法名称)");
    System.out.println("sayHi.getName() = " + sayHi.getName());
    
    Method study = personClass.getDeclaredMethod("study", String.class); // 成员方法如果是private之类的话要用getDeclaredMethod方法
    System.out.println("Arrays.toString(study.getParameterTypes()) = " + Arrays.toString(study.getParameterTypes()));
  }
  
  // 获取成员变量或者其他信息可以用getField等方法，略
  
  // 调用成员方法
  public void invoke_class_methods() throws xxxException {
    Class<Person> personClass = Person.class;
    Method sayHi = personClass.getMethod("sayHi(成员方法名称)");
    System.out.println(sayHi.invoke(new Person()));
    
    Method study = personClass.getDeclaredMethod("study", String.class); // 成员方法如果是private之类的话要用getDeclaredMethod方法
    study.setAccessible(true);
    System.out.println(study.invode(new Person(), "code"));
  }
}

动态代理

代理模式是指通过代理对象代替目标对象完成相应操作，并能够在操作执行的前后进行增强处理。

代理类常用于实现日志、鉴权等通用功能。

代理模式分为：

静态代理：代理类和委托类的关系在运行前就确定。但是当真实类的方法越来越多的时候，代理类对应的方法也要增加，代码量的改动大。
动态代理：
- JDK代理：涉及java.lang.reflect包中的InvocationHandler接口和Proxy类
- cglib代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JDKProxy extends InvocationHandler {
  
  private Animal target;
  
  public JDKProxy(Animal target) { this.target = target; }
  
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throw Throwable {
    System.out.println("do something before " + method.getName());
    method.invoke(target, args);
    System.out.println("do something after " + method.getName());
    return null;
  }
  
  public Object getProxyInstance() {
    return Proxy.newProxyInstance(this.getClass.getClassLoader(), target.getClass().getInterfaces(), this);
  }
  
  public static void main(String[] args) {
    Person person = new Person();
    Animal proxyInstance = (Animal)new JDKProxy(person).getProxyInstance();
    proxyInstance.move();
    proxyInstance.rest();
  }
}

多线程

线程thread是os能够进行运算调度的最小单位，使用多线程可以实现系统并发操作，提高资源利用率。使用多线程编码的好处：

提高cpu资源利用率：进行具有阻塞性质的操作，阻塞期间cpu不能进行工作，使用多线程可以增加程序的吞吐量。
保证公平特性：多个用户或程序对系统资源具有平等优先级，使用时间片的方式可以更好的共享cpu资源。
功能模块化：创建多个线程，让其并行的执行某个单独的任务，职责单一。

普通的多线程方式包括继承Thread和实现Runnable接口两种方式。

继承Thread：由于Java不能允许多继承，一个类如果需要继承其他类就不能再定义为线程类了。
实现Runnable接口：由于接口可以多实现，一个类可以继承其他类的同时实现Runnable接口称为线程类。

public class ThreadDemo {
  public static void main(String[] args) {
    MyThread t1 = new MyThread();
    MyThread t2 = new MyThread();
    t1.start();
    t2.start();
    
    Thread t3 = new Thread(new MyRunnable());
    Thread t4 = new Thread(new MyRunnable());
    t3.start();
    t4.start();
  }
}

// 继承Thread
class MyThread extends Thread {
  @Override
  public void run() {
    for (int i=0; i<10; i++) {
      System.out.println(MyThread.currentThread().getName() + ": " + i);
    }
  }
}

// 实现Runnable
class MyRunnable implements Runnable {
  @Override
  public void run() {
    for (int i=0; i<10; i++) {
      System.out.println(MyThread.currentThread().getName() + ": " + i);
    }
  }
}

线程池

公司Java编程规范中指出，建议“避免不加控制地创建新线程，应该使用线程池来管控资源”。

线程池有如下优点：

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

ThreadPoolExecutor是线程池最基础的功能实现类，构造方法参数如下：

参数	意义
corePoolSize	核心线程池数量，一个任务到来时，如果当前没有空闲线程且线程数量小于corePoolSize，则创建一个新的线程执行这个任务。
maximumPoolSize	如果阻塞队列已满，无法继续将任务放入。如果当前线程数量小于maximumPoolSize则创建一个新的线程执行当前任务。
keepAliveTime, unit	线程空闲时间，如果当前线程数量已经大于corePoolSize或者调用了allowsCoreThreadTimeOut将线程超时关闭设置为true，则空闲这段时间后会关闭线程。
workQueue	负责任务缓冲的阻塞队列，如果当前没有空闲线程且线程数量已经等于corePoolSize，则尝试将任务放入这个阻塞队列，如果成功则等待有空闲线程取出执行。
handler	如果当前阻塞队列满，且当前线程数量已经到达maximumPoolSize，则调用handler的rejectedExecution方法处理这个任务。

线程池创建线程的流程如下：

线程数如果小于corePoolSize，创建线程执行任务，否则进入2
workQueue阻塞队列如果还没满，则将任务插入阻塞队列；如果满了进入3
活动线程如果小于maximumPoolSize，创建线程执行任务，否则进入4
使用拒绝策略handler

如何合理使用线程池：

cpu密集型任务应配置尽可能小的线程，如配置Ncpu+1个线程的线程池。
io密集型任务的线程数量计算公式为Nthreads = Ncpu*Ucpu*(1+W/C)，从而充分利用cpu资源。
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理，它可以让优先级高的任务先执行。
执行时间不同的任务可以交给不同规模的线程池来处理，或者可以使用优先级队列，让执行时间短的任务先执行。

IO编程

java.io包中提供了各种流stream的相关API，可以通过标准接口和外部设备（文件、网络等）交互，输入/输出不同类型的数据。

按流的传输格式分为两种：

字节流：以字节byte为单位处理数据，适用于处理二进制数据（图片、视频）
字符流：以Unicode码元char为单位处理数据，适合处理文本数据（txt等）

NIO

Non-blocking IO（NIO）是一种非阻塞io，也称为New IO。nio主要的api包括通道channel、缓冲区buffer和选择器selector。

通道channel
- channel可以读取和写入通道，流是单向的（读或写）
- channel可以异步读写，流是同步的（读或写）
- channel总是从buffer读取或向buffer写入，流可以直接读写
缓冲区buffer
- buffer是一个内存块，与channel交互时使用，可以向其中写入数据并再次读取这些数据。
- buffer读写数据通常遵循以下步骤：1. 将数据写入buffer；2. 调用buffer.flip()切换读写模式；3. 从buffer中读取数据；4. 调用buffer.clear()重置buffer。
选择器selector：selector可以检测多个Java channel实例，并确定哪些通道已准备好进行读取或写入。这样单个线程就可以管理多个通道，从而可以管理多个io连接，这种方式避免创建过多线程，减少资源占用。

Netty

Netty是一个基于Java NIO的网络编程框架，提供了一套高效的、事件驱动的异步网络通信机制。Netty底层使用了Java的NIO基础，并在其基础上进行了性能的优化。

正则表达式

实例1：入参格式校验

需求：校验入参是否为公司账号

Pattern：用于定义匹配模式
Matcher：用于指定具体进行匹配方式
matcher.matches()：整体匹配

public void match_entire() {
  String input = "l50039872";
  String regex = "[a-z]\\d{8}";
  boolean isMatch = Pattern.matches(regex, input);
  System.out.println("match entire: " isMatch);
}

实例2：字符串匹配搜索

需求：寻找报文中所有的公司账号

matcher.find()：是否找到匹配的子字符串
matcher.group(0)：匹配的当前字符串

public void match_all() {
  String input = "Java Engineer: l50039872, d23454582";
  String regex = "[a-z]\\d{8}";
  Pattern p = Pattern.compile(regex);
  Matcher m = p.matcher(input);
  int i = 0;
  while (matcher.find()) {
    System.out.println(++i + " Found: " + m.group(0));
  }
}

实例3：字符串匹配搜索并分组解析

需求：寻找报文中的所有公司账号，并分别展示字母和数字

matcher.group(i)：匹配到的子字符串的第i个部分

public void group_match() {
  String input = "Java Engineer: l50039872, d23454582";
  String regex = "([a-z])(\\d{8})";
  Pattern p = Pattern.compile(regex);
  Matcher m = p.matcher(input);
  int i = 0;
  while (matcher.find()) {
    i++;
    System.out.println(i + " Found: " + m.group(0));
    System.out.println(i + " Found 1: " + m.group(1));
    System.out.println(i + " Found 2: " + m.group(2));
  }
}

实例4：报文中的敏感字段过滤

需求1：将json报文中的敏感字段替换成***，如果key中含"password"，则认为对应的value为敏感字段。

input.replaceAll(regex, "$1***$3")：第一个入参只要被替换字符的模式，第二个时替换换后的内容。这里用到了外部反向引用分组。

public void replace_pwd() {
  String input = "xxxxxx";
  String regex = "(\".*password.*\": \")(\\w*)(\")";
  String output = input.replaceAll(regex, "$1***$3");
  System.out.println("output = " + output);
}

需求2：如果input包含多个password，会导致贪婪。

非贪婪模式：可以通过在量词后面添加一个问号来实现。如果要匹配尽可能少的字符，可以使用"*?"或"+?"或"??"等非贪婪量词。

public void replace_pwd_all() {
  String input = "xxxxxx";
  String regex = "(\".*?password.*?\": \")(\\w*)(\")";
  String output = input.replaceAll(regex, "$1***$3");
  System.out.println("output = " + output);
}

数据库应用编程

JDBC编程

JDBC（Java DataBase Connectivity）是Java连接数据库操作的原生接口。JDBC也是软件开发人员入门数据库开发的必学和基础只是，便于我们了解数据库操作的基本机制和用法。

public static void main(String[] args) throws Exception {
  Connection c = null;
  Statement s = null;
  ResultSet resSet = null;
  try {
    // 加载MySQL驱动程序
    // 反射方式加载jar包中的com.jdbc.Driver类
    // 执行静态代码块中的DriverManager.registerDriver(new Driver())进行注册
    Class.forName("com.mysql.cj.jdbc.Driver");
    // 建立数据库连接
    // Connection为数据库连接对象，url指定连接的路径，格式为"jdbc:mysql://ip地址:端口号/数据库名称"
    c = DriverManager.getConnection(url, user, pwd);
    s = c.createStatement();
    // 执行sql查询
    String sql = "SELECT * FROM TABLE LIMIT 10";
    resSet = s.executeQuery(sql);
    while (resSet.next()) {
      System.out.println(resSet.getString(xxxColumnLabel));
    }
  } catch (xxxException e) {
    ...
  } finally {
    ...
  }
}

注意：禁止直接使用外部数据来拼接sql语句，避免sql注入。

JDBC有几个关键接口：

Driver：每个驱动类都必须实现的接口，java sql框架允许使用多个数据库驱动程序。每个驱动程序都应该提供一个实现Driver接口的类。
DriverManager：用于注册Driver，并创建数据库连接。DriverManager将尝试加载它能找到的尽可能多的驱动程序，然后对应任何给定的连接请求，它将依次要求每个驱动程序尝试连接到目标url。
Connection：与特定数据库进行连接（会话），在连接的上下文中可以执行sql语句并返回结果。
Statement：用于向数据库发送sql语句
ResultSet：用于代表sql语句的执行结果。ResultSet对象维护了一个指向表格数据行的游标，类似迭代器。调用ResultSet.next()等方法可以使游标指向具体的数据行，进行调用方法获取该行的数据。

MyBatis编程

ORM（Object Relational Mapping）是一种思想，是插入在应用程序和jdbc之间的一个中间层，便捷的将应用中的对象与数据库的字段进行映射，简化java数据库应用开发。

JPA（Java Persistence API）是Java持久化规范，是ORM框架的标准。

Mybatis是一个业界流行的持久化框架，但不严格依照JPA规范，底层封装了JDBC，开发更简洁、灵活。

基于MyBatis的Java应用开发内容包括：

数据库安装创建
数据库配置
DAO层Mapper接口开发
Mapper.xml映射文件开发
业务代码调用Mapper接口

基于SpringBoot框架的数据库应用开发中，需要在application.yml配置文件中添加如下数据库配置：

spring:
	datasource:
		name: root
		url: jdbc:xxx(url)
		username: root
		password: xxx
		type: # 数据库连接池
		driver-class-name: com.mysql.cj.jdbc.Driver # 数据库驱动的类名，同jdbc的url
		
mybatis:
	mapper-locations: classpath:com.xxx/*.xml # 配置mapper.xml路径
	type-aliases-package: com.xxx # 实体类存放位置

DAO层Mapper接口可以基于@Mapper注解实现，是java业务代码进行数据库操作的纽带。

@Mapper
public interface UserMapper {
  List<User> queryUserInfo(@Param("name") final String name);
}

Mapper.xml映射文件开发。

mapper namespace="com.xxx.dao.UserMapper"要与Mapper接口类名保持一致。
select id="queryUserInfo"要与Mapper接口的方法名保持一致。
#{name} 标识接口中的参数，名称要一一对应。使用"#"方式避免sql注入。
通过定义resultMap标识复杂对象类型与数据库字段的对应关系。

<mapper namespace="com.xxx.dao.UserMapper">
  <resultMap type="com.xxx.model.User" id="userMap">
    <result property="name" column="name"/>
    <result property="description" column="description"/>
  </resultMap>
  <select id="queryUserInfo" resultMap="userMap">
    select * from TBL_USER_INFO user where NAME = #{name}
  </select>
</mapper>

业务代码中合适位置调用Mapper接口即可。

@RestController
public class UserService {
  @Autowired
  private UserMapper userMapper;
  
  @RequestMapping("/queryUserInfo")
  public List<User> queryUserInfo(@RequestParam("name") String name) {
    List<User> userList = userMapper.queryUserInfo(name);
    return userList;
  }
}

网络编程

在JDK的java.net包中，提供Socket等api，封装了网络通信的底层细节，支持tcp和udp协议的网络通信。

套接字socket是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象，是一种实时、双向的通信方式，客户端和服务器之间建立持久连接，双方可以随时发送和接收数据。

即时通讯：通过socket，可以在多个用户之间实现实时的文字、音频或视频通信。
文件传输：可以使用socket在不同计算机之间传输文件（视频、图片），断点续传。
远程控制：可通过socket在远程计算机上执行指令或操作。

网络编程socket有一些关键的api：

public ServerSocket(int port)创建一个ServerSocket对象，绑定到指定的端口。
public Socket accept()侦听此套接字建立的连接并接受它。该方法会阻塞，直到建立连接。
public Socket(String host, int port)创建流套接字并将其连接到指定主机上的指定ip和端口号。连接后服务端的accept()方法返回服务端的socket。
public InputStream getInputStream()返回此套接字的输入流，用于读取/接收数据。
public OutputStream getOutputStream()返回此套接字的输出流，用于写入/发送数据。

实际业务场景中经常使用REST和WebSocket进行网络编程。

REST是一种常见的网络通信方式，是一套架构原则，使用http协议进行网络通信。REST遵循单向的请求-响应的通信模式，但服务器无法在需要时主动向客户端推送数据。REST非常适合哪些采用单向的请求-响应模式的场景，比如查看新闻网页、提交评论等，但不适合需要双方实时通信的应用，比如视频聊天、在线游戏等。

WebSocket是一种基于tcp协议的应用层协议，通过http/https协议建立起一个双向通信的通道，可以在客户端和服务器之间实现实时的数据传输。WebSocket可以看作是Socket的一种高级应用，它在socket的基础上实现了更高层次的协议和更便捷的编程接口，使得开发者可以更方便地实现实时通信。

安全类库

运行未知地java程序时，可能触发代码中的不安全或敏感操作（删除系统文件、重启系统等）。为防止直接运行相关代码对系统产生负面影响，需要对相关操作权限进行控制。

JDK中内置了SecurityManager安全管理器，允许程序在执行可能不安全或敏感的操作之前确定该操作是什么，以及是否在允许执行该操作的安全上下文中尝试该操作。

类加载器

类生命周期

类的生命周期中，有7个阶段：

加载：读取java类字节码并转化为方法区进行时的数据结构，创建一个代表该类的class对象。
验证：验证字节码信息是否符合jvm规范，防止恶意代码攻击jvm。
准备：为类的静态变量分配内存，并为静态变量赋初始值。不包含被final修饰的static变量，因为在编译时已经分配。
解析：将常量池中的符号引用转换为直接引用。如果符号引用指向一个未被加载的类，或者未被加载类的字段或方法，那么解析将触发这个类的加载。
初始化：执行静态初始化块和类变量赋值。执行类的构造函数，会触发即时解析依赖的类。先初始化父类，后初始化子类。
使用
卸载

类加载器机制

java中有3个内置类加载器，分别复杂加载不同的类：

启动类加载器（Bootstrap ClassLoader）
扩展类加载器（Extension ClassLoader）
应用程序类加载器（Application ClassLoader）

双亲委派机制是指当一个类加载器收到类加载请求时，它会先将该请求委派给它的父类加载器取尝试加载。只有当父类加载器无法加载该类时，子类加载器才会尝试加载。

双亲委派机制的优点有：

避免重复加载：通过委派给父类加载器，可以避免同一个类被多次加载，提高了加载效率。
安全性：通过双亲委派机制，核心类库由根加载器加载，可以确保核心类库的安全性，防止恶意代码替换核心类。
扩展性：开发人员可以自定义类加载器，实现特定的加载策略，从而扩展java的类加载机制。

运行时数据区

运行时数据区分为如下几个部分：

程序计数器
虚拟机栈
本地方法栈
Java堆
方法区
运行时常量池
直接内存

JVM内存配置参数

业务中需基于各内存分区的作用、业务场景需求合理配置参数。常用的jvm内存配置如下：

启动参数	说明
`Xmx`	jvm可申请的最大堆内存，创建对象过多且无法自动回收易导致堆溢出。
`Xms`	jvm启动时申请的堆内存。
`Xss`	线程栈大小，默认1024kb，程序递归深度太深容易导致线程栈溢出。
`MaxMetaspaceSize`	最大元空间，用于限制本地内存分配给类元数据的大小。
`MaxDirectMemorySize`	直接内存大小，使用ByteBuffer.allocateDirect()等方式申请直接内存过多或清理不及时就溢出。当Direct ByteBuffer分配的堆外内存到达指定大小后，会触发full gc。

垃圾回收机制GC

程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而无，比较确定。但java堆和方法区则有着很显著的不确定性，所以垃圾回收器所关注的堆和方法区的内存回收问题。

垃圾识别算法

引用计数算法

在对象中添加一个引用计数器，每当有一个地方引用它时，计数器值+1，当引用失效时，计数器-1。任何时刻计数器=0的对象就是不能再被使用的。

但是引用计数算法存在问题：对象之间循环引用等例外情况需要考虑，必须配合大量额外处理才能保证正确地工作。

可达性分析法

从gc roots开始，根据引用关系向下搜索，如果某个对象到gc roots间没有任何引用链相连，则证明此对象是不可能再被使用的。可以被认为是gc roots的对象有：

在虚拟机栈（栈帧中的本地变量表）中引用的对象
在方法区中类静态属性引用的对象
在方法区中常量引用的对象
在本地方法栈中JNI引用的对象
java虚拟机内部的引用

引用关系类型

强引用是指代码中普遍存在的类似Object obj = new Object()之类的应用，只要强引用还存在，垃圾收集器永远不会回收被引用的对象。

软引用SortReference描述的是那些还有用但并非必须的对象。在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。

弱引用WeakReference描述的是非必须对象。被弱引用关联的对象只能生存到下一次垃圾回收之前，垃圾收集器工作之后，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。

虚引用PhantomReference存在的唯一目的就是在这个对象被收集器回收时收到一个系统通知，被虚引用关联的对象，和其生存时间完全没关系。

垃圾回收算法

标记-清除算法

分为标记和清楚两个阶段，首先标记出所有需要回收的对象，标记完成后统一回收所有被标记的对象。

但是从效率的角度讲，标记和清除的效率都不高。从空间的角度讲，标记清除后会产生大量不连续的内存碎片。

标记-复制算法

将可用内存按照容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完后，就将还存活着的对象复制到另外一块上面，然后再把已经使用过的内存空间一次清理掉。

不过内存缩小为原来的一半，代价太高。在对象存活率较高时就要进行较多的复制操作，效率将会降低。

标记-整理算法

标记过程与标记-此乃给出算法一样，但后续步骤为让所有存货的对象都向内存空间一端移动，然后直接清理掉边界以外的内存。

分代收集

垃圾收集方式：

部分收集Partial GC：目标不是完整收集整个java堆的垃圾收集
- 新生代收集Minor GC
- 老年代收集Major GC
- 混合收集Mixed GC
整堆收集Full GC：收集整个java堆和方法区的垃圾收集

垃圾收集器

收集器	串行or并行or并发	分代	算法	目标	适用场景
Serial	串行	新生代	复制	响应速度优先	单cpu环境下的client模式
Serial Old	串行	老年代	标记-整理	响应速度优先	单cpu环境下的client模式，cms的后备方案
ParNew	并行	新生代	复制	响应速度优先	多cpu环境时在server模式下与cms配合
parallel scavenge	并行	新生代	复制	吞吐量优先	在后台运算而不需要太多交互的任务
parallel old	并行	老年代	标记-整理	吞吐量优先	在后台运算而不需要太多交互的任务
cms	并发	老年代	标记-清除	响应速度优先	集中在互联网站或b/s系统服务端上的java应用
g1	并发	both	标记-整理+复制	响应速度优先	面向服务端应用，将来替换cms

Java编程入门

Fri, 25 Apr 2025 00:00:00 GMT

基本数据类型

基本数据类型的占用空间固定，直接在变量中存储值和传递值。基本数据类型有byte, short, int, long, float, double, char, boolean。

基本数据类型在使用时，如果忽略取值范围，会造成代码异常
浮点数不能直接用==比较

char和String赋值时需要注意转义，尤其时八进制/十六进制表示方法。

转义字符	意义
\b	退格backspace
\f	换页，将当前位置移到下页开头
\n	换行
\r	回车
\t	水平制表，跳到下一个tab位置
`\\`	代表一个反斜线字符
`\'`	代表一个单引号字符
`\"`	代表一个双引号字符
`\0`	空字符null
`\000`	1到3位八进制数所代表的任意字符
`\u0000`	Unicode转义字符，\u + 4个十六进制数字，`\u0000`表示空字符

基本数据类型存在以下类型转换：

自动类型转换
强制类型转换
类型提升

java所有的数值类型之间可以相互转换。如果系统可以把一种类型的值赋给另一种类型，称为自动类型转换。允许自动类型转换的标准是表数范围小的类型赋值给表数范围大的类型。

从整数型向浮点型转换时，仍可能有精度损失。
如果转换和计算同时进行，要小心数据的溢出。

强制类型转换可用于所有基础数值类型之间的转换，很多场合特指表数范围大的类型给表数范围小的类型赋值。

类型提升指的是当一个算数表达式包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升。

byte、char、short自动提升为int
整个表达式的数据类型自动提升至表达式中的最高数据类型

引用数据类型

引用数据类型类似于c的指针，存放的是对象的引用。引用变量在声明时被指定为一个特定的类型，一旦声明后，类型就不能被改变。

引用类型包括：类、接口、数组、枚举和注解。默认值为null。引用变量可以用来引用任何与之兼容的类型。

数组

// 声明
int array[];
int[] array;
// 初始化
int[] array = new int[5];
int[] array = {0, 1, 2};
int[] array = new int[]{0, 1, 4};
// 错误的示例
int array[5];
int array[5] = {0, 1, 2, 3, 4};
// 索引遍历
for (int i=0; i<array.length; i++) {}
// for-each遍历
for (int value : array) {}

包装类

包装类就是把基本数据类型和其辅助方法封装到类中，注意基本类型不是类，无法获得类的基本特性（无法参与转型、泛型、集合、反射等过程）。用包装类就是为了弥补这个缺陷。

Integer a = Integer.valueOf(5); // 装箱
int b = a.intValue(); // 拆箱
Integer a = 5; // 自动装箱
int b = a; // 自动拆箱

由于包装类的拆装箱过于无感，混用时可能造成性能问题
当引用数据类型有更匹配的重载方法时，不会自动拆装箱

包装类比较必须使用equals() ，==比较的是两个引用是否指向一个对象。

包装类的创建很浪费性能，因此java对简单数字(-128~127)对应的包装类进行了缓存，称为常量池。通过直接量赋值的包装类如果在此范围内，会直接使用常量池的引用，因此==返回true。

包装类默认值为null，自动拆箱时会报NullPointerException。

Java基本语法

java的程序结构由不同的包组成，包由java文件组成，每个java文件有且只能有一个和文件同名的公共类/接口。

包声明：每个文件至多一句，声明类所在的包
import声明：文件中引入的所有外部类声明
公共类/接口：每个文件只能有一个公共类，类名必须和文件名一致。所有的内部类、成员、方法等都写在公共类内
程序入口：java程序的入口方法，形式必须为public static void main (String[] args)

package com.example.myapp; // 包声明

import java.util.ArrayList; // import声明
import java.util.List;

public class MyClass{ // 公共类
  private List mList = new ArrayList();
  public static void main (String[] args) { // 程序入口
  
  }
}

标志符：在java语言中，用来标志类名、对象名、变量名、方法名、类型名、数组名、包名的有效字符序列，称为标志符。

由子母、数字、下划线、$组成，且第一个字符不能是数字
区分大小写

关键字：有一些专门词汇被赋予特殊含义，不能作为标志符。

运算符：

算术运算符
关系运算符
位运算符
逻辑运算符
赋值运算符
条件运算符
instanceof 运算符

逻辑与流程控制：

循环结构：for、while、do...while
条件语句：if...else、switch(尽量不要省略break)

异常处理：

检查性异常：用户错误或问题引起的异常，是程序员无法预见的
运行时异常：可能被程序员避免的异常，在编译时可以被忽略
错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略

try {
  // 用于监听，将要被监听的代码放在里面，当try语句块内发生异常时，异常就被抛出
} catch (NullPointerException e) {
  // 捕获异常
} catch (Exception e) {
  
} finally {
  // finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句。如果finally块中使用了return或者throw，则不会跳回执行，直接停止
}

// throw用于抛出异常
// throws用在方法签名中，用于声明该方法可能抛出的异常

异常匹配规则：

如果抛出的异常对象属于catch子句中的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。
每个catch子句依次检查，一旦有子句匹配，则后面的被旁路。因此编写多重catch语句时，需要先小后大，即先子类再父类。

finally规则：

finally语句必定会执行，除非程序/线程提前退出。
finally执行时机再try/catch代码块退出前，即所有代码块后，跳出逻辑前。
finally执行语句不会影响原有返回值。
finally中如果执行return或抛异常，会代替原有返回逻辑。

Lambda表达式

new Thread { // 省略了接口名、函数名，注意行末没有分号
  () -> System.out.println("Thread")
}

List<String> list = Arrays.<String>.asList("Lambda", "is", "wonderful");
Collections.sort(list, (s1, s2) -> { // s1, s2省略了参数表类型，直接写形参。多行代码用{}包围
  if (s1 == null) return -1;
  if (s2 == null) return 1;
  return s1.length() - s2.length();
})

Lambda只能用在函数接口上，即只含有一个方法的接口
Lambda依赖于参数推断

IO编程

在java io中，流是一个核心的概念。流从概念上说是一个连续的数据流。你既可以从流中读取数据，也可以往流中写数据。流与数据源或者数据流向的媒介相关联。

字节流：以字节byte为单位处理数据，适合处理二进制数据 InputStream, OutputStream
字符流：以Unicode码元（char）为单位处理数据，适合处理文本数据 Reader, Writer

NIO（Non-blocking I/O）是一种同步非阻塞的io模型，也是io多路复用的基础，成为解决高并发与大量连接、io处理问题的有效方式。nio不同于io的一点在于nio面向缓冲区，而io面向流。

buffer缓冲区：一块可读写数据的内存。java中包装为Buffer对象，并提供了一组操作方法。buffer的读写步骤为：
- 1、写入数据到buffer
- 2、flip()切换读模式
- 3、从buffer中读取数据
- 4、clear()/compact()方法清数据
channel通道：类似于流，但是有区别。
- 通道是双向的，可读也可写
- 通道可以异步地读写
- 通道中的数据总是要先读到一个buffer，或者总是要从一个buffer中写入
selector选择器：用于侦听多个通道是否已做好读写准备，配合nio实现单个线程管理多个通道。

io多路复用是单个线程进行多个通道的io。

阻塞io，非阻塞io和io多路复用的比较：

在阻塞io中，线程只能空闲等待，只有靠增加线程数提升效率。
非阻塞io中，虽然可以同时尝试多个通道，但轮询会消耗过多cpu或者错过io时机。
多路复用是触发式io，可以实现单线程管理多个通道，且不必担心错过读写时机。

正则表达式

正则表达式定义了字符串的模式，可以用来搜索、编辑或者处理文本。正则表达式并不仅限于某一种语言，但是在每种语言中又细微的差别。

在java中，\\表示插入一个正则表达式的反斜线。在java中需要2个反斜杠才能被解析为其他语言中的转义作用。

常用字符	意义
`^`	匹配输入字符串开始的位置。如果设置了RegExp对象的Multiline属性，`^`还会与\n和\r之后的位置匹配。
`$`	匹配输入字符串结尾的位置。如果设置了RegExp对象的Multiline属性，`^`还会与\n和\r之后的位置匹配。
`*`	零次或多次匹配前面的字符或者子表达式
`+`	一次或多次匹配前面的字符或者子表达式
`?`	零次或一次匹配前面的字符或者子表达式
`[a-z]`	字符范围，匹配指定范围内的任何字符
`\w`	匹配任何字类字符，包括下划线
`\W`	与任何非单词字符匹配

// 正则匹配
String content = "XXXX";
String pattern = ".*Huawei.*";
boolean isMatch = Pattern.matches(pattern, content);
System.out.println(isMatch);

// 捕获组
String line = "This order was placed for xxxx";
String pattern = "(\\D*)(\\d+)(.*)";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(line);
if (m.find()) {
  System.out.println("Found Value: " + m.group(0));
  System.out.println("Found Value: " + m.group(1));
  System.out.println("Found Value: " + m.group(2));
  System.out.println("Found Value: " + m.group(3));
} else {
  System.out.println("No Match");
}

正则注入regex injection：攻击者可能会通过恶意构造的输入对初始化的正则表达式进行修改，比如导致正则表达式不符合程序规定要求；可能会影响控制流，导致信息泄露，或导致ReDos攻击。java安全规范规定，禁止直接使用不可信数据构造正则表达式。利用方式有：

匹配标志：不可信的输入可能覆盖匹配选项，然后有可能会被传给Pattern.compile()方法。
贪婪：一个非受信的输入可能试图注入一个正则表达式，通过它来改变初始的那个正则表达式，从而匹配尽可能多的字符串，从而暴露敏感信息。
分组：程序员会用括号包括一部分的正则表达式以完成一组动作中某些共同的部分。攻击者通过提供非受信的输入来改变这种分组。

针对正则注入的输入校验：

非受信的输入应该在使用前净化，从而防止发生正则表达式注入。
当用户必须指定正则表达式作为输入前，必须注意需要保证初始的正则表达式没有被无限制修改。
在用于输入字符串提供给正则解析之前，进行白名单字符处理。
开发人员必须仅仅提供有限的正则表达式功能给用户，从而减少被误用的可能。

面向对象

面向对象是在分析问题时，以问题所涉及到的事或物为中心的分析方式。

类class表示归纳和整理
对象object表示具体的事物

基本语法

// 类的语法基本结构
/*
class 类名 {
  特征（属性）
  功能（方法）
}
*/

// 创建对象
// new 类名();

class Cooking {
  // 属性
  String name;
  String type = "红烧";
  String food;
  String relish = "大料";
  // 方法
  void execute() {
    System.out.println("准备食材:" + food);
    System.out.println("准备佐料:" + relish);
    System.out.println("开始烹饪");
    System.out.println("烹饪完成");
  }
}

public class Java_Object {
  public static void main(String[] args) {
    Cooking c = new Cooking();
    c.name = "红烧排骨";
    c.food = "排骨";
    c.execute();
  }
}

类和对象

类是一种结构体，里面包含了属性和方法，会有很多的对象。

对象是类的实例化，一般new出来的对象会赋值给变量，方便重复使用。变量的类型就是对象的类型。对象是将内存地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量，而变量的类型称之为引用数据类型。

有一种特殊的对象null。null是没有引用的对象，称为空对象。所有引用类型变量的默认取值是null。

静态

把和对象无关，只和类相关的称之为静态static。和类相关的属性称之为静态属性，和类相关的方法称之为静态方法。

class Test {
  String name;
  static String sex;
  void test() {
    test1(); // 成员方法可以访问静态属性和静态方法，因为对象先于类存在
    System.out.println("test...");
  }
  static {
    // 对象准备创建时，也会自动调用代码块，但不是静态的
    System.out.println("静态代码块执行"); // 类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能
  }
  static void test1() {
    System.out.println("test1...");
  }
}

public class Java_Static {
  public static void main(String[] args) {
    Test t = new Test();
    t.test();
    t.test1();
    Test.test1(); // 两种都可以
  }
}

构造方法

构造方法专门用于构造对象。如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的、无参的构造方法，方便对象的调用。

构造方法也是方法，但是没有void关键字
方法名和类名相同
如果类中没有构造方法，那么JVM会提供默认的构造方法
构造方法也是方法，所以也可以传递参数，但是一般传递参数的目的是用于对象属性的赋值

class User {
  String username;
  User(String name) {
    username = name;
    System.out.println("Name: " + name);
  }
}

继承

类的继承只能单继承，一个类只能有一个父类，不能存在多个父类。继承采用extends语法。

父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的构建。默认情况下，子类对象构建时，会默认调用父类的构造方法完成父类对象的构建，使用的时super()的方式，只不过JVM自动完成。如果父类提供构造方法，那么JVM不会提供默认的构造方法，那么子类应该显示调用super方法构建父类对象。

class Parent {
  String name = "zhangsan";
	void test() { System.out.println("test..."); }
  Parent() { System.out.println("parent..."); }
}

class Child extends Parent {
  Child() {
    super();
    System.out.println("child...");
  }
}

多态

多态是一个对象在不同场景下表现出来的不同状态和形态。多态语法是对对象的使用场景进行了约束。一个对象可以使用的功能取决于引用变量的类型。

class Person {
  void testPerson() { System.out.println("test person..."); }
}

class Boy extends Person {
  void testBoy() { System.out.println("test boy..."); }
}

public class Java_Polymorphism {
  public static void main(String[] args) {
    Person p = new Person();
    p.testPerson();
    Person p1 = new Boy();
    // p1.testBoy(); 无法运行
  }
}

重载与重写

一个类中，不能重复声明相同的方法，也不能声明相同的属性。这里相同的方法指的是方法名，参数列表相同，和返回值类型无关。

如果方法名相同，但是参数列表（个数，顺序，类型）不同，会认为是不同的方法，只不过名称一样，这个操作在Java称之为方法的重载。

class User {
  User() {}
  User(String name) { System.out.println("name: " + name); }
  
  void login(String account, String pwd) { System.out.println("登录"); }
  void login(int tel) { System.out.println("手机验证码登录"); }
}

父类对象的方法主要体现通用性，无法在特殊的场合下使用。如果子类对象需要在特殊的场合下使用，那么就需要重写方法的逻辑，这个操作在Java中称之为方法的重写。这里的重写，并不意味着父类的方法被覆盖掉，只是在当前的场合不使用，如果使用的话可以使用super关键字访问。

方法的重写要求子类的方法和父类的方法名相同，返回值类型相同，参数列表相同

class Parent {
  String name = "zhangsan";
  void test() { System.out.println("parent test..."); }
}

class Child {
  String name = "lisi";
  void test() {
    super.test();
    System.out.println("child test...");
  }
}

访问权限

Java中的访问权限主要分为四种：

private：同一个类中可以使用
default：默认权限，当不设定任何权限时，JVM会默认提供权限，包（路径）权限
protected：受保护的权限，子类可以访问
public：任意使用

内部类

所谓的外部类就是在源码中直接声明的类，而内部类则是类中声明的类。

Java不允许外部类使用private，protected修饰，内部类就当成外部类的属性使用即可。因为内部类可以看作外部类的睡醒，所以需要构建外部类对象才可以使用。

public class Java_InnerClass {
  public static void main(String[] args) {
    OuterClass outer = new OuterClass();
    OuterClass.InnerClass inner = outer.new InnerClass();
  }
}

class OuterClass {
  public class InnerClass {
    
  }
}

final

Java中提供了一种语法，可以在数据初始化后不被修改，使用关键字final。

final可以修饰变量，变量的值一旦初始化无法被修改。一般将final修饰的变量称之为常量，或者叫不可变变量。
final可以修饰属性，那么JVM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化。
final可以修饰方法，这个方法不能被子类重写。
final可以修饰类，这个类就没有子类。
final不可以修饰构造方法。
final可以修饰方法的参数，一旦修饰，参数就无法修改。

final String name = "zhangsan";

class User {
  public final String name;
  public User(String name) {
    this.name = name;
  }
  public final void test() {}
}

final class FinalClass {
  public FinalClass() {}
}

抽象

抽象方法是只有声明，但是没有实现的方法。抽象类是不完整的类，因为类不完整，所以无法构建对象。

如果一个类中含有抽象方法，那么这个类就是抽象类；如果一个类是抽象类，它的方法不一定是抽象方法。

抽象类无法直接构建对象，但是可以通过子类间接构建对象。如果抽象类中含有抽象方法，需要重写抽象方法，将方法补充完整。

abstract关键字不能和final同时使用。

abstract class Parent {
  public abstract void eat();
  public void test() {}
}

class Child extends Parent {
  public void eat() {
    System.out.println("eat...");
  }
}

接口

接口可以简单理解为规则，是抽象的。规则的属性必须为固定值，而且不能修改，属性和行为的访问权限必须为公共的。

属性应该是静态的。
行为应该是抽象的。

接口和类是两个层面的东西，接口可以继承其他接口，类的对象需要遵循接口，在Java中这个遵循，称之为实现，类需要实现接口，而且可以实现多个接口。

interface USBInterface {}
interface USBSupply extends USBInterface {
  public void powerSupply();
}
interface USBReceive extends USBInterface {
  public void powerReceive();
}

class Computer implements USBSupply {
  public USBReceive usb1;
  public USBReceive usb2;
  public void powerSupply() {
    System.out.println("电脑提供能源...");
    usb1.powerReceive();
    usb2.powerReceive();
  }
}

class Light implements USBReceive {
  public void powerReceive() {
    System.out.println("电灯接收能源...");
  }
}

public class Java_Interface {
  public static void main(String[] args) {
    Computer c = new Computer();
    Light l1 = new Light();
    c.usb1 = l1;
    Light l2 = new Light();
    c.usb2 = l2;
    c.powerSupply();
  }
}

编程后台操作

Mon, 14 Apr 2025 00:00:00 GMT

数据库

数据库database(DB)：以一定方式储存在一起，能为多个用户共享、具有尽可能小的冗余度、与应用数据彼此独立的数据集合，它具有完整性、共享性

数据库管理系统database management system(DBMS)：一种操纵和管理数据库的大型文件，用于建立、使用和维护数据库。它对db进行统一的管理和控制，以保证db的安全性、完整性、共享性等。

数据存储管理的发展阶段

人工管理：数据保存在磁带上，只能顺序读写、不能共享、数据冗余、一致性差
文件系统：数据以文件形式存储在磁盘上，应用程序和数据访问相对独立，无集中管理，数据冗余
数据库：结构化数据模型，数据和程序彼此独立，冗余度低，数据控制功能
大数据：数据量大，分布式计算，Hadoop，NoSQL

关系型数据库

关系型db是建立在关系模型基础上的db，借助于集合代数等数学概念和方法来处理db中的数据。

各种实体和实体之间的联系用关系模型表示。

标准数据查询语言SQL是一种基于关系数据库的语言，这种语言执行对关系数据库中的数据的检索和操作。

SQL

结构化查询语言Structured Query Language(SQL)一些基本概念：

投影：选出列
选择：选出行
连接：从一张或多张表中选择出合适的行再进行查询

学习路线：

select查询语句基础

select * | {[distinct] column | expression[alias],...} from table; # select基本语句
select column as another_name from table; # 重命名列标题
select col1, col2, col1||col2 as "Employees" from table; # 级联操作是将列或者字符串和其他列串联，用||表示
select distinct column from table; # 消除重复行

NULL值是不可用且未分配，未知并且不适用的值。

查询数据的限制与排序

select * | {[distinct] column | expression[alias],...}
from table
[where conditions] # 限制选择的行
[order by col1 [asc|desc], col2 [asc|desc], ...] # 按照某列排序，从左到右按序排序，默认升序

运算符：

操作符	描述
=	等于
>	大于
>=	大于等于
<	小于
<=	小于等于
<>	不等于
between ... and ...	在...和...之间（闭区间）
in (set)	匹配任意一个值
like	模糊匹配（'%'通配0个或多个字符，'_'通配一个字符）
is NULL	是一个NULL值
and	与
or	或
not	非

单行函数

函数	描述
lower('xxx')	转小写
upper('xxx')	转大写
initcap('xxx')	单词首字母转大写
concat('xxx', 'xxx')	字符连接
substr('xxx', 1, 2)	取子串（从第一个字符选取，选取2位）
length('xxx')	取字符串长度
instr('xxx', 'str')	返回子字符串在字符串中的位置
round(num, 2)	小数点后2位四舍五入
trunc(num, 2)	把小数点后两位保留，剩下截掉
sysdate	反馈系统当前日期
to_number()	字符转数字
to_char()	数字/日期转字符
to_date()	字符转日期

分组函数

函数	描述
avg(num)	返回数字表达式中所有值的平均值
sum(num)	返回数字表达式或列总和
count(*)	返回表达式中值的个数
max(num)	返回表达式中值的最大值
min(num)	返回表达式中值的最小值

select col1, avg(col2)
from table
group by col1; # 按照col1分组，在每组中计算平均值

select col1, max(col2)
from table
group by col1
having max(col2) > 10000; # 根据分组后的查询结果进行筛选显示，having只能写在group by后面

多表查询

自连接：一个表自己与自己建立连接
等值连接：查询两个表，用where进行col的等值匹配
左外连接：优先连接左表，左表如果无法连接到，则保留为空
右外连接：优先连接右表，右表如果无法连接到，则保留为空
全连接：显示所有记录，如果两边无法连接到，都保留为空

# 等值连接
select emp.ename, emp.job, dept.deptno, dept.dname
from emp, dept
where emp.deptno=dept.deptno;

# 左外连接（优先连emp表）
select emp.ename, emp.job, dept.deptno, dept.dname
from emp, dept
where emp.deptno=dept.deptno(+);

# 全连接
select emp.ename, emp.job, dept.deptno, dept.dname
from emp full join dept
on emp.deptno=dept.deptno;

子查询（嵌套式查询）

操作符	描述
in	等于列表中的任何一个
any	和子查询返回的任意一个值比较
all	和子查询返回的所有值比较

select select_list
from table
where expr operator # 主查询
	(select select_list
  from table
  where condition); # 子查询

注意一下几点：

在查询时基于未知时应考虑使用子查询
子查询必须包含在括号内
将子查询放在比较运算符的右侧，增强可读性
对单行子查询使用单行运算符
对多行子查询使用多行运算符

表结构操作语句

表时数据库存储结构的逻辑概念，表分为行和列。

create table [USER.] table_name (
  {col1 datatype [column_constraint][table_constraint]}
  {col2 datatype [column_constraint][table_constraint]}
  {...}
); # 创建表格（列名称，列数据类型，列约束，表约束）
drop table table_name cascade constraints; # 删除内容和定义，释放空间
describe table_name # 查看表结构

alter table table_name add column_name datatype; # 增加列
alter table table_name drop column column_name;  # 删除列
alter table table_name rename to new_table_name; # 修改表名
alter table table_name rename column col_name to new_col_name; # 修改列名

数据类型	描述
varchar2(L)	可变长度字符串
date	日期数据类型（日-月-年）
number(p, s)	数字类型（p为整数位，s为小数位）
boolean	布尔类型，只有true，false和null

列级约束	描述
not null	非空
unique	唯一
primary key	主键
foreign key	外键
check	条件检查

表级约束	描述
unique	唯一
primary key	主键
foreign key	外键
check	条件检查

数据操作语句

数据操作语言DML是SQL语言的核心部分，当你做下列操作时DML语句会被执行：

insert into table[(column [, column, ...])]
values (value (, value, ...)); # 增加新行到表中

update table
set column=value [, column=value, ...]
[where condition]; # 修改表中的行

delete [from] table
[where condition]; # 删除表中的行

注意：

insert：
- 该语句一次只能插入一行到表中
- 插入新的一行，每列都包含值
- 按照表中列的默认顺序列除数值
- 在insert子句中列出列是可选的
- 将日期和字符数值放入单引号中
update，delete：
- 使用where会指定要修改的行
- 不使用where会修改所有的行

事务操作语句

事务可以看作是由对db的若干操作组成的一个单元，要么全完成，要么全取消，保证数据满足一致性的要求。

事务开始于第一个dml的sql语句执行时，结束与下列事件之一：

发出commit或者rollback语句
一个数据定义语言ddl或数据控制语言dcl语句执行（隐式提交）
用户退出iSQL*Plus（默认提交）
系统崩溃（隐式提交）

事务命令	描述
commit	提交事务
roll back	回滚事务
savepoint	事务的标记点，可以使一个事务再回滚到不同的阶段
roll back to <savepoint>	与savepoint对应，回滚到标记点

commit命令执行之前，dcl首先影响db缓冲区，因此，数据以前的状态可以被恢复；当前用户可以查询表观察到dcl的结果；其他用户不能观察到当前所作的dcl的结果；其他用户不能改变受影响的行中的数据。

commit执行之后，数据在db中被永久的改变，数据以前的状态永久丢失；所有用户都可以观察到事务的结果；受影响的行的锁定被释放，其他用户可以操纵那行；所有保存点被擦除。

什么时候发起rollback命令：

用户直接发出撤销命令
某些时机程序代码段中出现异常和错误

使用save point命令在事务中建立标记点，并允许用户只回滚标记点之后的动作。

SQL语句的简单优化

避免使用'*'，在解析过程中，会将星号一次性转换成所有的列名，并通过查询数据字典完成，意味着耗费更多的事件
尽量使用表的别名
注意where子句中的连接顺序，将能够缩小范围的condition放到后面
使用'>='替代'>'
用truncate代替delete，delete如果没有commit操作，回滚段中会存放删除操作恢复的消息，而truncate会让回滚段不再存放任何可被恢复的信息，因此很少的资源被调用，执行事件会很短
尽量多的使用commit
避免在索引列上使用函数

Linux

安装linux：2019最新,Linux详细安装教程

操作系统os是管理和控制计算机硬件资源的计算机程序，核心功能有：

syscall接口
程序管理
内存管理
文件系统管理
驱动管理

Linux是类Unix操作系统，可以管理计算机所有硬件资源，进行cpu调度，分配工作桌面，linux结构分为4个，从外到内分别为应用程序，shell程序（Bash），内核kernel和硬件。

Linux特点如下：

多任务，多用户
功能强大的开发者交互界面
安全保护机制，稳定性好
用户界面，强大的网络支持
移植性好

常用的远程接入工具：xshell，xftp

Linux用户管理

Linux系统是用id来区分用户的，分为User ID和Group ID，用户名或者组名用于方便人们的记忆。

用户id保存路径：/etc/passwd
组id保存路径：/etc/group

/etc/passwd文件中记录了单个用户的登录信息，每一行代表一个用户，用':'分割成7个字段：

字段	意义
1	用户登录名
2	用户口令，加密的，/etc/shadow有真正的口令文件
3	指定用户的UID，用户登录进系统后，系统通过该值识别用户
4	组识别号GID，对应/etc/group文件中的一条记录
5	描述信息，用来保存用户的真实姓名和个人细节
6	指定用户的主目录的绝对路径
7	用户登录系统时运行的shell程序名称，通常是一个shell程序的全路径名

群组管理方法如下：

groupadd [-option] [group_name] # 新建群组
groupmod [-g n] [group_name]    # 修改群组
groupdel [group_name]           # 删除群组

用户管理方法如下：

useradd [-option] [user_name] # 新增用户
passwd [user_name] # 设置用户密码
usermod [-option] [user_name] # 修改用户属性
userdel [-option] [user_name] # 删除用户
who    # 查询当前登录系统的所有用户
id     # 查询当前用户的GID和UID
finger # 查询用户的属性信息
su [-] [user_name] # 切换用户

文件和目录管理

绝对路径是由根目录(/)开始写起的文件名或者目录名称，相对路径是相对于当前路径的文件名或者目录名称的写法。

pwd    # 显示当前工作目录
cd dir # 更改工作目录
ls [-option] [dir|file] # 查看文件或者目录
chown [-R] 文件主 文件    # 修改属主
chgrp [-R] 属有群组 文件  # 修改所属群组
chmod [-options] mode files 或者 chmod [ugoa] {+|-|=} [rwx] files # 修改权限

touch file # 新建文件
mkdir [-m 模式/权限] [-p] dir # 新增目录
cp [option] origin_file/dir target_file/dir  # 复制文件或目录
scp [option] origin_file/dir target_file/dir # 复制文件或目录，用于网络胡同的远程主机复制文件或目录，要求对其父目录具有写权限
mv [-fiu] origin_file/dir target_dir # 移动文件或目录
rmdir [-p] dir     # 删除目录
rm [-fir] file/dir # 删除文件或目录
find path [-option] [查找条件] # 查找文件或目录路径
cat file  # 直接查阅文件内容，不能翻页
more file # 翻页查看文件内容
less file # 翻页阅读
head file # 查看文件前几行内容，默认10行
tail file # 查看文件后几行内容，默认10行
grep [-cin] '目标字符串' file # 查找文件内容

command1 | command2 # 管道，将一个命令的输出连接到另一个命令的输入
command > file  # 输出重定向 (覆盖导入)
command >> file # 输出重定向 (从文件末尾导入) 
command < file  # 输入重定向

文件和目录的权限意义：

read(r)：可读取此文件/目录的实际内容
write(w)：可以编辑文件/目录（不包含删除该文件）
execute(x)：该文件具有被系统执行的权限/具有进入该目录的权限

文件属性和权限说明（从左到右）：

前十位：文件类型(1)+owner权限(3)+group权限(3)+other权限(3)
数字：连接数
用户名
用户组
文件大小
最近修改日期
文件名

vim编辑器

vim是类Unix系统内置文本编辑器，其他文本编辑器不一定存在。vim具有三种模式：

一般模式：用esc进入
编辑模式：从一般模式用i, o, a 或 R进入
指令模式：从一般模式用:, / 或 ?进入

按键说明	意义
上下左右	移动光标
0或home键	移动光标到行首字符处
$或end键	移动光标到行尾字符处
gg	移动光标到第一行
G	移动光标到最后一行
nG	n为数字，移动光标到第n行
: set nu	显示行号
/word	向光标之下搜索名字为word的字符串
?word	向光标之上搜索名字为word的字符串
n	重复前一个搜寻动作
N	重复前一个搜寻动作，但方向相反
:n1,n2s/word1/word2/g	在n1行和n2行之间搜索word1字符串，并且将该字符串替代为word2
:1,$s/word1/word2/g	全文搜索word1字符串，并且将该字符串替代为word2
:1,$s/word1/word2/gc	全文搜索word1字符串，并且将该字符串替代为word2，并在替换之前要求用户确认
x	delete键
X	backspace键
nx	delete n次
dd	删除光标所在一整行
ndd	删除光标所在行向下n行
yy	复制光标所在行
nyy	复制光标所在行向下n行
p	将已经复制的数据，从光标下一行开始粘贴
u	复原上一个动作
.	重复上一个动作
i	进入insert模式，从目前光标所在处插入
a	进入insert模式，从目前光标所在处的下一个字符插入
o	进入insert模式，从目前光标所在处的下一行插入新的一行
r	进入replace模式，取代光标所在字符一次
R	进入replace模式，一直取代直到esc为止
esc	退出编辑模式到一般模式
:w	将编辑的数据写入磁盘中
:wq	保存并退出
:q!	不保存，强制退出
ZZ	若文件没有被修改，则不存储退出。若文件被修改，则存储后退出
:w filename	另存为
:r filename	将文件名为filename的文件内容读取到光标的后面

Linux文件系统管理

文件系统是os用于明确存储和组织计算机数据的方法，即对一个存储设备上的数据和元数据进行组织的机制。它使得对数据的访问和查找变得容易。

文件系统分类：

是否有日志？
- 传统型文件系统
- 日志型文件系统
如何查找数据？
- 索引式文件系统：将文件属性数据和实际内容分别存放在不同你的区块，通过属性数据，可以快速找到实际数据所在。
- 非索引式文件系统：只有block存在，读取数据时，需要一个block一个block读取，效率较低。

目录树是如何读取的？从文件系统的顶层进行读取，获取inode号码并验证inode权限，然后根据该inode读取block内的文件名数据，再一层层往下读取到正确的档案内容。

Linux磁盘是存在分区的。安装系统时首先会接触到分区。硬盘分区实质上是对硬盘的一种格式化，将硬盘逻辑的分成不同的槽/块。让数据能够分类存放在硬盘的不同区域中，以便更好地管理数据。硬盘分区按照功能的不同，分为以下几类：

主分区3个
扩展分区1个
逻辑分区n个

fdisk -l    # 查看磁盘分区
fdisk 设备名 # 创建分区
mkfs [-t 类型] [-b block大小] 设备名称 # 创建文件系统
mount 设备名 挂载点   # 手动挂载文件系统
umount 设备名或挂载点 # 手动卸载文件系统

/etc/fstab配置了开机自动挂载的文件系统，系统挂载有以下限制：

/目录必须挂载，并且一定要先于其他挂载点被挂载起来
挂载点必须是已经存在的目录，可以任意指定
所有文件系统只能在同一时间挂载一次

/etc/fstab每行有6个字段：

字段序号	意义
1	文件系统
2	挂载点
3	文件系统类型
4	文件系统参数
5	是否采用dump备份
6	开机是否自检

df [-h|-i]    # 查看分区使用情况
du [-a|-s|-h] # 查询文件或目录的磁盘使用空间
lsof          # 查看打开的文件

网络管理

linux网络术语：

设备：主机内的网卡
链路：设备到网络的连接
接口：为使用设备，驱动程序在设备上创建了接口
子网掩码：将ip地址划分成网络地址和主机地址两部分的掩码
广播地址：到达本网段上所有主机的地址

ip的分类：

a类网络：0.xxx.xxx.xxx - 127.xxx.xxx.xxx
b类网络：128.xxx.xxx.xxx - 191.xxx.xxx.xxx
c类网络：192.xxx.xxx.xxx - 223.xxx.xxx.xxx
d类网络：224.xxx.xxx.xxx - 239.xxx.xxx.xxx
e类网络：240.xxx.xxx.xxx - 255.xxx.xxx.xxx

ifconfig 接口 [-option] # 查看或设置网络接口的参数，如ip，掩码等
ifconfig 接口 up # 读取配置文件的方式启动网络接口
route # 查看路由表
route add [-net|-host] [netmask Nm] [gw Gw] [dev] # 新增到网段或者主机的路由
route add default gw # 暂时更改默认路由
route del [-net|-host] [netmask Nm] [gw Gw] [[dev] lf] # 删除到网段或者主机的路由

ping [-option] address # 检查网络是否通畅或者网络连接速度
traceroute [-option] <ipaddr or domain name> # 探测数据包从源到目的经过的路由器的ip

Linux进程管理和服务管理

程序是文件中保存的一系列可执行命令。

进程是加载到内存中的程序，有cpu运行。用户进程是用户通过终端加载的进程。守护进程是与终端无关的系统进程，可基于时间或事件启动。

ps aux  # 查看所有进程信息
top     # 连续观察进程动态，默认3秒更新一次
pstree  # 用ascii字符显示树状结构，表达程序间的相互关系
kill    # 结束进程
killall # 结束同一进程组内的所有进程

任务的概念与相关术语：

任务：登录系统取得shell之后，在单一终端接口下启动的进程。在任务管理的行为当中，每个任务都是目前的shell的子进程，无法在一个shell下面取管理另外一个shell下面的任务。
前台：在终端接口上，可以出现提示符让用户操作的环境。
后台：不显示在终端接口的环境。

任务管理可以多项任务并行，使用&号执行。使用ctrl+z将正在运行的任务放入后台暂停。

jobs       # 查看当前shell的后台的任务
fg %job ID # 将任务放入前台执行
bg %job ID # 将任务放入后台执行
crontab [-u user] [-e|-l|-r] # 周期计划任务
at # 安排一个任务在未来执行

system daemon (systemd) 是linux下的一种init软件。作为init软件，systemd程序的任务有如下工作：

初始化文件系统，设置环境变量
挂载硬盘，/proc, /tmp, swap等
根据设置的运行级别，启动相应的守护进程
并在系统运行期间，监听整个文件系统

systemctl start|stop|status [service] # 通过systemctl管理服务
journalctl -u A.service # 查看A服务的日志
journalctl --system --since=today # 查看当天系统服务以及内核的日志

Linux监控系统

作为系统管理员，我们需要监控哪些项目？

系统是否正常启动？
系统负载如何？
系统是否有非法用户登录？

hwinfo --cpu  # 显示cpu信息
hwinfo --disk # 查看磁盘信息
iostat        # 输出cpu和磁盘io相关的统计信息
lspci         # 列出所有PCI设备

监控系统和进程的命令：

ps：用来显示当前进程状态，查看的是静态信息
top：即时显示进程的动态
uptime：查看系统已经开机的时间以及系统平均负载
uname：查看系统版本相关信息，如内核号
netstat：显示与ip，tcp，udp协议相关的统计数据，用于检验本机各端口的网络连接情况

who [option]            # 查看登录系统的用户
w [option] [user]       # 查看当前登录系统的用户以及用户当前的工作
finger [option] [user]  # 查看用户详细信息
last [option]           # 查看曾经登陆过系统的用户
lastlog [option] [user] # 查看用户最近一次登录的信息

编程工具演练

Tue, 08 Apr 2025 00:00:00 GMT

Git基础和实操

版本控制工具简介

版本控制是一种记录一个或若干文件内容变化，以便将来查阅特定版本修订情况的系统，查看历史、恢复版本，保证多人协作不出问题。

原始的版本控制是通过修改文件并保存文件副本来实现的，但命名随意，导致版本难辨新旧，无法辨别每一版的修改内容。

有一些比较远古的版本控制工具：

diff：用来比较两个文件或者目录之间的差异diff -u left.c right.c
patch：diff的反向操作，我们把上述差异结果保存到文件中，假设差异结果为diff.txt
- patch left.c diff.txt：通过diff.txt，把left.c变成right.c
- patch -R right.c diff.txt：通过diff.txt，把right.c变成原来left.c的内容

最早期的本地版本控制工具为RCS（Revision Control System）

集中式版本控制工具：CVS（Concurrent Versions System）和SVN（Subversion），但是存在问题：

提交通道狭窄：不能同时修改、缺乏代码门禁
数据安全性差：单点故障、黑客攻击

分布式版本控制系统：BitKeeper、Git

Git是Linus（Linux之父）的第二个伟大作品。和其他版本控制系统相比，Git的差别在于对待数据的方法，Git像是把数据看作是对小型文件系统的一组快照，每次提交更新时，它主要对当时的全部文件制作一个快照并保存这个快照的索引，变成一个快照流。如果其中一个版本受到破坏，其他任何一个版本都不会受到影响。Git的好处如下：

数据安全
提交为本地操作，编码不会被冲突打断，可以移动办公
数据和提交全部使用SHA1哈希，以保证完整性
适合分布式开发，强调个体

如何选择适合的版本控制工具：

SVN不适合的领域：
- 跨地域的协同开发
- 对代码的高质量追求和代码门禁
Git不适合的领域
- 不适合word等二进制文档的版本控制
- 整体的读授权，不饿能将读授权精细到目录级别

Git的安装和配置

在Linux下安装Git：

Ubuntu或Debian
- sudo aptitude install git
- sudo aptitude install git-doc git-svn git-email gitk
RHEL、Fedora、CentOS
- yum install git
- yum install git-svn git-email gitk
从源代码开始安装

在Windows下安装Git：到git-scm网站下安装windows安装包，直接下载就行，安装过程中选择一些必要的组件（建议把git-lfs去掉），在选择是否修改环境变量时，选择“Use Git Bash Only”。安装完成后，右击屏幕并选中Git Bash就可以启动了。

另外有一个基于msysGit的图形界面工具：TortoiseGit（小乌龟），直接到官网安装就可以。

Git基本配置：

配置个人身份：
- 系统配置（适用于所有用户）：git config --system xxx
- 用户配置（适用于当前用户）：git config --global xxx
- 仓库配置（适用于当前项目）：git config --local xxx
- 配置个人身份：
  - git config --global user.name "Zhangsan"
  - git config --global user.email zhangsan123@huawei.com
文本换行符配置：
- git config --global core.autocrlf [true|input|false]
文本编码配置
- 中文编码支持：
  - git config --global gui.encoding utf-8
  - git config --global i18n.commitencoding utf-8
  - git config --global i18n.logoutputencoding utf-8
- 显示路径中的中文
  - git config --global core.quotepath false
与服务器的认证配置
- http/https协议认证：
  - 设置口令缓存：git config --global credential.helper store
  - 添加https证书信任：git config http.sslverify false
- ssh协议认证
  - 输入ssh-keygen -t rsa -C zhangsan123@huawei.com生成公钥
  - 添加公钥到代码平台：进入代码平台的settings，找到SSH Keys，把公钥文件的内容复制到Public Key中保存

Git基本命令

Git版本控制下的工程区域只有3种：

版本库：工作区中有一个隐藏目录.git，这个就是版本库，存放Git用来管理该工程的所有版本数据
工作区：日常工作的代码文件或者文档所在的文件夹
暂存区：一般放在工程根目录.git/index文件中，也叫索引index

Git版本控制下的文件状态有3种：

已提交commit
已修改modify
已暂存stage

Git常用命令如下：

# 工程准备
git init              # 在本地目录下新建项目仓库
git [lfs] clone [URL] # 克隆远端工程到本地磁盘，如果所在的项目git服务器已经支持了git-lfs，对二进制文件进行了区别管理，那么克隆工程的时候务必使用git lfs clone，否则克隆操作无法下载到工程中的二进制文件导致工程内容不完整。

# 新增、删除、移动文件到暂存区
git add [file]                      # 把文件添加到暂存区，此时还没有提交
git rm [file]                       # 将指定文件彻底从当前分支的缓存区删除，因此它从当前分支的下一个提交快照中被删除
git mv [old_file] [folder|new_file] # 用于移动文件，也可以用于重命名文件

# 查看工作区
git diff [version1] [version2]              # 比较两个节点之间的差异
git diff [branch1]..[branch2]               # 比较两个分支之间的差异
git diff --cached                           # 比较当前索引和上次提交之间的差异
git diff [branch1]..[branch2] --name-status # 比较两个分支之间的差异，只看文件列表
git status                                  # 用于显示工作目录和暂存区的状态

# 提交更改的文件
git commit            # 将暂存区里的文件改动提交到本地的版本库
git commit -am "xxx"  # 一次性提交所有在暂存区改动的文件到版本库

# 查看日志
git log

# 推送远端仓库
git push [local_branch] [remote_branch] # 在使用git commit命令将自己的修改从暂存区提交到本地版本库后，可以使用push将本地版本库的分支推送到远程服务器上对应的分支

# 分支管理
git branch                                      # 查看本地工程的所有git分支名称
git branch -r                                   # 查看远端服务器上的分支
git branch -a                                   # 查看本地和远端的所有分支
git branch [branch]                             # 新建分支（但不会切换到新分支）
git branch -d [branch]                          # 删除分支
git branch -D [branch]                          # 强制删除分支
git branch -d -r [branch]                       # 删除远端分支
git checkout [branch]                           # 切换已有分支
git checkout -b [branch]                        # 新建分支（自动切换到新分支）
git checkout -f [branch]                        # 强制切换到已有分支
git pull origin [remote_branch]:[local_branch]  # 从远端服务器中获取某个分支的更新，再与本地指定的分支进行自动合并
git pull origin [remote_branch]                 # 如果远程指定的分支和本地指定的分支相同，直接pull更新
git fetch origin [remote_branch]:[local_branch] # 从远端服务器中获取某个分支的更新，但不会进行合并操作，确认fetch内容符合预期后，再决定是否手动合并节点
git fetch origin [remote_branch]                # 如果远程指定的分支和本地指定的分支相同，fetch更新

# 分支合并
git merge [branch]  # 从指定的分支合并到当前分支的操作
git rebase [branch] # 合并目标分支到当前分支

# 撤销操作
git reset [commit_id] # 将工作区内容回退到历史提交节点
git checkout .        # 用于回退本地所有修改但未提交的内容（有风险，谨慎使用）
git checkout -[file]  # 仅回退某个文件的未提交改动

IDEA常用快捷键

快捷键	意义
alt+insert	新建
alt+上下箭头	以函数为单位移动
ctrl+g	定位到行
ctrl+w	可以选择单词继而语句继而行继而函数
ctrl+shift+w	取消选择光标所在词
shift+shift	查找任意文件
ctrl+n	查找java类
ctrl+f	查找
ctrl+r	替换
f4	进入某一方法或者到变量定义处
ctrl+f12	查看方法和成员变量
ctrl+alt+左右箭头	回退/前进到上一次编辑处
ctrl+d	复制一行
ctrl+y	删除一行
ctrl+ /	选中一段进行注释/反注释
shift+f6	重命名
ctrl+alt+m	抽取函数
ctrl+alt+v	抽取变量
ctrl+shift+f9/f10	调试/运行测试用例
ctrl+f8	打断点/取消断点
shift+f9/f10	调试/运行
f7	进入函数
f8	单步
f9	到下一个断点或者结束
alt+f8	查看表达式结果

雏鹰计划-学习启动会

Mon, 24 Mar 2025 00:00:00 GMT

为什么要有雏鹰计划

从校园到职场，编程有差异
如何提升软件能力，职业化，缩短业务期
编码基础，编码习惯clean code，写好代码的兴趣
快速上手编码，转身进入工作状态，展现自我能力

培养方案

看懂业务代码（雏鹰计划），写好代码入职前2-3月
软件范式培养5月
软件高手、专家3年

雏鹰计划安排

线上宣讲3.12
启动报名3.12
学习，建立学习班集体（当周）
定期组织，集中辅导（定期组织）
结班典礼，总结，收获分享，学习之星揭晓，入职后培养体系介绍（5月底）

3+1模式开展学习活动

班长+导师（固定群内解答问题，每周半天）+班主任+新员工
每周周报输出：每班每周课程安排+学习内容

课程介绍

这次是5.0，多了ai赋能、软件测试

ilearning网站：软件雏鹰计划（java版）

学习安排：建议学习周期1.5月，时间60h

nce数通业务介绍+技术布局

物理世界 <-----（园区网络、广域网络、数据中心网络+网络安全）----->数字世界

top5的kpi:网络可用性、网络安全、客户满意度、运营效率、运维自动化

业务方向：围绕（智能业务变更、智能故障处置、智能体验保障、智能安全防护、智能生态集成）

架构演进：从L3架构-基于规则到 L4架构-基于知识

一脑 - Net master智能大脑
一图 - 高清数字地图
一网 - 智能网元

技术方向：

一脑智能决策：固定规则 -> 动态知识
一图数字孪生
一网软硬协同
全系统开放
CloudNative

雏鹰计划前成员分享

雏鹰计划，本人是学python和c的，专业为医学人工智能，转语言有学习成本

入职感受：

拒绝焦虑，刚工作会迷茫，担心难以胜任 -> 正常现象。一开始不会安排特别难的任务，导师制，和大牛做好联络，不要吝啬提问，工作比上学忙碌。
压力驱动，有精神物质激励
日常活动

《经营未来》精选-3

Wed, 05 Mar 2025 00:00:00 GMT

血泪

新军部筹划的”调整重、化工业投资“政策使现代集团陷入了危机。无所不为的”国保委时代“来临了。

一批从海外学成归来的经济学者，连同国内的一部分经济学家，纷纷参与到新军部经济政策的筹划活动中。他们把重、化学工业的重复投资视为韩国经济发展的障碍，主张积极改变这一经济模式。这一主张也暗合了那些试图改变国内经济格局的新军部领导人的想法。

现如今，很少有人会把多家汽车生产公司共存的局面视为重复投资、国力浪费的现象。经济有其竞争规则，竞争应以公平为基础。竞争公平规则受到保障的程度是衡量先进国家与落后国家的标准之一。

但在当时，一部分经济学家和官僚却坚持认为，只有把所有汽车制造厂融为一体同时发电设备厂也融为一体，才有利于国家经济的发展。具体说来，就是要把现代汽车、大宇汽车和亚细亚汽车合并为一家，再把电力设备领域的大宇玉浦造船厂、现代重工业，以及昌原的现代洋行（现斗山重工业）合并为一体。

对于现代集团来说，汽车与电力设备好比手心、手背，哪一个都无法割舍。现代集团对汽车产业的期望与热情是很高的，何况当时，现代汽车刚刚起步走向世界。电力设备领域也是一样。现代集团已经具备了制造原子能发电设备的能力。如果放弃这一领域，就等于放弃巨大的火力发电站与核发电站设备市场。

新军部的经济调整方案简直就像捕捉现代集团的一张阴沉的大网。但是，这一政策已经公开，留给我们的唯一选择就是作出取舍。

经过智囊团的反复研究商议，郑会长最终决定选择汽车产业，因为这个新兴产业具有无限的发展空间，虽然电力设备产业也大有可为，但其生产本身就不具有稳定性，况且即使放弃了设备生产，今后我们至少还可以参与核电厂或火力发电厂的建设工程。现在想来，郑会长的判断也依然是明智的。

内部意见统一之后，我便单枪匹马冲向了“国保委”。会谈的对象是陆军军校第17、18期出身的两位军官。他们直接让我作出选择。我说：

“在作选择之前，我想先问一下，为什么要作这种选择？虽然现在看来，重、化工业似乎存在投资过剩，但在不远的将来一定会出现供不应求。如果把具有竞争力的企业都合并起来，必然会违反市场经济的第一原则—一竞争，进而导致经济衰退。考虑到韩国经济的未来，我们认为这种投资调整本身就是有问题的。”

“这个政策是经过充分论证、研究过的，我看就没有必要在这里讨论了。你们只需要从两个当中选择一个就行。”

第一天的谈判毫无实质进展，但我能感觉到一点：“国保委”已经和现代集团的竞争对手达成了某种共识，我们成了被孤立的一方。他们一定希望我们放弃汽车、选择电力设备。不，他们或许已经内定了让现代集团选择电力设备，然后把我们往这个方向诱导。

我第三次去“国保委”的时候，会谈的军官终于摊牌了。

“你们现代集团一直侧重于重工业发展，在这个领域也有过不少投资。既然建筑是你们的主力行业，选择电力设备也就顺理成章了。”

“现代选择汽车产业。”我单刀直入。

他们一下子慌了。

接下来，他们开始强行要求我们选择电力设备。我毫不含糊地说：“现代集团从始至终不赞成合并，如果合并不可避免，那我们一定选择汽车产业。”

那些军官自然不甘心，又罗列了一大堆现代集团应该选择电力设备的理由，但我丝毫没有动摇，谈判进入了僵持阶段。这时候，他们竟然把矛头指向了我个人：

“你现在住在什么地方？”

“江南。”

“是公寓吗？ ”

“不是，独门独院，不小。”

“哼，你倒是住得宽敞。而我，就住在山顶一间连自来水都没有保障的40平米的公寓里。我们在为国家担忧的时候，你们却在一边享清福，还不肯跟政府合作，这像话吗？”

我再也坐不住了。

“两位花国家经费上军校的时候，我每天早上在梨泰院拉着平板车清理垃圾，靠勤工俭学完成了学业。你们父母送你们进高中的时候，我不但要自己赚学费，还要拼命干活养活自己。大学毕业进入公司后，还要在国外工地没日没夜地工作。1974年我们国家外汇储备几近耗尽、国家经济面临崩溃的时候，是靠我们这些海外建设者辛辛苦苦挣的美金才扛了过去。两位从军校毕业后经历过战争吗？而我，每天都要在和战争一样残酷的海外市场上打拼，每天工作18个小时，每天晚上只能睡三四个小时。”

这时，一位军官拦住我的话。

“我们也参加过战争。越南战争。”

我忍住苦笑，又接着说：

“谁说只有军人才是爱国者？我们这些企业人难道就不是爱国者吗？企业可以成为批评的对象，但无视企业作用的想法是绝对不可取的。你们住在山顶的公寓里，而我曾经在比那还要艰苦很多倍的地方生活过。作为一个大企业的社长，我住在一套大房子里有什么错吗？那套房子是公司为我方便接待外宾而盖的，如果这样也有错，难道一定要我降低自己的居住水平吗？难道这就是你们治国的目标吗？你们应该在最短的时间内，让你们这样的军人公务员也达到和我一样的富裕水准，这才是可取的目标。怎么可以要求一个靠诚实劳动富裕起来的人降低生活水平呢？”

这一次的谈判在争论中结束了。我回到公司和郑会长商量，如果这样争论下去，我们必然会被推到选择的边缘，毕竟主动权不在我们手里。

一天晚上，一个在政府部门工作的朋友托人捎来口信，说是想约我见一面。这位朋友当时正在辅助政府运作“改革”事宜，一看到我便露出担忧的神清。

“李社长，现在是非常时期，很多问题不是固执己见就能解决的。依我看，你还是同意吧。时间对你们不利啊。明天就去表态吧，这关系到现代集团的命运。”

那天晚上，我一直在揣测他找我谈话的动机。是真心为我和现代集团担心，还是站在新军部立场上诱导我呢？我竟一时难以辨别。

第二天，我向郑会长转达了那位朋友的话。郑会长看上去很疲惫。“10·26”事件后，现代集团完全是靠他的坚韧意志与斗志才经受住了各种考验。肩扛千斤担的压力可想而知。

“再努努力吧，如果实在不行，就同意吧。或许这就是大势所趋。”

郑会长把公司的印章递给我。

“会长，您这是做什么？”

“你不要有思想负担。”

“如果要盖章的话，还是请会长您亲自去吧。即使您不去，还有很多人能代表公司盖章啊。”

“这件事一直是你在处理，你就善始善终吧。”

我没再说什么，收起印章，去了“国保委”。

和往常一样，还是两条难以相交的平行线。我继续坚持我的“不可合并论”。

“如果把汽车企业捆成一个，竞争力就会降低，最终只能成为国家的负担。印度就是一个前车之鉴：他们只有一家国营汽车企业，技术开发不行，经营管理也不行，造出来的汽车款式陈旧，性能也不好，价格却贵得离谱。因为产量少，买一辆汽车要等上好几个月。没有合理竞争的弊端，局外人是很难了解的。我们国家现在看似重复投资，但事实上是经济不景气、产业化未能进入正轨所引起的。假以时日，就会体现出各个企业对出口所做的贡献。所以，还是请再考虑一下是否合并的问题。”

“李社长，你以为你是谁啊？这个政策是以海归学者所做的调查报告为依据制定的。你有什么资格在这里信口胡说？”

我暗暗对自己说，务必再坚持一下。

“我不知道那些人是以什么为根据主张合并的。那种废除合理竞争、培养垄断企业才有助于资本主义社会发展的理论，在任何一本经济学教科书上都找不到。垄断企业一开始运转可能还不错，但时间一长，就会出现无数的问题；而在健康的竞争环境中成长起来的企业，他们的前途将不可估量。如果你们现在非要无理合并，能不能解决眼前问题还是未知数，今后要想进入国际市场更是毫无希望。到时候再后悔可就晚了。”

“我们没时间听你在这儿讲课！要么同意合并，要么，请便。”

此时已是深夜。我意识到，再争论下去，也不会有什么转机。房间内的空气沉闷得让人透不过气来。

“既然我们别无选择，那就请按政府的决定盖章吧。”

我拿出郑会长的印章，放在桌上。我不能用我的手来盖这个章。

一位下属军官走上前，拿起了印章，就在落章前的一瞬间，那位高级军官一脚踏开桌子，站了起来。

“不要盖！”

他识破了我的意图。如果由他们盖章，由此产生的后果也将由他们承担。他气急败坏地看着我，又转头冲那位下属大发其火：

“你怎么搞的！”

那天半夜，我从“国保委” 出来，回到了公司。整个公司大楼，只有郑会长的办公室还亮着灯。

郑会长盯着我的脸，呆呆地看了好一会儿。

“盖了吗？”

“没盖，章在这儿。”

“啊？怎么回事？”

“我明天再详细向您汇报吧。”

郑会长又看着我的脸。

“唉，你的眼睛出血了。”

“不会吧，我没觉得有什么异样啊。”

“是出血了，去照照镜子吧。”

在会长室入口的镜子前一照，果然我的眼睛里有红色的液体。沾在手帕上是乌紫色的。这就是所谓的 “血泪＂吧！以前还以为只是文学性的修辞，没想到从自己的眼睛里流下了血泪。

我的正面对抗使 “国保委” 的汽车产业合并计划无法顺利进行，进而促成了将问题移交工商部处理的契机，合并问题也随之成为公开的争论。在工商部主待的会议上，郑周永会长更是强烈阐述了产业合并的弊端。最终，汽车产业没有走向合并之路。

假如那时真的草草合并，韩国现在的汽车产业水平或许就和印度无异了。当时被合并的电力设备产业，结果后患无穷。

奏响凯歌

1987年12月，国家电力公司开始为灵光核电站三、四期工程建设实施招标。当时，国内拥有核电站建设经验的只有现代建设和东亚建设两家公司。

核电站分为核反应堆和电力生产装置两个部分。在之前的古里核电站一、二期与月城核电站一、二期工程中，现代建设负责建造了第一部分核反应堆工程，第二部分由东亚建设公司负责建造。此后的灵光核电站一、二期工程则是由现代建设全权负责的。所以，现代建设是国内唯一一家具备建设完整的核电站经验与能力的企业。政府和现代建设就灵光核电站三、四期工程签订授意合同是最为理想的。

按照当时的情况，签订授意合同只是表示一种意向。《预算会计法》规定，大型工程不能和特定的公司签订承包合同，以防止给予特殊优惠待遇。事实上，政府不和现代建设签订核电站建设合同还有政治上的问题。由于此前政府无理介入现代集团的极东石油经营权问题，郑周永社长和第五共和国的权力层之间出现了裂痕。在这种情况下，政府自然不会让“现代”轻松过关。

就在这时，发生了一件让韩国当局进退两难的事情：美国三里岛核电站发生核物质泄漏，引起全世界对核电站安全问题的关注。没有经验的公司不能参与核电站工程建设成为一种国际共识。

韩国政府不愿把项目交给“现代”，但又不能不顾及舆论的巨大压力。于是，国家电力公司决定重新招标，并提出了新的竞标资格要求。

第一次公告的标书审查结果是，只有“现代”符合要求。国家电力公司发出第二次公告，结果还是“现代”胜出。根据法律，通过两次审定的公司，第三次就可以与之签订承包合同。

看到工程授意合同基本确定，我便去了新加坡处理公司其他事务。谁知几天后，我突然接到郑会长打来的国际长途电话。

“李社长，核电站的授意合同无效了。”

“怎么回事？”

“是副总理在刚刚召开的记者招待会上公布的。你赶紧回来处理一下……”

当时，在大部分政府主持的工程中，建设公司向政府提供政治资金是一种管理。但这次的核电站工程受到国内外普遍关注，资金猫腻难有藏身之地，政府权力层因此感到不快。

在我离开的那几天，副总理、安全企划部长等政府高层竟然找出授意合同中的漏洞，随即召开记者招待会，宣布取消与“现代”的合同，并再次进行招标。

一回国，我便直奔郑寅用副总理办公室。

“政府怎么能不和合同当事人打招呼，就单方面取消合同呢？现代建设是经过一次、两次、三次竞标，堂堂正正地拿下了这个项目。政府单方面撕毁了合同，是要负法律责任的。我们恳请政府取消这一决定，否则我们将不得不对政府提起诉讼。”

从副总理办公室出来后，我又去找国家电力公司的朴正基社长。

“如果您按照副总理的要求取消合同，那就等于承认之前和我们签订合同是错误的。您只有强烈主张和我们签订的合同是合法的，并且按原计划进行，才能证明您之前的做法是正确的。否则，单方面撕毁合同的所有责任都将由您来承担。”

朴社长处境尴尬。作为国家电力公司的社长，改变已经上报总统的决定几乎是不可能的。

下一步，我又去找动力资源部的崔昌洛部长。

“法律规定，不能以政治方式取消合法的工程合同。这次单方面撕毁与我们的合同，政府究竟是什么意思？”

崔部长似乎欲言又止。

后来，国家电力公司的朴社长向我转达了崔部长的意思：这个问题不归副总理管辖，更不是副总理应该出面处理的事情；虽然知道其中又不妥之处，但对于上面已经决定了的事情，他也不方便对外发表意见。

明白了崔部长的意思之后，我再一次走进了他的办公室。

“部长您只要肯定我的看法就行。等到合适的时机，请您再表明自己的态度吧。”

我没有必要让崔部长为难。虽然现代建设的反抗不容忽视，但政府也不会轻易改变决定。

在听了我的陈述之后，国家电力公司的朴社长主张必须深证考虑核电站建设的安全问题，并决定按照合同与现代建设合作。这自然引起了政府权力层的强烈不满，很快，他们便撤掉了朴社长的职务。接任的韩凤洙社长对此问题毫无作为。无奈之下，现代建设只得请律师做好诉讼准备，并通告了政府。诉讼对象是国家电力公司社长和动力资源部部长。

终于，崔部长来找我了：

“请你们承认政府权威。即便道理在你们一边，政府也不可能取消已经作出的决定。希望你们和东亚建设一起，再进行一次竞标。”

虽然这个提议依然违背原则，但我们决定接受。我提出一个条件：

“核电厂工程事关重大，招标不能以标书总额为准，必须以标书中的明细数据内容为准。”

明细数据内容涉及很多具体的技术指标。没有核电站建设经验的企业是不可能提供这些数据的。政府接受了我的条件。

竞标结果，灵光核电站三、四期工程项目，依然花落“现代”！

这是一项工程两次被同一家公司赢得的珍贵记录。事实上，也是第一次在政府主持的重大项目中，企业没有向政府提供政治资金。

在吸取了LNG储藏基地项目的失败教训之后，在两次起落、奋力抗争之后，我们终于奏响了嘹亮的凯歌。

《经营未来》精选-2

Mon, 24 Feb 2025 00:00:00 GMT

初生牛犊不怕虎

10月初，我第一次担任了镇海第四肥料建设工程的工地出纳。工长是一位资历颇高的技术员，和那个年代的大多数技术员一样，他没有在大学接受过系统教育，但从日本侵略时期就开始积累了丰富经验。作为不折不扣的“工地型”任务，他特别不喜欢“乳臭未干的书呆子”，当然我也被包括在内。

给职员预支款是我作为出纳的主要工作之一。职员们通常都在下午5点之后找我预支。他们忙了一天，下班后才想到我这儿来，我自然是尽我所能给予方便。但这种做法却引起了工长的不满。

“喂，5点以后还给什么预支啊？你见过哪家银行在5点以后给钱的吗？”

真是不可理喻，银行是银行，工地是工地。难道让忙得焦头烂额的技术员们在工作时间放下手里的活，到我这里来排队吗？心里虽这么想，但我不能反对，因为工长的话符合原则。

几天后的一个下午，工长找我来预支，但当时已经过了5点。

“不行！”

“什么？”

工长瞪大了眼睛。这个毛头小子竟敢公然违抗工长的命令。

“没时间跟你开玩笑，快给我，有急用！”

“5点以后是禁止现金支出的。"

”我知道，但我是工长！“

”正因为您是工长，如果您把自己定的规矩打破了，我想以后就不会有人再遵守了。所以，现在绝对不能预支！“

”你是不是疯了？太不像话了！小子，这是办公事用的，是非常紧要的事情，明白吗？“

”遵守公司纪律也是很紧要的事情！“

”是吗？呼……天啊！“

工长无可奈何地走了。在那之后，我时刻准备着接受工长地报复，但情况却出乎我的意料。后来每次我去银行办事，工长都会用他的车送我去，然后再去办他自己的事。他似乎反而更看重我了。

有一天，他突然对我说了这么一句话：

”李先生，你将来肯定会成为公司的大人物。“

12月初，公司突然通知我，要派我去泰国工地。镇海工地对我来说是一所大学校，当时国内的建筑企业对使用整套设备的工程毫无经验，不仅是我，现场所有人员都在犯错、改正的反复施行中摸索着前进的道路。这时候派我去海外，无疑是对我这段时间工作的肯定。

我将参与的芭迪雅-那拉迪瓦高速公路建设工程是韩国建筑史上的第一项海外工程。这是连接位于泰国南部、马来西亚边境的两个城市的第二条公路，全场98公里，于1965年9月30日开始国际竞标。现代建设与西德、日本、法国、意大利、荷兰等16个国家的29家公司展开竞争，最终以最低成交价拿下了这项工程。当时的成交价为522万美元，比现代建设一年的销售额还要多。

这项工程意义重大。当时连大企业都不敢做的事，竟然由”现代“这个名不见经传的中小企业做起来了。正是因为有这样的开拓精神，”现代“才会发展到如今的规模。

泰国工地的指挥部比首尔的公司总部还要庞大。我是现场最基层的出纳人员，上面有经理科长，再上面有管理部长。整个工程于1966年1月7日正式动工，但进展得很不顺利。当时在韩国，连”高速公路“这个词都比较陌生，建设装备、技术人员都是捉襟见肘。美国人看到我们从国内运来的旧设备后直摇头：”你们要是能在5年内完成这个项目，我们把姓都改了。“

为了节省劳务费，我们用了很多泰国工人，但由于语言不通和管理不善，摩擦、冲突时有发生。第一年投入了工程预算的70%，但工程进度只完成了30%。颜面尽失还是次要问题，最重要的是公司面临存亡危机。

工地内部矛盾达到白热化的那天晚上，我正在办公室里整理账簿，当时屋里还有公司雇用的两个泰国经理人员。

突然，外面一阵嘈杂，我身旁的泰国经理往窗外一看，急忙对我说：

”李先生，快跑吧！“

原来是从韩国来的工人在闹事。他们挥舞着军用短刀，把现场搞得一片狼藉。干部们闻风而逃，现场只剩下我一个不是暴徒的韩国人，泰国人留下的居然更多。

那些暴徒好像把我的办公室当成了最终目标，一阵大吼大叫地冲了过来。两位泰国经理只好躲开，办公室里只剩下我一个人。

”嘭“地一声，办公室的门被撞开了，一股浓烈的酒味扑面而来。我一看，大约有15个人，手持刀棍，喘着粗气。突然，其中一个人猛地把短刀扎在我的办公桌上。

”趁老子心情好，乖乖地把保险柜钥匙交出来。“

”不交！“

”你想死啊？“

看那架势，好像要用刀刺我的脸，我后退几步，把身体紧靠在墙上。

”不肯交钥匙？看你能撑多久！“

短刀刺向我脖子左边，我下意识地把头往右边一转，眼前一片漆黑。接着，刀又刺向右边，我赶紧把头转向左边。

一脚伸进了鬼门关，我突然想，把钥匙给他们算了。其实保险柜里只有一点零钱，而且在这种情况下即使我交出钥匙也没有人会说什么。但最终，我还是没有把钥匙交给他们。这不是出于什么使命感，只是因为我不愿屈服的本能！

”不交钥匙也行，帮我们把保险柜打开就行！“

他们看短刀的威胁不起作用，就指着保险柜让我打开。我朝保险柜挪了两三步，然后猛地把保险柜抱在胸口。

”兄弟们，揍他！“

一阵拳打脚踢……

我感觉浑身冒火似地疼痛，但还是死死地抱住保险柜。

这时，耳畔传来警车地鸣叫声，暴徒们见势不妙，一哄而散。和警察一起冲进来的职员们看到抱着保险柜几近昏迷的我，立刻明白了事态，良久沉默不语。

这件事很快传到了首尔总部。

”李明博不惜生命保住了公司保险柜。“

……

”泰国工地保险柜事件“成了我在”现代”扎根的契机。

推土机

现代建设在越南承接的新工程弥补了在泰国的亏损，从而打下了重振旗鼓的基石；在国内，也通过京釜高速公路的建设打了一场漂亮的胜仗。

京釜高速公路工程被誉为“檀君以来最伟大的历史。”这一战略计划实际上是朴正熙总统“打通国家大动脉，经济才能搞活”的信念，和郑周永社长“我们当然可以”的豪言壮语一拍即合的产物。

1968年3月，当我完成泰国高速公路工程回到国内后，郑社长决定把我派往西冰库，担任现代建设重型机械事务所的管理科长。

我一下子如坠冰窟。重机所很少有正规大学出身的职员加入，只有临时工和刚从工地回来、尚无去处的人才会被安排到那里。按说，我在国外工作了3年，虽然进行的是亏损工程的收尾工作，但毕竟还算圆满地完成了任务，回国后理应进入总部管理部或经理部，哪曾想到会被派到了那么一个不得人心的地方。

我在人们同情、担心甚至嘲讽的目光中，默默地来到了西冰库工厂。在自称“老油条”的驾驶员和维修人员当中，有好多都拥有二十多年工作经验，是早在现代建设公司创立之前，就和郑周永社长一同打造汽车服务工厂的技术老手。他们都在人称“王常务”的重机所所长金永柱常务手下工作，因此人称“王党派”。

我这个新任管理科长的”第一把火”就是要改变这些”王党派“的旧观念和工作态度。在重机领域工作的人都习惯于使用日本式的配件术语，如果碰到大学刚毕业、熟记英语术语的年轻技术员，连沟通都成了问题。

我把新旧两派召集到一起。

”我们现在使用的不是美8军留下的古董，而是最新的进口设备，以后我们也会越来越多地向美国公司订购配件。如果把differential gear（差动齿轮）说成‘代5（Dae Woo.gear的日式外来韩语）’，谁能听得懂呢？只记住配件名称还不够，每个配件上标注的固定编号也要一并记住，因为只凭名称是没法区分规格和生产厂家的。所以，今后申请配件的时候，务必先看好手册中的编号。如果像以前那样光说‘要代5’，我是不会批的。“

为了掌握配件的名称和编号，”王党派”开始经常请教那些年轻技工，工厂的氛围有了很大改变。

当时，重机事务所的一个重要任务就是支持京釜高速公路建设，因此需要更严格的纪律和紧迫感。我把上班时间从7点提前到了6点。无论男女老少，所有人一律6点在运动场集合，做10分钟体操，再围着西冰库工厂跑20分钟，以良好的精神状态投入工作。休息时间禁止打牌、下棋，即便是星期六下午，我也不允许在工作场所存在松懈的工作态度。

老员工们虽然嘴上嘟囔着“没赶上好时候啊，遇到这么个年轻家伙，真是活受罪”，但行动上还是遵守规定的；可女员工们不干了。

“6点上班对我们女员工来说太难了。男的只要洗漱一下就可以出门，可我们光是化妆就得要30分钟。请让我们比男的晚上班30分钟吧。”

我不能动摇。

“男员工晚上九十点钟才下班，而你们一般七八点就可以回家。你们可以利用晚上的富余时间，化好妆再睡觉嘛。早上起来刷一下牙就可以出门了。”

女员工们气坏了，但也无可奈何。按现在来说，这简直不成体统，但我们那一代正是靠着这样的努力才战胜了贫穷。

京釜高速公路工程是韩国建筑业的转折点。在那之后，使用机械设备进行建设施工受到认可；于是，重机所的作用也变得越来越重要。如果不能及时提供设备，工程进度就会受到影响。

郑社长每天都会打好几次电话来催促设备维修工作。他对设备的名称、性能、配件了如指掌，而我作为管理科长却完全摸不着头脑，也就免不了要被电话那头的郑社长一顿痛斥。

不仅仅在电话里，有时候郑社长会“从天而降”，冲我们大发脾气：“工地上因为没有设备而停工，你们重机所到底在干吗呢！”

有一天，我又被训斥了一顿。那天晚上，我把一台因无法及时修理而未能送到工地的D8型推土机，以及一台构造相似的HD16型推土机全部拆开。大家都骂我疯了，因为那是需要紧急修理后马上送往工地的。我打开说明书，熟记每一个配件的名称和功能，然后再重新组装起来。

我为什么要拆推土机？因为我知道，掌握了设备，才能掌握人。从性格来说，我也绝对不能忍受让难题来束缚和压制我。

我不仅用这股“疯劲”征服了推土机，后来还用推土机推掉了一个“青瓦台的指示”。

当时，我们的西冰库工厂旁边有家生产建材的企业共荣社。因为粉尘问题，两家公司发生了纠纷。机械和粉尘是水火不容的。我们的重型设备随时都要和粉尘做斗争。经过交涉，他们答应安装粉尘设备，但却迟迟不见行动。

一天，我又给他们的负责人打电话，要求他们遵守约定。但一直到那天晚上他们也没有采取相应措施，反而加班加点“制造”粉尘。我打电话提出强烈抗议。对方理直气壮地说：

“青瓦台让我们供应混凝土搅拌车，没办法，只能24小时开工。”

“那是你们和青瓦台的事，你们必须遵守和我们的约定！”

“和你们的约定算什么？青瓦台的指示谁敢违抗？”

我大为光火，发出最后通牒：

“我们等到今晚12点。如果你们再不采取措施，明天早上你们就别想干活了。”

到第二天早上，他们还是一点动静都没有。我跳上推土机，一路开过去，在他们卡车出入的道路上挖了一道深沟。对方急红了眼，让我们把道路恢复原样，我说不能服从。这时，青瓦台直接打来了电话，我依然没有让步。

“道路能不能恢复取决于他们。因为他们不遵守和我们的约定，才发生了这种事，所以请青瓦台不要干预。我不知道他们的交货情况有多么紧迫，但如果我们的设备不能按时维修，高速公路工程将会受到严重影响。”

到了晚上，那家企业终于低头让步。

把道路恢复原样后，我接到了现代总部打来的谴责电话。

“为什么没有请示总部，惹出那样的祸来？”

“既然是在现场出现的问题，当然该由我负责处理。如果请示总部，总部怎么跟青瓦台对抗啊？”

这回，总部也无话可说了。据说后来，青瓦台的重要人物给现代总部的高层打电话问：

“你们那位管理科长到底是什么人？怎么做出那种事来？”

我们这边只好一阵敷衍：

”是个只知道原则的年轻科长，还不懂人情世故，请多多谅解吧。“

家庭与财产

在我还是现代公司的一名小职员时，贫穷依然伴随着我。能拥有一间小屋已经是奢侈的想法，更不用说结婚、成家了。随着职位不断上升，在我28岁成为“前途无量”的理事之后，有人开始为我做媒了，介绍的对象大多是有钱人家的女儿，或者政治世家的千金，也有演艺界的漂亮女明星。

但事实上，我内心里并没有人们想象的那种优越感，富贵名媛对我来说反而是一种负担。

有一天，在浦项念高中时的一位英语老师把他朋友的妹妹介绍给了我。她不是有钱人家的女儿，父母都是清廉的公职人员，这一层就已经让我对她产生了好感。1970年我们见面的时候，她刚从梨花女子大学毕业。据说她在学校时，还曾被选为校花。但在我眼里，她并不是那种特别漂亮、出挑的女孩，而是一个心底善良的姑娘。由于工作繁忙，我几乎没有和她好好约会过。即使偶尔约了她，也总是“迟到早退”。有几次忙得脱不开身，只好打电话到约定的咖啡厅，让她换到饭店，然后还是不能按时去，只能让她自己吃饭。有时候让她等得太晚，只好让公司的司机替我把她送回家。

在举行订婚仪式的那天，我也是因为有紧急事务要处理，仪式一结束便扔下她，直奔公司。据说那天，妻子的很多朋友还在那里议论：

“怎么嫁了个这么丑的男人？”

曾经的校花嫁了我这么个“难看的复合体”，也难怪他们会这么说。

结婚后，我们用朋友们送的结婚礼金，在麻浦租了一间十几坪的月租房。每隔半年，房东就要求提高租金，所以3年内我们搬了8次家。第二次搬家的时候还带着全部的行李；但从第三次搬家开始，就只带走些生活必需品；到第七次，只拿了碗筷就离开了。有时候我甚至忘记已经搬了家，下班后又回到原来的住处。

妻子从我还是穷小子的时候起，就和我一同为生活奋斗，是与我患难与共的“糟糠之妻”；但有那么一段时间，她竟然被误认为是我的“情人”。

事情是这样的：当时我们住在由公司提供的狎鸥亭洞“现代公寓”。我经常一大早就出门，夜里很晚才回到家，邻居们很少看到我，只见过我妻子。因为我当时已经担任现代建设的社长，人们猜测我至少有50多岁，我的夫人当然就该是40多岁的中年妇女。但事实上，我妻子当时才29岁。

当她带着小女儿去市场买东西时，有人就说：“瞧，那是现代公司的社长夫人”。“不会吧？社长夫人怎么可能这么年轻！”一来二去，这些话就被传成了“现代公司的社长和年轻情人生活在一起”，真是让人哭笑不得。

我的家庭完全是妻子一个人在操持。三个女儿和一个儿子出生的时候，我一次都没有守在妻子身边。因为工作忙，和家人在一起的时间实在太少了。我一直觉得自己不是一个好爸爸，很少为孩子们做些什么，到国外出差也没有给他们买过什么礼物，顶多带回来飞机上赠送的洗漱用品什么的。孩子们小的时候，都以为那是爸爸特意从国外带回来的好东西，长大后才发现全然不是那么回事。

但即便如此，我的孩子们依然会说：“爸爸是最关心我们的人。”这不是孩子们说的“假话”，而是我为人之父的“秘诀”所起的作用吧。我的秘诀就是通过妻子了解孩子们的作息安排。比如，孩子们考试、演出或野游的日期、内容都要向妻子问清楚，还有做些笔记。

“我是爸爸，我现在在新加坡。这里正下着雨呢，家里呢？”

就这样，先聊聊天气，然后再问考试之类的情况。

“今天考试顺利吗？是不是考语文、数学、物理这三门？”

“啊？！爸爸你怎么知道的？”

我边笑边看笔记：

“明天要考英语和历史吧？”

这样，孩子们就会想，“爸爸多关心我啊！”

就像我记住孩子们的日常生活一样，我也完全向孩子们公开我的生活。如果孩子们知道父母在什么地方、做些什么，这样的家庭往往不需要过多地为孩子操心。父母的言传身教是对孩子最好的帮助。

在我担任现代公司社长的时候，曾经参加过一个谈话节目。当时社会上对公开公职者的财产十分关注。我在节目中强调说，社会舆论支持的不应是“清贫论”，而应是“清富论”。这番谈话引起了不小的波澜。

财产的多少并不是问题的关键。如果积累的方式不正当，即使很少的一点财产也是不正当的财产；反之，如果方式政党，凭智慧与勤劳致富，财产很多也是合情合理。当然，通过不正当方法致富的一些企业和个人是需要反对和查办的。

我们韩国有句俗话：像狗一样挣钱，像宰相一样花钱。我认为现在应该是”像宰相一样挣钱，也像宰相一样花钱“。干净合法地挣钱，正大光明地花钱，这才是健康地社会。

《经营未来》精选-1

Sat, 22 Feb 2025 00:00:00 GMT

前言

自小就有的梦想，一生都在我心中澎湃；

我喜欢冒险与挑战所带来的热情与振奋，我一直梦想社会安定、经济安乐以及透过文化而获得快乐的”幸福世界“。

我要成为”自己的主人“、”良心的主人”和“事业的主人”。

从一个清理垃圾卖苦力的工读学生，到敢于迎接挑战的学生会主席，到军事政权的反抗者，到打工者，到职业经理人，到首尔市长，到当选总统，是贫困教会了我善于学习、教会了我冷静地思考人生和社会地意义；迫使我执意进取，直面挑战，勇于变革；更让我懂得了把握未来、经营未来的重要。

人必有所守护，方能有所坚持。我贯彻一生要为国民幸福坚持奋力拼搏；我愿意在任何危机、挑战面前，毅然迎上前去；我坚持再苦、再难也要堂堂正正地做人。这是在经历了艰难的成长、求学、事业开拓之后，珍藏于内心的一个坚定信念。

李明博
2008年2月

妈妈，请让我上高中吧！

在我即将从浦项中学毕业的时候，家里的处境更加困难了。大哥已经参军，二哥从同志商业高中毕业后考上了一所免学费的陆军军官学校，但因为身体原因退了学，只得重新准备考大学。我知道家里根本没钱供我继续念高中，便把升学的念头抛在一边。但是，我们的班主任却无论如何也不想放弃我。

毕业前，学校召开了升学讨论会。按照已往的情况，浦项中学的优秀毕业生都能进入庆北高中等名校。班主任认为，成绩一直名列全校第二的我肯定能考入好学校，因此让我的家长务必去一趟学校，商量我的升学问题。那时候，母亲刚开始卖红豆烤饼，从一大早忙到大半夜，根本没有时间来学校。在她看来，拼命赚钱为二哥筹学费是第一要紧的事。

但我还是抱着提一下的想法，向母亲传达了班主任的意思。母亲默默地做着红豆烤饼，好一会，她看着远方对我说：

“咱们家这个情况，你是不可能上高中的。如果你二哥落榜了，你还可以去试一试。如果一定要上高中，那也只能上免学费的邮政高中。可一要是一走，谁帮我做这个生意啊？我一个人可忙不过来。”

虽然早知道结果，可听母亲这么一字一句说出来，泪水还是忍不住在眼眶里打转。

班主任知道我家的情况后，又给我出了一个主意：

“你不上高中的话，真是太可惜了……对了，浦项同志商业高中有个夜校。你可以白天帮家里干活，晚上再去念书。你现在还小，可能不知道，以后要找工作的话，高中毕业证可比初中毕业证有用多了。”

我满怀期望地跟母亲说了班主任的建议，可母亲还是不同意。

“你得帮我做生意，帮哥哥挣学费。生意做得好，也一样可以过上好日子。再说，上夜校也是要钱的，我们家可实在拿不出你的学费啊。”

好心的班主任还在执著地跟母亲进行“攻防持久战”。两边传话的我也累得够呛。

“全部课程都拿第一的学生可以免学费，我相信明博可以做到。”

终于，班主任的最后一个提议被母亲接受了。

“这样的话，咱们做个约定好了。我同意你去上夜校，但前提是不用家里出学费。只能靠你自己努力了。”

因为这个约定，我一直读到了高中毕业。三年夜校，我每门课的成绩都是第一名。

上高中后，我开始随着季节变化做买卖：春天卖麦芽糖，夏天卖冰棍儿，冬天卖爆米花儿。

不管晴天下雨，我总穿着同一件校服，因为穿得出门的衣服就这么一件。我做买卖的那条街上总有许多女校学生来来往往，我的破旧校服、脏兮兮的脸、低着头傻乎乎的样子都成了她们取笑的对象。我不停地对自己说要泰然处之，但强烈的自尊心，加上内向的性格、青春期的焦虑，我又如何做到泰然处之？

思来想去，只好拿顶草帽一遮了事。

到高二时，我决定尝试着做水果生意，一来赚钱比较多，二来也可以躲避那些女生的异样眼光。我白天去市场进水果，晚上放学后推到热闹的剧院门口去卖。刚开始颇有些紧张。我把水果擦得亮亮的，还准备了一盏炭化灯。有一天夜里下着雨，路上行人不多。我正巴巴地盯着剧院门口，盼望电影散场后能有人光顾我的水果摊，突然，有辆小汽车在倒车时撞倒了我的推车，车上的水果咕噜噜撒了一地，几个西瓜都摔烂了。我连忙冲过去捡我的水果，这时，一个声音冲我骂了起来：

“喂，臭小子，推车就好好推，干吗停在中间拦道？你以为这路时你们家的吗？”

我一时慌了神，赶紧向他道歉；可等到那车开走以后，我突然觉得很愤怒。其实我做错了什么了呢？这样被人欺负，感觉真窝囊。想到贫穷带来的屈辱，悲伤、委屈、愤怒一股脑儿涌上心头。

“这么活着有什么意思？就算高中毕业又能怎样？干脆离开这个鬼地方算了！”

这么恨恨地想着，掏出口袋里地钱数了数，足够去首尔地路费了。我偷偷擦干眼泪，走进了路边的小吃摊，想在出发前喝点酒。

“大婶，给我一瓶烧酒，一碟小菜！”我大声喊道。

“今天这孩子怎么了？”

一向看我很乖的大婶吃了一惊。

“快点上酒啊，怎么这么多话！给你钱就是了。”

我开始发脾气，可大婶还是磨磨蹭蹭地没给我拿酒。就在等待地几秒钟里，我突然想起一件事：

”卖了这么长时间地水果，还没有让妈妈尝过我的水果呢。“

每次我从市场进水果回来，母亲总是一边擦着水果，一边说：”这些水果真漂亮啊，一看就知道很好吃。“但是把这些都视为独立财产地我，抱着即使一分钱也要节约的心，总是假装没有听见母亲的话。

”是啊，又不是非要今天走。水果虽然撞烂了，但还是可以让妈妈好好吃个够。那就明天再走吧，晚一天也没关系。“这么打定了主意，我把水果重新装上车，推回了家。

”爸，妈，今天吃点水果吧，剩了很多呢。“

母亲看见被撞歪的拖车和摔碎的西瓜，还有我夸张的喊声，大约知道了发生的事情。她一句话也没说，转身进了被窝。那天夜里我躺在睡铺上，满脑子想的都是离家出走。

第二天清晨，母亲照例开始起到，但那一天，她给我的祈祷格外地长，似乎她也一夜没睡好。

”祈求上帝为我们家明博指引一条光明的路，让他健康成长，让他做每一件事都顺顺利利……“

母亲的祈祷撞击着我的心。”原来，母亲是这样地关心着我啊！“感激地心情促使我将离家出走地计划又推迟了一个月。这样反复几次之后，我又恢复成了原先那个穿着校服、买水果的我。

蜕变

我在戒严司令部受到盘问。为了要我交代他们需要的情况，他们用各种方法胁迫我，用得最多的是不让我睡觉。

“小子，我们可以把你塞进冷冻室，也可以把你扔进海里，如果你不想‘意外死亡’，最好乖乖交代！”

我始终咬紧牙关。我得遵守诺言。

审判时我们被转到了地方法庭。出庭时，在野党的政界人士以及宗教界、法律界、文化界人士，还有学生都给予了我们坚定的支持。我们仿佛成了英雄。

最终，和其他“主谋者”差不多，我被判处5年有期徒刑，关押在西大门监狱。我所在的牢房里有杀人犯、强奸犯、诈骗犯等等，平时这些人都以讲述自己的“传奇故事”打发时间。学生罪犯则把监狱当做另外一片斗争天地开展绝食运动。进行反专制斗争的人也想通过把我们捧成英雄来突破当时的斗争困境。但说实话，我始终觉得我们所做的一切，与那些独立斗士、爱国志士相比，根本算不了什么。这只是年轻一代应当为国家所尽的义务，不能将其夸大为英雄主义。

我突然明白了自己在狱中应该做些什么：作为学生，我要把这段时间落下的功课补回来。我一边拼命读书，一边开始冷静地思考人生和社会的意义。

西大门的监狱生活从1964年6月末开始，于10月末结束。法院改判我3年有期徒刑，缓期5年执行。如今回头看，这段生活对我而言，不啻为一种幸运。我在监狱中学会了乐观。在那以前，我一直以为自己生活在最底层、经历过无可比拟的绝望。但是在狱中，我懂得了所谓悲观与乐观都是相对的。在监狱外的人看来，被囚禁之人都是极端悲惨的；但对死刑犯而言，只要活着就是莫大的幸福。艰苦的狱中生活还让我领悟到了人身上潜在的超强的适应能力。刚开始，每天早上分到的水连湿手都不够；一个月后，用那点水完全可以洗手、洗脸。

从当选学生会主席，到逃亡、坐牢，这一年的经历让我从幼虫蜕变成了长着翅膀的成虫！

出狱后，我发现自己一下子成了名人。

有一天，我突然收到从外婆家寄来的一箱苹果。箱子上的收件人地址让我永远难忘：

“首尔市龙山区，李明博收”

因为穷困，我们几乎和外婆家没什么联系。怎么突然出现这么一箱苹果呢？后来才知道，在看到我被释放的报道后，外婆她们想寄些苹果来慰问，可又不知道详细地址，只大约记得我们在首尔龙山的某个地方。这箱地址不详的苹果居然能顺利到达我家，可见我当时多么有名了。

但这时，母亲的身体因过度操劳，完全垮了。

从日本回来后的二十多年里，母亲没有睡过一天安稳觉，身体自然每况愈下。我在监狱的时候，母亲来探望我一次。我一看到母亲就知道她病得不轻，可她却努力装出不要紧的样子。那天，母亲直视我的眼睛，说：

“明博，我一直以为你是个不起眼的小东西，现在才发现，你才是真正了不起的家伙。你的想法是对的，以后就按照自己的信念去做吧，我会为你祈祷的。”

这是母亲第一次，也是最后一次肯定我。

等到我出狱的时候，母亲已经卧床不起。那年的12月15日，母亲永远地离开了我们。

父亲在京畿道利川度过了他的余生。大哥为父亲准备了一个小农场，父亲一到农场就把母亲移葬过去，并亲自为母亲立了碑铭：

“你千辛万苦把孩子们拉扯大，却没能看到孩子们成功，留下我一人享尽天伦，实在让我惭愧。”

父亲是在1981年我当现代建设社长地时候去世地。和母亲一样，都是在12月。

JS Introductory Basics

Fri, 21 Feb 2025 00:00:00 GMT

JavaScript是一种轻量级、解释型、面向对象的脚本语言。它主要用于网页开发，能够在网页上实现动态效果，增强用户与网页的交互体验。

作为一种客户端脚本语言，JS可以直接嵌入HTML，并在浏览器中执行，使得网页不再是静态的，而是可以根据用户操作动态变化。

JavaScript的应用场景

JavaScript 主要用于以下几个方面：

客户端脚本：在浏览器端执行，实现动态效果和用户交互。
网页开发：与HTML和CSS结合，使网页更具交互性和动态性。
后端开发：通过Node.js，JavaScript也可以在服务器端运行，实现后端应用开发。

示例代码：

console.log("Hello JavaScript!");

JavaScript基础语法

变量声明

var x;                  // 变量，具有函数作用域
let y = 5;              // 变量，具有块级作用域，更安全灵活
const pi = 3.14;        // 常量
console.log(x, y, pi);  // 输出: undefined 5 3.14 (undefined表示已被声明但未赋值)

let name = 'lllirunze';
console.log(name);

let empty_value = null;
console.log(empty_value); // 输出: null，表示明确为空

条件判断与循环

if (condition1) {
    // code
} else if (condition2) {
    // code
} else {
    alert("error: xxx");
}

for (let i = 0; i < 10; i++) {
    console.log(i);
}

let count = 1;
while (count <= 10) {
    console.log(count);
    count++;
}

// break语句用于终止循环
// continue语句用于跳过当前循环的剩余部分，直接进入下一次循环

函数

function functionName(param1, param2) { 
    return param1 + param2;
}

let result = functionName(3, 5);
console.log(result); // 输出: 8

变量作用域

let global_var = 'global variable';
function localVarFunction() {
    let local_var = 'local variable';
    console.log('global variable:' + global_var);
    console.log('local  variable:' + local_var);
}

localVarFunction();

事件（Events）

事件是文档或浏览器窗口中发生的特定瞬间，例如：

onClick：点击事件
onMouseOver：鼠标悬停
onMouseOut：鼠标移出
onChange：文本内容改变
onSelect：文本框选中
onFocus：输入框获得焦点
onBlur：输入框失去焦点

JavaScript绑定事件有三种方式：

HTML属性方式
DOM属性方式
addEventListener 方式

<script>
    function clickEvent() {
        alert('点击事件触发了');
    }
    function focusEvent() {
        console.log('获取焦点');
    }
    function blurEvent() {
        console.log('失去焦点');
    }
</script>

<button onclick="clickEvent()">click button</button>
<input type="text" onfocus="focusEvent()" onblur="blurEvent()">

文档对象模型（DOM）

当网页被加载时，浏览器会创建DOM，将HTML结构解析为树形结构。DOM提供了一个编程接口，允许开发者通过JavaScript操作网页元素。

获取DOM元素

var elementById = document.getElementById('box1');                // 通过 id 获取元素
var elementByClass = document.getElementsByClassName("box2")[0];  // 通过 class 获取元素
var elementByTag = document.getElementsByTagName('div');          // 通过标签名获取元素

修改元素内容

elementById.innerHTML = 'edit html content';  // 解析HTML
elementByClass.innerText = 'edit text';       // 仅修改文本
elementByTag.style.color = 'red';             // 修改元素样式

绑定事件

var buttonElement = document.getElementsByTagName('button')[0];

// 方式1：直接绑定onclick事件
buttonElement.onclick = function() {
    alert('Click events triggered by DOM.');
};

// 方式2：使用addEventListener绑定事件
buttonElement.addEventListener('click', function() {
    alert('Trigger the click event by addEventListener.');
});

:::note[Reference]

3小时前端入门教程（HTML+CSS+JS） :::

Python Crawler

Thu, 13 Feb 2025 00:00:00 GMT

什么是爬虫？

Python爬虫是一种利用Python编程语言编写的程序，目的是从互联网上自动获取信息。这些信息可以是网页内容、图片、视频或者其他类型的数据。Python爬虫通过模拟浏览器的行为，访问网页并提取所需的数据，然后将数据保存或进一步处理，以供后续分析或使用。常见的Python爬虫库包括Beautiful Soup和Scrapy等，它们使得爬取网页数据变得更加高效和方便。

爬虫分几步？

获取网页原始内容
解析网页内容
根据需求来储存或分析数据

爬虫需要注意一些事项：

不要爬取公民隐私数据
不要爬取受著作权保护的内容
不要爬取涉及到country事务，建设等
爬虫的请求数量和频率不要过高
网站如果存在反爬限制，请不要强行爬取
可以通过查看网站的robots.txt文件，了解可爬取的网页路径范围，该文件指明了哪些网页允许被爬取

{% note red fa-triangle-exclamation %}请遵守以上内容，这样可以更好更礼貌地使用python爬虫。{% endnote %}

HTTP请求和响应

HTTP请求和响应是Web开发中非常重要的概念，用于客户端（例如浏览器）和服务器之间的通信。

HTTP有不同的请求方法，常见的有：

GET：获得数据
POST：创建数据
...

HTTP请求由三部分组成：

请求行：包含方法类型，资源路径和协议版本
请求头：包含关于请求的元数据，如内容类型、认证信息等
请求体：对于某些请求方法（如POST），可能包含发送到服务器的数据，比如表单数据或JSON数据

HTTP响应由三部分组成：

状态行：指示服务器对请求的处理结果，如200表示成功，404表示未找到请求的资源等
响应头：包含关于响应的元数据，如内容类型、缓存控制信息等
响应体：包含实际请求的数据，如HTML文档、JSON数据或者其他类型的内容

如何用Python Requests发送请求？

首先打开终端，安装相关库，输入如下指令即可安装成功。

pip install requests

我们输入如下内容，进行对某网站http请求，得到如下结果。

import requests

headers = {
  "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
}

response = requests.get("http://lllirunze.cn/", headers=headers)
print(response)

<Response [200]>

如果我们print(response.text)的话，会输出该页面的html代码，看起来会比较复杂。

在进行爬取的时候，建议添加一些headers内容，使用它的目的是为了模拟浏览器发送请求，这样可以让请求看起来像是通过正常浏览器发出的，而不是由脚本或爬虫发出的。这对于一些反爬虫机制可能会有所帮助，避免被网站认为是机器人访问，从而减少被封禁或限制访问的风险。

HTML网页结构

HTML网页结构是用来定义网页内容的语言，它通过标签tags来组织和显示文本、图像、链接等信息。一个HTML网页通常由多个元素组成，这些元素按照一定的规则嵌套在一起，形成页面的结构。

可以看前文。

如何用Beautiful Soup解析HTML内容？

首先在终端输入指令安装对应库。

pip install bs4

以爬取Books to Scrape所有书名为例，通过在该网站点击F12，我们可以找到所有书名对应的代码块为h3标签，因此我们可以使用如下代码即可爬取到该网页的书名。

import requests
from bs4 import BeautifulSoup

headers = {
  "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
}

content = requests.get("https://books.toscrape.com/", headers=headers).text
soup = BeautifulSoup(content, "html.parser")
all_titles = soup.findAll("h3")

for title in all_titles:
  link = title.find("a")
  print(link.string)

:::note[Reference]

What is Neofetch?

Sat, 08 Feb 2025 00:00:00 GMT

Neofetch是一款用 bash 3.2+ 编写的命令行系统信息工具。Neofetch能以美观、视觉愉悦的方式显示操作系统、软件和硬件的相关信息。用户可以快速查看关于操作系统、内核版本、桌面环境、硬件配置等的详细信息。

Neofetch的主要特点

跨平台支持：Neofetch支持Linux、macOS和Windows（通过WSL）等多种操作系统。
美观的输出：Neofetch在终端中以整洁且富有美感的方式展示系统信息，包含了诸如操作系统名称、内核版本、CPU、内存、磁盘等信息，还会显示一个彩色的操作系统logo。
高度可定制：用户可以根据自己的需求来定制Neofetch输出的信息，甚至可以修改显示的顺序和颜色主题。
轻量化设计：Neofetch是一个非常轻量的工具，启动速度极快，占用的系统资源非常低，非常适合在资源有限的环境中使用。

Neofetch显示的信息内容

默认情况下，Neofetch会显示以下系统信息：

操作系统名称及其版本
内核版本
当前的桌面环境或窗口管理器
CPU 型号及其核心数
其他

如何使用Neofetch

以Ubuntu Linux为例，使用如下命令进行安装。

sudo apt-get update
sudo apt-get install neofetch

安装完毕之后，直接在终端中输入neofetch的命令就可以了。

如果我们希望在进入终端的时候直接获得Neofetch的信息，我们可以进行如下配置：

# 打开配置文件
vim ~/.bashrc
# 在文件的最后一行添加如下信息：
neofetch
# 保存并退出之后，使修改生效
source ~/.bashrc

重启进入终端就可以直接获取Neofetch的信息了。

:::note[Reference]

neofetch :::

TJU Course Sharing Project

Wed, 05 Feb 2025 00:00:00 GMT

:::tip 感谢项目作者superpung。 :::

随着大学学习的深入，我们往往会面临课程资料的收集与整理问题。从选课到复习，从课程资料到历年试卷，所有这些内容都需要花费大量的时间与精力去查找和整理。为了帮助更多的同学们减少这种重复劳动、提高学习效率，天津大学课程共享计划应运而生。

天津大学课程共享计划，灵感来源于浙江大学课程攻略共享计划，旨在通过一个集中平台，收集并分享天津大学的各类课程资料和经验，打破传统的依赖学长学姐口口相传的方式，让所有学生能够便捷地访问有用的学习资源。

项目背景

回忆大学生活，每一门课程的学习都离不开各类资料的帮助。可是在忙碌的学期中，很多同学常常因为资料散落在不同的地方而错过重要信息。天津大学课程共享计划的初衷正是解决这种信息不对称和资源不易获取的问题。通过集中管理和公开分享课程资料，让后来的学生不必再走弯路，把前人的经验传递给更多的人。

项目内容

选课攻略：提供课程选择的建议和经验，帮助同学们选择适合自己的课程。
电子版教材：包括各类课程的电子版教材，便于学习参考。
课件与作业：分享课堂上的课件、作业和实验材料。
历年试卷与复习资料：提供历年试卷和复习资料，帮助同学们备考。

天津大学课程共享计划不仅仅是一个资料共享平台，它是一个为天津大学学子提供支持的社区。通过每个学生的贡献和参与，未来平台的内容会越来越丰富，资源的质量会逐步提高，最终实现一个开放、高效和共享的学习环境。

如果你是天津大学的同学，或者对这个项目有兴趣，欢迎访问天津大学课程共享计划并贡献自己的力量！

::github{repo="superpung/TJU-CourseSharing"}

Git Guides

Fri, 31 Jan 2025 00:00:00 GMT

Git是一个分布式版本控制系统，它能够帮助我们管理代码历史记录，并且支持多人协作开发。在软件开发中，使用Git来管理版本和协作开发已经成为了标准实践。本文列举了一些常用的Git操作。

安装Git

Windows：link
Ubuntu Linux：sudo apt-get install git
CentOS Linux：sudo yum install git
MacOS：brew install git

配置Git

git config --global user.name "xxx"           # 配置用户名
git config --global user.email "xxx@xxx.xxx"  # 配置邮箱
git config --global color.ui true             # 配置颜色
git config --global core.editor vim           # 配置git使用的编辑器，以vim为例

Git常用操作

创建Git仓库

git init

克隆现有仓库

git clone git@github.com:lllirunze/lllirunze.git

查看仓库状态

git status

添加文件到暂存区

git add <file>  # (1)添加指定文件
git add .       # (2)添加所有文件

提交更改

git commit          # (1)打开指定编辑器，编写提交内容
git commit -m "xxx" # (2)直接将xxx的提交内容添加到暂存区

查看提交历史

git log

版本回退

我们通过git log找到要回退的版本后，根据对应的commit id，执行如下操作（版本号不用写全，写前几位就行了）。

git reset <commit id>

Git分支管理

查看目前所在分支

git branch

创建新分支

git branch <new branch>

切换分支

git checkout <branch>         # (1) 切换到已有分支
git checkout -b <new-branch>  # (2) 创建新分支并切换至此

合并分支

在一个分支上完成工作后，我们先切换回主分支上再进行merge操作。

git checkout <main-branch>
git merge <other-branch>

删除分支

git branch -d <branch>

远程仓库操作

在添加远程仓库之前（以GitHub为例），我们需要为本机创建SSH key，并将其粘贴到GitHub账户中。

ssh-keygen -t rsa -C "xxx@xxx.xxx"

一路回车获取默认值就行。后续我们可以在用户主目录中找到.ssh目录，里面有id_rsa和id_rsa.pub两个文件。我们将id_rsa.pub中的内容复制到GitHub的SSH密钥配置界面中即可。

:::tip GitHub主页->点击右上角头像->Settings->SSH and GPG keys->New SSH key :::

为本地添加远程仓库

git remote add origin git@github.com:lllirunze/lllirunze.git

查看当前配置的远程仓库

git remote -v

推送到远程仓库

git push <remote branch> <local branch>

一般来说，origin为远程仓库的默认名称，<local branch>是我们推送的分支名。

拉取远程仓库的最新内容

git pull origin <local branch>

删除远程仓库的链接

git remote remove origin

:::note[Reference]

NJU ICS PA1

Thu, 30 Jan 2025 00:00:00 GMT

选择实现架构：`riscv32`

单步执行

// nemu\src\monitor\sdb\sdb.c
static int cmd_si(char *args) {
  char *str = strtok(args, " ");
  if (str == NULL) cpu_exec(1);
  else {
    uint64_t step = strtoul(str, NULL, 10);
    cpu_exec(step);
  }
  return 0;
}

打印寄存器

// nemu\src\monitor\sdb\sdb.c
static int cmd_info(char *args) {
  isa_reg_display();
  return 0;
}

// nemu\src\isa\riscv32\reg.c
void isa_reg_display() {
  int reg_num = ARRLEN(cpu.gpr);
  int i;
  for (i = 0; i < reg_num; i++) {
    printf("%s\t0x%08x\t%u\n", reg_name(i), gpr(i), gpr(i));
  }
  printf("pc\t0x%08x\t%u\n", cpu.pc, cpu.pc);
}

扫描内存

先实现一个简单的版本：规定表达式expr中只能是一个十六进制数

// nemu\src\monitor\sdb\sdb.c
static int cmd_x(char *args) {
  char *str = strtok(NULL, " ");
  int N = atoi(str);
  char *expr = strtok(NULL, " ");
  expr = expr + 2;
  vaddr_t src = (vaddr_t)strtoul(expr, NULL, 16);

  int i;
  for (i = 0; i < N; i++) {
    word_t addr = vaddr_read(src + i * 4, 4);
    if (i % 4 == 0) printf("0x%08x:\t", src + i * 4);
    printf("0x%08x", addr);
    if (i % 4 == 3) printf("\n");
    else printf("\t");
  }
  if (N % 4 != 0) printf("\n");

  return 0;
}

算术表达式的词法分析

我们在实现的过程中需要注意一件事情，运算符是存在计算优先级的，可以参考link。我们调整struct rule类型的结构，添加一个变量priority。

// nemu\src\monitor\sdb\expr.c
struct rule {
  const char *regex;
  int token_type;
  int priority;
};

我们根据正则表达式对token类型添加匹配规则：

// nemu\src\monitor\sdb\expr.c
static struct rule rules[] = {
  {" +", TK_NOTYPE, 0},             // spaces
  {"\\+", '+', 4},                  // plus
  {"-", '-', 4},                    // minus OR negation
  {"\\*", '*', 3},                  // multiplication OR dereference
  {"\\/", '/', 3},                  // division
  {"\\%", '%', 3},                  // mod
  {"\\(", '(', 1},                  // left parenthesis
  {"\\)", ')', 1},                  // right parenthesis
  {"0[xX][0-9a-fA-F]+", TK_HEX, 0}, // hexadecimal number -> 0x..(0)
  {"[0-9]+", TK_DEC, 0},            // decimal number
  {"\\$(0|ra|sp|gp|tp|t[0-6]|s10|s11|s[0-9]|a[0-7]|pc)", TK_REG, 0}, // registers
  {"==", TK_EQ, 7},                 // equal
  {"!=", TK_NEQ, 7},                // not equal
  {"&&", TK_AND, 11},               // and
  {"\\|\\|", TK_OR, 12},            // or
  {"!", '!', 2},                    // not
  {"&", '&', 8},                    // bitwise and (we don't consider taking address)
  {"\\|", '|', 10},                 // bitwise or
  {"\\^", '^', 9},                  // bitwise xor
  {"~", '~', 2},                    // bitwise inversion
  {"<<", TK_SHIFTLEFT, 5},          // shift left
  {">>", TK_SHIFTRIGHT, 5},         // shift right
  {">=", TK_GEQ, 6},                // greater than or equal to
  {"<=", TK_LEQ, 6},                // less than or equal to
  {">", TK_G, 6},                   // greater than
  {"<", TK_L, 6},                   // less than
};

然后我们在制定好规则之后，通过make_token()来识别并记录token。

// nemu\src\monitor\sdb\expr.c
static bool make_token(char *e) {
  int position = 0;
  int i;
  regmatch_t pmatch;
  nr_token = 0;
  while (e[position] != '\0') {
    for (i = 0; i < NR_REGEX; i ++) {
      if (regexec(&re[i], e + position, 1, &pmatch, 0) == 0 && pmatch.rm_so == 0) {
        char *substr_start = e + position;
        int substr_len = pmatch.rm_eo;
        position += substr_len;

        if (substr_len > 32) return false;
        if (nr_token >= NR_TOKENS) return false;

        switch (rules[i].token_type) {
          case TK_NOTYPE: break;
          case ... :
            tokens[nr_token].type = rules[i].token_type;
            strncpy(tokens[nr_token].str, substr_start, substr_len);
            tokens[nr_token].priority = rules[i].priority;
            nr_token++;
            break;
          default: break;
        }
        break;
      }
    }
    if (i == NR_REGEX) return false;
  }
  return true;
}

算术表达式的递归求值

得到对应的tokens数组之后，我们就可以根据它们来进行递归求值，整体逻辑如下：

// nemu\src\monitor\sdb\expr.c
word_t eval(int left, int right, bool *success) {
  if (left > right) /* bad expression */
  else if (left == right) /* return value */
  else if (check_parentheses(left, right) == true) return eval(left+1, right-1, success);
  else {
    /* find dominate operator */
    word_t val1 = eval(left, op-1, success);
    word_t val2 = eval(op+1, right, success);
    switch(op_type) {
      case ... : /* perform calculations */
      default: /* bad expression */
    }
  }
  return 0;
}

这里有一些子函数需要进行编写。首先是判断两边括号是否能够匹配，如果匹配就计算eval(left+1, right-1, success)，否则进行后续常规计算。

// nemu\src\monitor\sdb\expr.c
bool check_parentheses(int left, int right) {
  if (tokens[left].type != '(' || tokens[right].type != ')') return false;
  int layer = 0;
  int i;
  for (i = left; i < right; i++) {
    if (tokens[i].type == '(') layer++;
    else if (tokens[i].type == ')') layer--;
    if (layer <= 0) return false;
  }
  return (layer == 1);
}

另外一个是需要找到计算式中的主运算符。这里需要注意几点：

不同类型的运算符的结合方向是不同的。例如加号+的运算方向是从左到右，而逻辑非!的运算方向是从右到左。
括号内的运算符先排除在外，暂时不能作为主运算符，例如1+(2*3)和(1+2)*3的主运算符是不同的。

因此我们可以编写如下代码：

// nemu\src\monitor\sdb\expr.c
int check_priority(int left, int right) {
  int dominate_priority = 0;
  int i;
  int layer = 0;
  for (i = left; i <= right; i++) {
    if (tokens[i].type == '(') layer++;
    else if (tokens[i].type == ')') layer--;
    if (layer != 0) continue;
    if (tokens[i].priority > dominate_priority) dominate_priority = tokens[i].priority;
  }
  return dominate_priority;
}

int find_dominate_operator(int left, int right, int pri, bool leftToRight) {
  int i;
  int layer = 0;
  if (leftToRight == false) {
    for (i = left; i <= right; i++) {
      if (tokens[i].type == '(') layer++;
      else if (tokens[i].type == ')') layer--;
      if (layer != 0) continue;
      if (tokens[i].priority == pri) return i;
    }
  }
  else {
    for (i = right; i >= left; i--) /* same steps */
  }
  return 0;
}

word_t eval(int left, int right, bool *success) {
  if (left > right) { }
  else if (left == right) { }
  else if (check_parentheses(left, right) == true) { }
  else {
    int dominate_priority = check_priority(left, right);
    bool leftToRight;
    if (dominate_priority == 2 || dominate_priority == 13 || dominate_priority == 14) leftToRight = false;
    else leftToRight = true;
    int op = find_dominate_operator(left, right, dominate_priority, leftToRight);
    int op_type = tokens[op].type;    
    switch(op_type) { /* perform calculations */ }
  }
  return 0;
}

具体的代码请移步至代码仓。

实现带有负数的算术表达式

当识别出减号的时候，我们需要判断这个符号是减号还是负号，总共有这几种条件，只要满足一条，就可以是负号。

-是第一个token
-的前一个token不是数字、寄存器或者)

// nemu\src\monitor\sdb\expr.c
case '-':
  if (nr_token != 0 && (tokens[nr_token-1].type == TK_DEC || tokens[nr_token-1].type == TK_HEX || tokens[nr_token-1].type == TK_REG || tokens[nr_token-1].type == ')')) {
    tokens[nr_token].type = '-';
    tokens[nr_token].priority = 4;
  }
  else {
    tokens[nr_token].type = TK_NEG;
    tokens[nr_token].priority = 2;
  }
  strncpy(tokens[nr_token].str, substr_start, substr_len);
  nr_token++;
  break;

负号是一个单目运算符，因此我们写下case TK_NEG: return -eval(op+1, right, success);就可以了。

除0的确切行为

// nemu\src\monitor\sdb\expr.c
switch(op_type) {
  case '/':
    val1 = eval(left, op-1, success);
    val2 = eval(op+1, right, success);
    if (val2 == 0) {
      Log("Warning: The divisor cannot be 0.");
      *success = false;
      return 0;
    }
    return val1 / val2;
}

表达式生成器

// nemu\tools\gen-expr\gen-expr.c
static inline void gen(char e) {
  int i = 0;
  while (buf[i] != '\0') i++;
  buf[i] = e;
  buf[i+1] = '\0';
  return;
}

static inline void gen_num() {
  uint32_t num = ((uint32_t) rand()) % 100;
  sprintf(buf+strlen(buf), "%d", num);
  return;
}

static inline void gen_op() {
  switch(rand() % 4) {
    case 0: gen('+'); break;
    case 1: gen('-'); break;
    case 2: gen('*'); break;
    case 3: gen('/'); break;
    default: break;
  }
}

static void gen_rand_expr() {
  char *s = buf;
  if (strlen(buf) > 0 && *(buf+strlen(buf)-1) == '/') s = buf+strlen(buf);
  int n = rand() % 3;
  switch(n) {
    case 0:  gen_num();                                  break;
    case 1:  gen('('); gen_rand_expr(); gen(')');        break;
    default: gen_rand_expr(); gen_op(); gen_rand_expr(); break;
  }

  // test division 0
  if (s != buf) {
    sprintf(code_buf, code_format, s);
    FILE *fp = fopen("/tmp/.code.c", "w");
    assert(fp != NULL);
    fputs(code_buf, fp);
    fclose(fp);

    int ret = system("gcc /tmp/.code.c -o /tmp/.expr");
    if(ret != 0) printf("ret: %d\n",ret);
		
    fp = popen("/tmp/.expr", "r");
    int result;
    fscanf(fp, "%d", &result);
    pclose(fp);

    if(result == 0){
      memset((void*)s, 0, strlen(s) * sizeof(char));
      gen_rand_expr();
    }
  }
}

在nemu\tools\gen-expr下运行make run，即可进行随机测试。

扩展表达式求值的功能

该内容已经实现，详见前文。

监视点池的管理

// nemu\src\monitor\sdb\watchpoint.c
typedef struct watchpoint {
  int NO;
  struct watchpoint *next;
  char expression[1024];
  word_t old_val;
} WP;

static WP *new_wp() {
  if (free_ == NULL) return NULL;
  WP *wp = free_;
  free_ = free_->next;
  return wp;
}

static void free_wp(WP *wp) {
  wp->next = free_;
  wp->old_val = 0;
  memset(wp->expression, 0, sizeof(wp->expression));
  free_ = wp;
  return;
}

实现监视点

我们在nemu/Kconfig中添加一个开关选项，这样在make menuconfig时可以选择是否进行difftest。

// nemu\Kconfig
menu "Testing and Debugging"

...

config WATCHPOINT
  bool "Enable watchpoints scanning"
  default n

在menuconfig中勾选监视点扫描后，我们就可以使用CONFIG_WATCHPOINT参数扫描观察点了。

// nemu\src\cpu\cpu-exec.c
static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
#ifdef CONFIG_WATCHPOINT
  if (scan_wp(_this->pc)) { nemu_state.state = NEMU_STOP; }
#endif
}

// nemu\src\monitor\sdb\watchpoint.c
bool scan_wp(vaddr_t pc) {
  bool success;
  WP *cur = head;
  while (cur != NULL) {
    success = true;
    word_t new_val = expr(cur->expression, &success);
    if (cur->old_val != new_val) return true;
    cur->old_val = new_val;
    cur = cur->next;
  }
  return false;
}

// nemu\src\monitor\sdb\watchpoint.c
bool scan_wp(vaddr_t pc) {
  bool success;
  WP *cur = head;
  while (cur != NULL) {
    success = true;
    word_t new_val = expr(cur->expression, &success);
    if (cur->old_val != new_val) return true;
    cur->old_val = new_val;
    cur = cur->next;
  }
  return false;
}

:::note[Reference]

NJU ICS PA0

Mon, 27 Jan 2025 00:00:00 GMT

前言

我在2020年秋季其实已经写过一个天津大学的NEMU实验，这是一个根据南京大学ICS-PA改编的计算机系统综合实践课程，我们写的是x86版本。但是，因为一些众所周知的原因（Ctrl-C + Ctrl-V），我其实并没有完全理解这个实验的内容（都是抄同学的），而且实验也只是进行到PA3课程就结束了。

因此我打算重新做一遍完整的NJU-ICS-PA，算是重温一下这个南上加南的实验。实验代码已放到这里。

::github{repo="lllirunze/nju-ics-pa"}

虚拟机安装Ubuntu Linux

VMware Workstation
Ubuntu
vmware安装ubuntu教程：还有很多教程，仅供参考

ps：vmware的安装网址好像和往年有所不同，大家请自行查找即可

在github上添加ssh key

ssh-keygen -t rsa -C "lirunze.me@gmail.com"

输出结果之后复制~/.ssh/id_rsa.pub里的内容之后粘贴到Github就行了。

`make menuconfig`为什么会报错

缺少了bison和flex库，在终端输入

sudo apt-get install bison
sudo apt-get install flex

:::note[Reference]

南京大学计算机科学与技术系计算机系统基础课程实验 2024 :::

CSS Introductory Basics

Sun, 26 Jan 2025 00:00:00 GMT

CSS（层叠样式表）用于定义网页的样式和布局。利用 CSS，我们可以为网页上的每个元素指定颜色、字体、大小等，从而实现对网页设计的精确控制。

CSS 语法

典型的 CSS 规则由选择符、属性和值组成：

selector {
    property1: value1;
    property2: value2;
}

一个选择器可以有多个声明。
每个声明必须以;结尾。
所有属性和值都以键值对的形式书写。

示例：

p {
    color: blue；
    font-size: 16px；
}

应用 CSS 的三种方法

内联样式：直接在 HTML 元素中使用。
内部样式表：在 HTML <head>中的<style>标记内。
外部样式表：通过 <link rel="stylesheet" href="css/style.css"> 标记链接。

这些样式的优先顺序是 内联 > 内部 > 外部。

选择器

选择器是 CSS 的重要组成部分，因为它们定义了样式将应用于哪些元素或元素组。

<style>
    h2 {
        color: aqua;
    }
    .highlight {
        background-color: yellow;
    }
    #header {
        font-size: 35px;
    }
    * { /* Universal selector */
        font-family: "KaiTi";
    }
    .father > .son { /* Child selector */
        color: yellowgreen;
    }
    .father p { /* Descendant selector */
        color: brown;
    }
    h3 + p { /* Adjacent sibling selector */
        background-color: red;
    }
    #element:hover { /* Pseudo-class selector */
        background-color: blueviolet;
    }
</style>

示例:

<h2>Element Selector</h2>
<h3 class="highlight">Class Selector</h3>
<h4 id="header">ID Selector</h4>
<div class="father">
    <p class="son">Child Element Selector Example</p>
    <div>
        <p class="grandson">Descendant Selector Example</p>
    </div>
</div>

<p>Regular p tag</p>
<h3>Adjacent Sibling Selector Example</h3>
<p>Regular p tag</p>

<h3 id="element">Pseudo-class Selector Example</h3>

CSS 属性

CSS 包含多种属性。您可以在菜鸟教程上了解更多。

<h1 style="font: bolder 50px 'KaiTi';">
    Example of the font shorthand property
</h1>

盒子模型

盒子模型在网页设计中至关重要，它由填充、边框和边距组成。

padding：元素内部、内容和边框之间的空间
border：环绕填充和内容
margin：边框周围的外部空间

<style>
    .demo {
        background: aqua;
        width: 300px;
        height: 200px;
        border-style: solid;
        border-width: 10px;
        border-color: blueviolet;
    }
</style>

<div class="demo">Content inside the box</div>

浮动

浮动允许将元素从正常的文档流中移除，并将其定位到左侧或右侧，让其他内容围绕它们流动。

selector {
    float: left | right | none;
}

定位

定位可以控制元素的位置。主要有三种定位方式

相对定位：相对于正常位置移动元素。
绝对定位：相对于位置最近的祖先移动元素。
固定定位：将元素相对于浏览器窗口定位，在滚动时保持固定。

<style>
    .box1 {
        height: 350px;
        background-color: aqua;
    }
    .box-normal {
        width: 100px;
        height: 100px;
        background-color: purple;
    }
    .box-relative {
        position: relative;
        left: 120px;
        top: 40px;
    }
    .box-absolute {
        position: absolute;
        left: 120px;
    }
    .box-fixed {
        position: fixed;
        top: 300px;
        right: 0;
    }
</style>

<h1>Relative Positioning</h1>
<div class="box1">
    <div class="box-normal"></div>
    <div class="box-relative"></div>
    <div class="box-normal"></div>
</div>

<h1>Absolute Positioning</h1>
<div class="box1">
    <div class="box-normal"></div>
    <div class="box-absolute"></div>
    <div class="box-normal"></div>
</div>

<h1>Fixed Positioning</h1>
<div class="box1">
    <div class="box-fixed"></div>
</div>

:::note[Reference]

3小时前端入门教程（HTML+CSS+JS） :::

HTML Introductory Basics

Fri, 24 Jan 2025 00:00:00 GMT

HTML（超文本标记语言）是网络开发的基础，它使我们能够在网站上构建内容。本文将介绍一些 HTML 的入门概念，包括结构、标记、属性等。

如果你有一定的编码基础（如学过 Python 等编程语言），一定能轻松理解。

必备工具

在使用 HTML 时，拥有合适的工具可以让你的开发过程更加顺利。下面是一些 HTML 开发人员必备的工具和插件（如果我们使用 VSCode）：

HTML/CSS Support
Live Server
Auto Rename Tag

HTML文档结构

HTML 文档需要遵循特定的结构。下面是一个 HTML 文档的基本示例：

<!DOCTYPE html> <!-- Declaration to tell the browser this is an HTML document -->
<html lang="en"> <!-- Root element -->
    <head>
        <!-- Contains metadata, links to stylesheets, and JavaScript files -->
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>My First HTML Page</title>
    </head>
    <body>
        <!-- Contains the visible content of the page -->
        <h1>Welcome to My Website</h1>
        <p>This is my first HTML page.</p>
    </body>
</html>

常用文本标记

HTML 提供了多种用于格式化和结构化文本的标记。下面是一些常见的文本相关元素：

<!-- Heading -->
<h1>Heading Level 1</h1>
<h2>Heading Level 2</h2>
<h3>Heading Level 3</h3>
<!-- <h4>, <h5>, <h6> work similarly for smaller headings -->

<!-- Paragraphs and Text Style -->
<p>This is a paragraph. <b>Bold text</b> and <i>italic text</i>.</p>
<p>You can also use <strong>strong emphasis</strong> and <u>underlined text</u>.</p>

<!-- Unordered List -->
<ul>
    <li>Item 1</li>
    <li>Item 2</li>
</ul>

<!-- Ordered List -->
<ol>
    <li>First item</li>
    <li>Second item</li>
</ol>

<table>
    <tr> <!-- Table row -->
        <th>Header 1</th> <!-- Table header -->
        <th>Header 2</th>
    </tr>
    <tr>
        <td>Data 1</td> <!-- Table data -->
        <td>Data 2</td>
    </tr>
    <tr>
        <td>Data 3</td>
        <td>Data 4</td>
    </tr>
</table>

HTML属性

HTML中的属性定义了元素的属性或行为。它们总是在开头标签中指定，由<name="value">组成。

class：为元素定义一个或多个类，用于CSS风格设计。
id：为元素指定一个唯一标识符。
style：元素的内联样式（不建议使用大型样式）。

<tag attribute_name="attribute_value">xxx</tag>

block、inline和inline-block

block元素通常用于组织和结构页面的主要内容。这些元素通常从新一行开始，占据其父元素的全部宽度。常见的块元素包括 <div>、<h1>、<p>、<ul>、<table> 等。

inline元素通常用于为文本添加样式或为文本的一部分应用样式。这些元素不另起一行，而是与其他内联元素一起出现。内联元素只占用其内容所需的宽度，不会强制换行。常见的内联元素包括 <span>, <a>, <img> 等。

inline-block元素结合了块级元素和内联元素的特点。它允许元素出现在同一行中，还可以设置宽度和高度属性，而内联元素不支持这些属性。

:::note[Reference]

3小时前端入门教程（HTML+CSS+JS） :::

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili