Plain Text
┌─────────────────────────────────┐
│          应用程序层              │  # 用户直接使用的软件
│    (Firefox, MySQL, Nginx)      │
├─────────────────────────────────┤
│          系统工具层              │  # Shell、核心工具集
│   (Bash, Coreutils, Systemd)    │
├─────────────────────────────────┤
│          系统调用层              │  # 用户空间与内核的接口
│        (System Calls)           │
├─────────────────────────────────┤
│           内核层                 │  # 系统核心功能
│ (进程管理、内存管理、文件系统、网络) │
├─────────────────────────────────┤
│           硬件层                 │  # 物理设备
│   (CPU、内存、磁盘、网络设备)     │
└─────────────────────────────────┘

Plain Text
// 用户空间程序通过glibc封装系统调用
#include <unistd.h>

int main() {
    // write()系统调用示例
    write(1, "Hello Linux\n", 12);  // 触发int 0x80软中断
    return 0;
}

// 内核空间系统调用处理
asmlinkage long sys_write(unsigned int fd, const char __user *buf, size_t count) {
    // 内核处理写操作
    return vfs_write(file, buf, count, &pos);
}

Plain Text
# 监控进程的系统调用
strace -p 1234                    # 跟踪特定进程
strace -e open,read,write ls      # 只监控文件操作
ltrace -p 1234                    # 跟踪库函数调用

# 系统调用统计
strace -c ls > /dev/null         # 统计系统调用次数和耗时

Plain Text
/
├── bin/     # 基本命令二进制文件 (ls, cp, mv等)
├── sbin/    # 系统管理命令 (ifconfig, fdisk等)
├── etc/     # 系统配置文件 (网络配置、服务配置等)
├── home/    # 用户主目录 (用户个人文件和配置)
│    └── username/
├── var/     # 可变数据文件 (日志、缓存、数据库文件)
│    ├── log/    # 系统日志文件
│    ├── cache/  # 应用程序缓存
│    └── lib/    # 动态数据文件
├── tmp/     # 临时文件 (重启后可能被清理)
├── usr/     # 用户程序和数据
│    ├── bin/    # 用户命令
│    ├── sbin/   # 系统管理命令
│    └── lib/    # 程序库文件
├── dev/     # 设备文件 (硬件设备接口)
├── proc/    # 进程信息虚拟文件系统
└── lib/     # 系统库文件

Plain Text
# 查看文件权限示例
$ ls -l /etc/passwd
-rw-r--r-- 1 root root 2354 Jan 15 10:30 /etc/passwd

# 权限分解说明：
# 第1位: 文件类型 (-=文件, d=目录, l=链接)
# 第2-4位: 所有者权限 (rw-：root用户可读写)
# 第5-7位: 所属组权限 (r--：root组可读)
# 第8-10位: 其他用户权限 (r--：其他用户可读)

Plain Text
# 数字方式修改权限
chmod 755 script.sh  # rwxr-xr-x
chmod 644 config.conf  # rw-r--r--

# 符号方式修改权限
chmod u+x file.sh    # 给所有者添加执行权限
chmod g-w file.txt   # 移除所属组的写权限
chmod o=r file.conf  # 设置其他用户只有读权限

# 修改文件所有者
chown user:group file.txt  # 同时修改所有者和所属组
chown user file.txt         # 只修改所有者
chgrp group file.txt        # 只修改所属组

Plain Text
# SUID：以文件所有者身份运行
chmod u+s /usr/bin/passwd   # 普通用户修改密码需要root权限

# SGID：目录中新文件继承组权限  
chmod g+s /shared_dir       # 共享目录权限控制

# Sticky Bit：只有文件所有者能删除
chmod o+t /tmp              # 防止/tmp目录下文件被他人删除

Plain Text
# 查看磁盘空间使用情况
df -h  # -h参数让显示更人类可读(human-readable)

# 输出示例：
文件系统        容量  已用  可用 已用% 挂载点
/dev/sda1        20G  8.2G   11G   44% /
/dev/sdb1       100G   25G   75G   25% /data

# 查看目录大小
du -sh /var/log/    # 查看/var/log目录总大小
du -sh *           # 查看当前目录下各文件/目录大小

# 查找大文件
find / -type f -size +100M 2>/dev/null  # 查找大于100MB的文件

Plain Text
# 物理卷管理
pvcreate /dev/sdb1          # 创建物理卷
pvdisplay                   # 显示物理卷信息

# 卷组管理  
vgcreate vg0 /dev/sdb1      # 创建卷组
vgextend vg0 /dev/sdc1      # 扩展卷组

# 逻辑卷管理
lvcreate -L 10G -n lv0 vg0  # 创建10G逻辑卷
lvextend -L +5G /dev/vg0/lv0 # 扩展逻辑卷
resize2fs /dev/vg0/lv0      # 调整文件系统大小

Plain Text
# 文件系统检查修复
fsck /dev/sda1              # 检查文件系统
e2fsck -f /dev/sda1         # 强制检查ext4文件系统

# 磁盘挂载管理
mount /dev/sdb1 /mnt/data   # 挂载磁盘
umount /mnt/data           # 卸载磁盘

# 自动挂载配置
echo "/dev/sdb1 /mnt/data ext4 defaults 0 0" >> /etc/fstab

Plain Text
# 查看进程信息
ps aux    # 查看所有进程的详细信息
ps -ef    # 另一种查看方式

# 实时监控系统资源
top       # 经典的系统监控工具
htop      # 增强版的top（需要安装）

# 查看进程树状结构
pstree    # 以树状形式显示进程关系

# 查找特定进程
ps aux | grep nginx  # 查找nginx相关进程
pgrep nginx         # 查找nginx进程ID

Plain Text
# 查看进程详细状态
cat /proc/1234/status    # 查看进程1234的详细状态
ls -l /proc/1234/fd      # 查看进程打开的文件描述符

# 进程资源限制
ulimit -a                # 查看当前shell资源限制
cat /proc/1234/limits    # 查看进程资源限制

# 进程内存映射
pmap 1234                # 查看进程内存映射情况

Plain Text
# 进程启动
nohup java -jar app.jar > app.log 2>&1 &  # 后台运行并忽略挂起信号
setsid command.sh                       # 在新的会话中运行进程

# 进程终止
kill 1234              # 优雅终止进程
kill -9 1234           # 强制终止进程（慎用）
pkill nginx            # 按进程名终止
killall nginx          # 终止所有同名进程

# 进程信号管理
kill -l                # 查看所有信号
kill -TERM 1234        # 发送TERM信号（默认）
kill -HUP 1234         # 重新加载配置（常用于守护进程）

Plain Text
# 进程优先级调整
nice -n 10 command.sh   # 低优先级运行命令
renice 10 -p 1234       # 调整已运行进程的优先级

# 实时进程调度
chrt -f 1 command.sh    # FIFO调度策略，优先级1
chrt -r 50 command.sh   # Round-Robin调度策略

# CPU亲和性设置
taskset -c 0,1 command.sh  # 绑定到CPU0和1
taskset -p 1234            # 查看进程CPU亲和性

Plain Text
# 后台进程管理
command.sh &            # 在后台运行程序
jobs                    # 查看后台作业
fg %1                   # 将作业1切换到前台
bg %1                   # 在后台继续运行作业1

# 屏幕会话管理
screen -S session_name  # 创建新会话
screen -ls              # 列出所有会话
screen -r session_name  # 恢复会话

# 更现代的替代方案：tmux
tmux new -s session_name
tmux attach -t session_name

Plain Text
# 查看网络接口信息
ifconfig               # 传统命令（部分系统已淘汰）
ip addr show           # 现代推荐命令

# 网络连接状态
netstat -tlnp         # 查看监听端口和对应进程
ss -tlnp              # 更快的替代方案（推荐）

# 路由表查看
route -n              # 传统路由查看
ip route show         # 现代路由查看

Plain Text
# 基础连通性测试
ping baidu.com                # 测试网络连通性
traceroute google.com        # 跟踪网络路径
mtr google.com               # 增强版网络诊断工具

# 端口连通性测试
telnet baidu.com 80          # TCP端口测试
nc -zv baidu.com 80          # 更现代的端口测试
nmap -p 80 baidu.com         # 端口扫描

# 网络流量分析
tcpdump -i eth0 port 80     # 捕获80端口流量
tcpdump -i eth0 host 192.168.1.1  # 捕获特定主机流量

Plain Text
# IP地址配置
ip addr show                  # 查看IP地址是否正确配置
ip route show                # 查看路由表是否正确

# ARP表检查
arp -a                       # 查看ARP缓存
ip neigh show                # 查看邻居表

Plain Text
# 端口监听检查
ss -tlnp | grep 80           # 检查80端口是否监听
netstat -tlnp | grep :22     # 检查SSH服务监听

# 防火墙规则检查
iptables -L -n              # 查看iptables规则
firewall-cmd --list-all      # 查看firewalld配置
ufw status                   # 查看UFW防火墙状态

Plain Text
# DNS解析测试
nslookup baidu.com          # DNS解析测试
dig baidu.com               # 更详细的DNS信息
host baidu.com              # 简单的DNS查询

# DNS配置检查
cat /etc/resolv.conf        # 查看DNS服务器配置
systemd-resolve --status    # 查看systemd-resolved状态

Plain Text
# 分层测试方法
ping -c 4 baidu.com         # ICMP层连通性
telnet baidu.com 80         # TCP层连通性  
curl -I https://baidu.com  # HTTP层连通性

# 路径跟踪
traceroute -T baidu.com     # TCP方式跟踪
mtr --tcp baidu.com         # 持续监控路径质量

Plain Text
#!/bin/bash
# 脚本说明：这是一个系统健康检查脚本
set -euo pipefail  # 安全设置：错误退出、未定义变量退出、管道错误退出

# 常量定义
readonly SCRIPT_NAME=$(basename "$0")
readonly LOG_FILE="/var/log/system-check.log"

# 函数定义
log_message() {
    local level="1"
    local message="2"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [level] message" | tee -a "LOG_FILE"
}

# 检查函数
check_disk_usage() {
    local usage=$(df -h / | awk 'NR==2{print5}' | sed 's/%//')
    if [ "usage" -gt 90 ]; then
        log_message "ERROR" "磁盘使用率超过90%: ${usage}%"
        return 1
    else
        log_message "INFO" "磁盘使用率正常: ${usage}%"
        return 0
    fi
}

check_memory_usage() {
    local total=$(free -m | awk 'NR==2{print2}')
    local used=$(free -m | awk 'NR==2{print3}')
    local usage=$((used * 100 / total))
    
    if [ $usage -gt 80 ]; then
        log_message "WARNING" "内存使用率较高: ${usage}%"
        return 1
    else
        log_message "INFO" "内存使用率正常: ${usage}%"
        return 0
    fi
}

# 主函数
main() {
    log_message "INFO" "开始系统健康检查"
    
    check_disk_usage
    check_memory_usage
    
    log_message "INFO" "系统检查完成"
}

# 脚本入口
if [[ $# -eq 0 ]]; then
    main
else
    echo "用法: $0"
    exit 1
fi

Plain Text
# 基础搜索
grep "error" log.txt              # 查找包含error的行
grep -v "debug" log.txt           # 查找不包含debug的行  
grep -i "error" log.txt           # 忽略大小写搜索
grep -r "pattern" /dir            # 递归搜索目录

# 高级模式
grep -E "^[0-9]{3}-[0-9]{4}" file.txt  # 正则表达式匹配
grep -A 2 -B 2 "error" log.txt    # 显示匹配行前后2行
grep -c "error" log.txt           # 统计匹配行数

Plain Text
# 字段处理
awk '{print1}' file.txt           # 打印第一列
awk -F: '{print1}' /etc/passwd    # 指定冒号为分隔符

# 条件处理
awk '/error/ {count++} END {print count}' log.txt  # 统计error出现次数
awk '3 > 100 {print0}' data.txt    # 第三列大于100的行

# 高级处理
awk 'BEGIN{FS=":"; OFS="\t"} {print1,3}' /etc/passwd  # 设置输入输出分隔符

Plain Text
# 文本替换
sed 's/old/new/g' file.txt        # 全局替换
sed 's/^#//' file.conf            # 删除行首注释符
sed -i.bak 's/old/new/g' file.txt # 原地替换并备份

# 行操作
sed -n '10,20p' file.txt          # 打印10-20行
sed '/pattern/d' file.txt         # 删除匹配行
sed '1i\插入的内容' file.txt        # 在第一行前插入

Plain Text
# 服务状态管理
systemctl status nginx           # 查看服务状态
systemctl start nginx            # 启动服务
systemctl stop nginx             # 停止服务  
systemctl restart nginx          # 重启服务
systemctl reload nginx           # 重载配置（不重启）

# 服务自启动管理
systemctl enable nginx           # 开机自启动
systemctl disable nginx          # 禁用开机自启动
systemctl is-enabled nginx       # 检查自启动状态

# 服务日志查看
journalctl -u nginx              # 查看nginx服务日志
journalctl -u nginx -f           # 实时跟踪日志
journalctl --since "1 hour ago"   # 查看1小时内的日志

Plain Text
# /etc/systemd/system/myapp.service
[Unit]
Description=My Application
After=network.target

[Service]
Type=simple
User=appuser
Group=appgroup
WorkingDirectory=/opt/myapp
ExecStart=/usr/bin/java -jar app.jar
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Plain Text
# 实时日志监控
tail -f /var/log/nginx/access.log      # 实时跟踪访问日志
tail -f /var/log/syslog               # 系统日志监控

# 日志轮转配置
cat /etc/logrotate.d/nginx           # 查看nginx日志轮转配置

# 日志分析
grep "ERROR" /var/log/app.log | wc -l  # 统计错误数量
grep "404" /var/log/nginx/access.log | awk '{print7}' | sort | uniq -c  # 统计404页面

Plain Text
# 综合监控工具
top                                # 经典系统监控
htop                               # 增强版top
glances                            # 更全面的监控工具

# 内存监控
free -h                            # 内存使用情况
vmstat 1 10                        # 虚拟内存统计

# I/O监控
iostat -x 1                        # 磁盘I/O统计
iotop                              # 磁盘I/O进程监控

Plain Text
# CPU性能分析
perf record -g command             # 记录性能数据
perf report                        # 分析性能数据

# 内存分析
valgrind --tool=memcheck program   # 内存泄漏检测
pmap -x 1234                       # 进程内存映射详情

Plain Text
# 查看当前参数
sysctl -a | grep tcp               # 查看TCP相关参数

# 临时修改
sysctl -w net.ipv4.tcp_tw_reuse=1  # 启用TIME_WAIT连接重用

# 永久修改
echo "net.ipv4.tcp_tw_reuse = 1" >> /etc/sysctl.conf
sysctl -p                          # 重新加载配置

Plain Text
# 文件系统参数调优
tune2fs -l /dev/sda1               # 查看ext4文件系统参数

# 挂载选项优化
# /etc/fstab 示例优化配置
# /dev/sda1 / ext4 noatime,data=writeback,barrier=0 1 1

Plain Text
# 用户管理
useradd -m -s /bin/bash username   # 创建用户
passwd username                    # 设置密码
usermod -L username               # 锁定用户
userdel -r username               # 删除用户及主目录

# 组管理
groupadd developers                # 创建组
usermod -aG developers username   # 添加用户到组

# sudo权限管理
visudo                             # 编辑sudoers文件

Plain Text
# SSH配置优化 /etc/ssh/sshd_config
Port 2222                          # 修改默认端口
PermitRootLogin no                # 禁止root登录
PasswordAuthentication no         # 禁用密码认证，使用密钥
MaxAuthTries 3                    # 最大尝试次数
ClientAliveInterval 300          # 客户端存活检查

Plain Text
# 清空现有规则
iptables -F
iptables -X

# 设置默认策略
iptables -P INPUT DROP
iptables -P FORWARD DROP  
iptables -P OUTPUT ACCEPT

# 允许本地回环
iptables -A INPUT -i lo -j ACCEPT

# 允许已建立的连接
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 开放SSH端口
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 保存规则
iptables-save > /etc/iptables/rules.v4

Plain Text
应用层 (命令工具) → 系统调用层 (API接口) → 内核层 (核心功能) → 硬件层 (物理资源)

Plain Text
<!-- 关键域名预解析 -->
<link rel="dns-prefetch" href="//cdn.example.com">
<link rel="dns-prefetch" href="//api.example.com">

<!-- HTTP头强制预解析 -->
<meta http-equiv="x-dns-prefetch-control" content="on">

Plain Text
# 扩大半连接队列，防DDoS攻击
echo 8192 > /proc/sys/net/ipv4/tcp_max_syn_backlog

# 启用SYN Cookie保护
echo 1 > /proc/sys/net/ipv4/tcp_syncookies

# 快速回收TIME-WAIT连接
echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse

# 调整拥塞控制算法
echo "bbr" > /proc/sys/net/ipv4/tcp_congestion_control

Plain Text
# 查看TCP连接状态
netstat -ant | grep :443

# 监控重传率（应<1%）
cat /proc/net/snmp | grep Tcp

Plain Text
server {
    listen 443 ssl http2;
    
    # 强制TLS 1.3+ 
    ssl_protocols TLSv1.3;
    
    # 现代密码套件
    ssl_ciphers TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256;
    
    # 高效椭圆曲线
    ssl_ecdh_curve X25519:secp384r1;
    
    # HSTS预加载
    add_header Strict-Transport-Security "max-age=31536000SubDomains" always;
    
    # 0-RTT优化（谨慎启用）
    ssl_early_data on;
}

Plain Text
# Let's Encrypt自动续期
certbot renew --quiet --post-hook "systemctl reload nginx"

# 证书监控告警
openssl x509 -in certificate.pem -noout -dates

Plain Text
server {
    listen 443 ssl http2;
    
    # 启用服务器推送
    location /index.html {
        http2_push /style.css;
        http2_push /app.js;
    }
    
    # 调整流控制窗口
    http2_streams 128;
    http2_window_size 1m;
    
    # 头部压缩表大小
    http2_header_buffer_size 16k;
}

Plain Text
# 静态资源强缓存
location ~* \.(css|js|png|jpg)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
}

# API接口协商缓存
location /api/ {
    add_header Cache-Control "no-cache";
    etag on;
}

Plain Text
@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    
    // ✅ GET - 查询用户列表
    @GetMapping
    public ResponseEntity<List<User>> getUsers(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "20") int size) {
        List<User> users = userService.findUsers(page, size);
        return ResponseEntity.ok(users);
    }
    
    // ✅ GET - 查询特定用户
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return user != null ? 
            ResponseEntity.ok(user) : 
            ResponseEntity.notFound().build();
    }
    
    // ✅ POST - 创建新用户
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody @Valid User user) {
        User saved = userService.create(user);
        return ResponseEntity.created(URI.create("/users/" + saved.getId()))
                           .body(saved);
    }
    
    // ✅ PUT - 全量更新用户
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, 
                                         @RequestBody @Valid User user) {
        User updated = userService.update(id, user);
        return ResponseEntity.ok(updated);
    }
    
    // ✅ DELETE - 删除用户
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

Plain Text
// 性能API监控
const [navigation] = performance.getEntriesByType("navigation");
console.log('DNS查询:', navigation.domainLookupEnd - navigation.domainLookupStart);
console.log('TCP连接:', navigation.connectEnd - navigation.connectStart);
console.log('TLS握手:', navigation.requestStart - navigation.secureConnectionStart);
console.log('TTFB:', navigation.responseStart - navigation.requestStart);

Plain Text
<!-- 关键资源预加载 -->
<link rel="preconnect" href="https://cdn.example.com">
<link rel="dns-prefetch" href="//api.example.com">
<link rel="preload" href="/critical.css" as="style">
<link rel="preload" href="/main.js" as="script">

<!-- 预渲染重要页面 -->
<link rel="prerender" href="/next-page.html">

Plain Text
# 启用HTTP/2服务器推送
server {
    listen 443 ssl http2;
    
    location = /index.html {
        http2_push /styles.css;
        http2_push /bundle.js;
    }
    
    # 调整缓冲区优化吞吐量
    http2_chunk_size 8k;
    http2_body_buffer_size 128k;
}

Plain Text
# 多级缓存配置
location /static/ {
    # 强缓存：1年
    expires 1y;
    add_header Cache-Control "public, immutable";
}

location /api/data/ {
    # 协商缓存：频繁变化数据
    etag on;
    add_header Cache-Control "no-cache";
}

location /api/config/ {
    # 短期缓存：配置类数据
    expires 1h;
    add_header Cache-Control "public";
}

Plain Text
# 检查TLS版本和密码套件
openssl s_client -connect example.com:443 -tls1_3

# HTTP/2支持检测
curl -I --http2 https://example.com

# 完整请求链路分析
curl -w "DNS: %{time_namelookup} TCP: %{time_connect} TLS: %{time_appconnect} TTFB: %{time_starttransfer}\n" -o /dev/null -s https://example.com

# HSTS策略检查
curl -I https://example.com | grep -i strict-transport-security

Plain Text
# 创建功能分支
git checkout -b feature/user-auth

# 开发过程中定期base主干
git fetch origin
git rebase origin/master

# 完成功能后推送到远程
git push origin feature/user-auth

# 创建Pull Request合并到master

Plain Text
# 反模式：多个无关修改混合提交
git commit -m "修复登录和优化搜索"

# 正确做法：分离关注点
git commit -m "#123 修复登录验证逻辑"
git commit -m "#124 优化搜索性能"

Plain Text
# 优秀提交信息示例
git commit -m "feat: 用户登录支持OAuth2认证

- 集成Google OAuth2提供商
- 添加JWT token生成逻辑
- 更新登录页面UI样式

Closes #123
BREAKING CHANGE: 移除旧版登录API"

Plain Text
# 提交前验证
./gradlew test          # 运行测试套件
./gradlew checkstyleMain # 代码规范检查
./gradlew jacocoTestReport # 覆盖率检查

Plain Text
// 评审评论模板
/**
 * 代码整体结构清晰，但有几个优化建议：
 * 
 * 1. 第24-30行的输入验证逻辑可以提取为独立方法
 *   建议：private boolean isValidInput(String input)
 *   
 * 2. 异常处理很完善，但可以考虑使用异常类型
 *   建议：throw new ValidationException("Invalid input")
 *   
 * 3. 测试覆盖了主要路径，建议添加边界情况测试
 *   建议：添加空输入、超长输入等测试用例
 */

Plain Text
// 事故复盘模板
public class IncidentReview {
    private final String incidentId;
    private final String description;
    private final String rootCause;
    private final String solution;
    private final String prevention; // 预防措施
    private final boolean isSystemIssue; // 系统缺陷而非人为失误
    
    // 无责复盘：关注系统改进而非责任追究
    public void conductBlameFreeReview() {
        // 重点：如何防止类似问题再次发生
    }
}

Plain Text
// 团队效能指标看板
public class TeamMetrics {
    // 代码质量指标
    private double codeReviewCycleTime;  // 目标：<4小时
    private double buildFailureRate;     // 目标：<5%
    private double defectEscapeRate;     // 目标：<2%
    
    // 协作效率指标  
    private double mergeConflictRate;    // 目标：<3%
    private double prThroughput;         // 目标：>10个/周
    private double teamSatisfaction;     // 目标：>4.5/5
}

Plain Text
#!/bin/bash
# .git/hooks/pre-commit

# 运行测试
if ! ./gradlew test; then
    echo "测试失败，请修复后再提交"
    exit 1
fi

# 代码风格检查
if ! ./gradlew checkstyleMain; then
    echo "代码风格检查失败"
    exit 1
fi

# 提交信息格式检查
COMMIT_MSG=$(cat $1)
if ! echo "$COMMIT_MSG" | grep -qE "^(feat|fix|docs|style|refactor|test|chore): "; then
    echo "提交信息格式错误，请使用: feat|fix|docs|style|refactor|test|chore"
    exit 1
fi

Plain Text
name: CI Pipeline
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up JDK
      uses: actions/setup-java@v2
      with:
        distribution: 'temurin'
        java-version: '17'
        
    - name: Run tests
      run: ./gradlew test    - name: Code coverage
      run: ./gradlew jacocoTestReport
      
    - name: SonarCloud scan
      uses: SonarSource/sonarcloud-github-action@master
      env:
        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

Plain Text
Java类型系统
├── 基本类型（值类型）
│   ├── 整型：byte(8位), short(16位), int(32位), long(64位)
│   ├── 浮点float(32位), double(64位)  
│   ├── 字符型：char(16位)
│   └── 布尔型：boolean(1位)
└── 引用类型（对象类型）
    ├── 类类型：String、自定义类
    ├── 接口类型
    ├── 数组类型
    └── 枚举类型

Plain Text
// 基本类型：值直接存储
int age = 30;           // 栈中直接存储30
int copyAge = age;      // 创建值的副本
copyAge = 40;           // 修改副本，原值不变
System.out.println(age); // 输出30，原值未变

// 引用类型：存储对象地址  
String name = "Java";           // name存储字符串对象的地址
String copyName = name;         // 复制地址，指向同一对象
copyName = "Python";            // copyName指向新对象
System.out.println(name);       // 输出"Java"，原对象未变

Plain Text
// 自动装箱拆箱
Integer boxed = 100;    // ✅ 自动装箱：int → Integer
int unboxed = boxed;    // ✅ 自动拆箱：Integer → int

// 空指针陷阱
Integer nullValue = null;
int value = nullValue;  // ❌ 运行时NullPointerException

// 比较陷阱
Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // ✅ true（-128~127缓存）

Integer c = 200;
Integer d = 200;  
System.out.println(c == d);  // ❌ false（超出缓存范围）

Plain Text
String s1 = new String("text");  // 堆中新建对象
String s2 = new String("text");  // 堆中另一个对象

System.out.println(s1 == s2);       // ❌ false：比较地址
System.out.println(s1.equals(s2));  // ✅ true：比较内容

// 字符串常量池优化
String s3 = "text";  // 常量池中对象
String s4 = "text";  // 复用常量池同一对象
System.out.println(s3 == s4);       // ✅ true：常量池复用

Plain Text
控制流结构
├── 分支结构（条件执行）
│   ├── if-else：条件判断
│   └── switch：多路选择
├── 循环结构（重复执行）  
│   ├── for：计数循环
│   ├── while：条件循环
│   └── do-while：至少执行一次
└── 跳转语句（流程控制）
    ├── break：跳出循环/switch
    ├── continue：跳过本次迭代
    └── return：方法返回

Plain Text
// 多条件分支
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好"); 
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// 卫语句优化（提前返回）
if (user == null) return;       // 提前处理边界条件
if (!user.isActive()) return;
// 主要业务逻辑（减少嵌套层次）

Plain Text
// 传统switch（需要break）
switch (dayOfWeek) {
    case 1: 
        System.out.println("周一");
        break;  // 必须break，否则穿透
    case 2:
        System.out.println("周二"); 
        break;
    default:
        System.out.println("周末");
}

// Java 12+ switch表达式（推荐）
String dayType = switch (dayOfWeek) {
    case 1, 2, 3, 4, 5 -> "工作日";  // 多case匹配
    case 6, 7 -> "周末";
    default -> "无效日期";
};

Plain Text
// 标准for循环：已知迭代次数
for (int i = 0; i < 10; i++) {
    System.out.println("第" + i + "次迭代");
}

// 增强for循环：遍历集合/数组
String[] languages = {"Java", "Python", "Go"};
for (String lang : languages) {  // 只读遍历
    System.out.println("语言: " + lang);
}

Plain Text
// while：先判断后执行（可能0次）
Scanner scanner = new Scanner(System.in);
String input;
while (!(input = scanner.nextLine()).equals("exit")) {
    System.out.println("输入: " + input);
}

// do-while：先执行后判断（至少1次）
int attempt = 0;
do {
    attempt++;
    System.out.println("第" + attempt + "次尝试");
} while (attempt < 3);

Plain Text
// break：跳出整个循环
for (int i = 0; i < 10; i++) {
    if == 5) {
        break;  // i=5时完全退出循环
    }
    System.out.println(i);  // 输出0-4
}

// continue：跳过本次迭代
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;  // 跳过偶数次迭代
    }
    System.out.println(i);  // 输出1,3,5,7,9
}

Plain Text
// 包声明：逆域名规范
package com.example.project.util;

// 导入单个类（推荐）
import java.util.ArrayList;
import java.util.List;

// 导入整个包（谨慎使用）
import java.util.*;  // 可能导致命名冲突

Plain Text
src/main/java
└── com/example/
    └── ecommerce/                    # 根包：项目领域
        ├── Application.java          # 启动类
        ├── config/                   # 配置类
        │   ├── WebConfig.java
        │   └── DatabaseConfig.java
        ├── controller/               # 控制层（Web接口）
        │   ├── UserController.java
        │   └── OrderController.java
        ├── service/                  # 业务逻辑层
        │   ├── UserService.java
        │   └── OrderService.java
        ├── repository/               # 数据访问层
        │   ├── UserRepository.java
        │   └── OrderRepository.java
        ├── model/                   # 数据模型
        │   ├── User.java
        │   └── Order.java
        └── util/                    # 工具类
            ├── StringUtils.java
            └── DateUtils.java

Plain Text
package com.example.demo;                    // 包声明：属于demo模块

import java.util.*;                         // 导入：使用Java工具包

public class ShoppingCart {                 // 类声明：公开访问
    private List<String> items;             // 引用类型：字符串列表
    private double totalPrice;              // 基本类型：双精度浮点
    
    public ShoppingCart() {                  // 构造方法
        this.items = new ArrayList<>();     // 对象创建：堆内存分配
        this.totalPrice = 0.0;             // 基本类型初始化
    }
    
    public void addItem(String item, double price) {
        // 控制流：条件判断
        if (item != null && price > 0) {    // 逻辑与操作
            items.add(item);                // 列表操作
            totalPrice += price;            // 基本类型运算
            
            // 循环：遍历检查
           String existing : items) {  // 增强for循环
                if (existing.equals(item)) {
                    System.out.println("已添加: " + item);
                    break;                  // 跳转：提前退出
                }
            }
        }
    }
    
    public void checkout() {
        // 控制流：空值检查
        if (items == null || items.isEmpty()) {
            System.out.println("购物车为空");
            return;                        // 跳转：方法返回
        }
        
        System.out.println("结算商品:");
        // 循环：索引遍历
        for (int i = 0; i < items.size(); i++) {  // 标准for循环
            System.out.println((i + 1) + ". " + items.get(i));
        }
        System.out.printf("总价: %.2f\n", totalPrice);  // 
    }
}

Plain Text
// 测试代码执行推演
ShoppingCart cart = new ShoppingCart();  // 构造方法调用
cart.addItem("手机", 2999.0);           // 条件满足，添加商品
cart.addItem(null, 100.0);              // 条件不满足，跳过
cart.checkout();                         // 输出购物车内容

Plain Text
类型系统（数据载体）
       ↗↙        ↖↘
控制流（执行路径）↔ 包组织（代码结构）

Plain Text
// ❌ 数据完全暴露，失去控制
class User {
    public String password;  // 密码直接暴露
    public boolean isActive; // 状态可随意修改
}

Plain Text
// ✅ 封装数据，提供受控访问
class User {
    private String password;
    private boolean isActive;
    
    // 通过方法控制密码修改逻辑
    public void setPassword(String newPassword) {
        if (isValidPassword(newPassword)) {
            this.password = encrypt(newPassword);
        }
    }
    
    // 提供状态查询而非直接暴露字段
    public boolean isActive() {
        return isActive;
    }
    
    // 状态变更需要业务逻辑验证
    public void activate() {
        if (validateActivationConditions()) {
            this.isActive = true;
            sendActivationNotification();
        }
    }
}

Plain Text
// ❌ Java不支持多继承
class Student extends Person, Worker {  // 编译错误
}

// ✅ 单继承是Java的设计选择
class Student extends Person {
    // 只能继承一个父类
}

Plain Text
class Animal {
    public void breathe() { }
}

class Fish extends Animal {
    public void swim() { }  // 子类特有方法
}

Animal animal = new Fish();
animal.swim();  // ❌ 编译错误：Animal类型看不到swim方法

Plain Text
class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);  // ✅ 必须首先调用父类构造器
        // 子类初始化逻辑
    }
}

Plain Text
// ❌ 错误的"is-a"关系：栈不是向量
class Stack extends Vector {
    public void push(Object item) {
        addElement(item);
    }
    public Object pop() {
        Object obj = peek();
        removeElementAt(size() - 1);
        return obj;
    }
}
// 问题：Stack继承了Vector的所有公共方法，破坏了封装

Plain Text
// ✅ 使用组合，隐藏实现细节
class Stack {
    private List<Object> elements = new ArrayList<>();
    
    public void push(Object item) {
        elements.add(item);
    }
    
    public Object pop() {
        if (elements.isEmpty()) {
            throw new EmptyStackException();
        }
        return elements.remove(elements.size() - 1);
    }
    
    // 只暴露栈相关操作，隐藏List的其他方法
}

Plain Text
// 多态经典示例
abstract class Shape {
    public abstract void draw();  // 抽象方法，强制子类实现
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
 多态使用：统一处理不同图形
public class DrawingApp {
    public void drawShapes(List<Shape> shapes) {
        for (Shape shape : shapes) {
            shape.draw();  // 运行时确定具体实现
        }
    }
}

Plain Text
// 违反里氏替换原则的例子
class Rectangle {
    protected int width, height;
    
    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
}

class Square extends Rectangle {
    // 正方形重写setter，强制宽高相等
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);  // ❌ 违反里氏替换原则
    }
    
    @Override
    public void setHeight(int height) {
        super.setHeight(height);
        super.setWidth(height);  // ❌ 改变了类行为语义
    }
}

// 使用场景出现问题
void resize(Rectangle rectangle) {
    rectangle.setWidth(5);
    rectangle.setHeight(4);
    // 期望面积20，但如果是Square则得到16
}

Plain Text
// ✅ 依赖于抽象接口
interface MessageSender {
    void send(String message);
}

class EmailSender implements MessageSender {
    @Override
    public void send(String message) {
        // 邮件发送实现
    }
}

class SmsSender implements MessageSender {
    @Override
    public void send(String message) {
        // 短信发送实现
    }
}

class NotificationService {
    private MessageSender sender;  // 依赖于抽象
    
    public NotificationService(MessageSender sender) {
        this.sender = sender;
    }
    
    public void sendNotification(String message) {
        sender.send(message);  // 多态调用
    }
}

Plain Text
// 使用组合实现灵活的日志系统
interface Logger {
    void log(String message);
}

class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 文件日志实现
    }
}

class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        // 控制台日志实现
    }
}

// 通过组合实现日志功能增强
class TimestampLogger implements Logger {
    private Logger delegate;  // 组合基础日志器
    
    public TimestampLogger(Logger delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public void log(String message) {
        String = "[" + LocalDateTime.now() + "] " + message;
        delegate.log(timestamped);  // 委托给具体实现
    }
}

// 使用组合可以灵活组合功能
Logger logger = new TimestampLogger(new FileLogger());
logger.log("业务操作完成");  // 输出带时间戳的文件日志

Plain Text
// 使用组合+继承的混合设计
class Order {
    // 组合：订单包含支付信息（has-a关系）
    private Payment payment;
    private List<OrderItem> items;
    
    public Order(Payment payment) {
        this.payment = payment;
        this.items = new ArrayList<>();
    
    public void processPayment(BigDecimal amount) {
        // 委托给支付对象处理
        payment.process(amount);
    }
}

// 继承：支付方式多态化
abstract class Payment {
    public abstract void process(BigDecimal amount);
    protected void logPayment(String message) {
        // 公共日志逻辑
    }
}

class Alipay extends Payment {
    @Override
    public void process(BigDecimal amount) {
        // 支付宝支付实现
        logPayment("支付宝支付处理：" + amount);
    }
}

class WechatPay extends Payment {
    @Override
    public void process(BigDecimal amount) {
        // 微信支付实现
        logPayment("微信支付处理：" + amount);
    }
}

// 新增支付方式无需修改Order类
class BankTransfer extends    @Override
    public void process(BigDecimal amount) {
        // 银行转账实现
        logPayment("银行转账处理：" + amount);
    }
}

Plain Text
// ❌ 错误示范：循环拼接 - 创建10万个对象！
String result = "";
for (int i = 0; i < 100000; i++) {
    result += i;  // 每次循环都创建新String对象
}

// ✅ 正确做法：StringBuilder - 单一对象操作
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
    sb.append(i);  // 在单一对象上操作
}
String result =();

Plain Text
// 常量池机制示例
String s1 = "java";           // 常量池对象
String s2 = new String("java"); // 堆内存新对象
String s3 = "java";

System.out.println(s1 == s2);  // false：地址不同
System.out.println(s1 == s3);  // true：常量池复用

Plain Text
// ❌ SimpleDateFormat线程安全问题
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 多线程同时调用sdf.parse()会导致数据错乱或崩溃

// ✅ 解决方案：线程局部变量或Java 8新API
ThreadLocal<SimpleDateFormat> threadSafeSdf = 
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
// 或直接使用DateTimeFormatter（推荐）