Java web%10

%10

新路线 Java webai 笔记

阶段	时长	内容
Web前端基础	2天	HTML、CSS、JS、Vue3、Ajax
Web后端基础	4天	Maven、HTTP协议、Spring IOC、DI、MySQL、JDBC、Mybatis
Web后端实战	6天	Tlias案例（基于案例讲解web开发的核心知识）
Web后端进阶	2天	SpringAOP、SpringBoot原理、自定义Starter、Maven高级
前端web实战	4天	Vue工程化、ElementPlus、Tlias案例
项目部署	2天	Linux、Docker

后面笔记基本上就是个建议或者链接了 或者总结了 黑马的笔记很详细了

然后说我今天干了什么

其实也没干啥 配置了一个vscode环境

然后在写实际的项目电协官网

怎么说

感觉开发流程还不熟习 不知道前后端怎么穿脱

以及开发文档 需求分析 以及 开发流程

14.软件开发流程

以下是一个软件项目从需求分析到开发完成的完整流程，以及前端和后端开发的具体步骤：


### **一、软件项目开发全流程**
#### **1. 需求分析与规划**
- **目标**：明确用户需求，定义产品功能和范围。  
- **步骤**：  
  - 与客户/产品经理沟通，收集业务需求（如用户故事、功能列表）。  
  - 分析需求可行性，评估技术难度、成本和时间周期。  
  - 制定《需求规格说明书》和《项目开发计划》，确定里程碑和交付物。  

#### **2. 设计阶段**
- **目标**：完成技术方案设计，形成可执行的开发蓝图。  
- **步骤**：  
  - **架构设计**：确定技术栈（如前端用React/Vue，后端用Java/Node.js）、数据库设计（ER图、表结构）、系统模块划分。  
  - **UI/UX设计**：设计原型图（如Axure）、高保真视觉稿（Figma），定义交互逻辑和用户体验。  
  - **接口设计**：前后端分离模式下，制定API接口文档（如Swagger），明确数据格式和交互方式。  

#### **3. 开发阶段**
- **目标**：分模块实现功能，前端和后端并行开发。  
- **步骤**：  
  - 搭建开发环境，创建代码仓库（Git）。  
  - 前端开发与后端开发同步进行（见下文详细步骤）。  
  - 定期进行联调，确保接口数据互通。  

#### **4. 测试阶段**
- **目标**：验证功能正确性，修复缺陷。  
- **步骤**：  
  - **单元测试**：开发人员对单个模块/函数进行测试。  
  - **集成测试**：测试各模块间的交互是否正常。  
  - **系统测试**：模拟用户场景，测试整个系统的功能、性能、兼容性（如浏览器适配）。  
  - **用户验收测试（UAT）**：客户参与测试，确认需求是否满足。  
  - 缺陷跟踪与修复（使用Jira/Trello等工具）。  

#### **5. 部署与上线**
- **目标**：将系统发布到生产环境。  
- **步骤**：  
  - 配置服务器环境（如Nginx、Tomcat、云服务器）。  
  - 前端打包静态资源，后端部署服务端代码。  
  - 数据库迁移（如数据初始化、版本控制）。  
  - 域名绑定、SSL证书配置，确保系统安全访问。  

#### **6. 维护与迭代**
- **目标**：持续优化系统，修复线上问题。  
- **步骤**：  
  - 监控系统运行状态（日志分析、性能指标）。  
  - 收集用户反馈，规划版本迭代（如新增功能、优化体验）。  
  - 定期进行安全漏洞扫描和补丁更新。  


### **二、前端开发具体步骤**
#### **1. 技术选型与环境搭建**
- 选择框架/库（如React/Vue/Angular）、状态管理工具（Redux/Vuex）、构建工具（Webpack/Vite）。  
- 初始化项目，配置开发服务器（如Vite本地服务器）、代码规范（ESLint/Prettier）。  

#### **2. 静态页面开发**
- 根据UI设计稿，使用HTML/CSS/JavaScript实现页面结构、样式和静态交互。  
- 拆分组件（如Header、Footer、Button），遵循组件化开发模式（如React组件）。  

#### **3. 动态交互与接口联调**
- 实现前端逻辑（如表单验证、路由跳转），通过Ajax/Fetch调用后端API。  
- 处理接口返回数据，完成页面动态渲染（如列表加载、详情展示）。  
- 集成状态管理工具，管理跨组件数据（如用户登录状态）。  

#### **4. 优化与适配**
- **性能优化**：代码压缩、图片压缩、懒加载、路由懒加载。  
- **兼容性处理**：适配不同浏览器（如IE兼容补丁）、响应式布局（媒体查询）。  
- **单元测试**：使用Jest/Cypress编写组件测试用例。  

#### **5. 打包与部署**
- 使用构建工具打包代码，生成生产环境静态文件（HTML/CSS/JS）。  
- 部署到CDN或服务器（如Nginx），配置反向代理指向后端接口。  


### **三、后端开发具体步骤**
#### **1. 技术选型与环境搭建**
- 选择编程语言和框架（如Java Spring Boot、Node.js Express、Python Django）。  
- 配置开发环境（IDE、数据库客户端），初始化项目结构（如MVC分层）。  

#### **2. 数据库设计与实现**
- 根据需求设计数据库表结构，创建实体类/模型（如Java Entity、Python Model）。  
- 实现数据库操作（CRUD），使用ORM工具（Hibernate/MyBatis）或原生SQL。  

#### **3. 接口开发与业务逻辑实现**
- 按照接口文档定义API端点（如RESTful接口），处理请求参数和响应数据。  
- 编写业务逻辑代码（如用户注册：验证参数→生成密码→写入数据库→返回token）。  
- 集成中间件（如身份认证JWT、权限控制Spring Security）。  

#### **4. 服务端测试与优化**
- **接口测试**：使用Postman/APITest验证接口功能、参数校验和异常处理。  
- **性能测试**：模拟高并发场景（JMeter），优化数据库查询（索引优化）、接口响应速度。  
- **日志管理**：集成日志框架（Log4j/Slf4j），记录关键操作和错误信息。  

#### **5. 部署与维护**
- 将后端服务打包为可执行文件（如Java Jar包、Docker镜像）。  
- 部署到服务器（云服务器如AWS/阿里云），配置Nginx负载均衡、容器编排（Kubernetes）。  
- 监控服务状态（CPU/内存占用、接口响应时间），设置告警机制。  


### **四、前后端开发协作关键点**
1. **接口先行**：通过Swagger等工具提前定义接口，避免前后端开发冲突。  
2. **联调机制**：定期同步进度，使用Mock数据（如Mock.js）模拟后端接口，提前开发前端功能。  
3. **版本控制**：前后端代码分支独立管理，通过Git标签标记可发布版本。  
4. **文档同步**：维护接口文档、数据字典的实时更新，确保双方信息一致。  

通过以上流程，可确保软件项目开发高效、有序地推进，最终交付符合需求的高质量产品。

15.前端环境搭建及项目构建

my-react-project/
├── public/                  # 静态资源
│   ├── index.html           # 入口HTML
│   └── favicon.ico          # 图标
├── src/                     # 源代码
│   ├── components/          # 组件
│   │   ├── Header.tsx       # 头部组件
│   │   └── Button.tsx       # 按钮组件
│   ├── pages/               # 页面
│   │   ├── Home.tsx         # 首页
│   │   └── About.tsx        # 关于页
│   ├── App.tsx              # 根组件
│   ├── index.tsx            # 入口文件
│   └── styles.css           # 全局样式
├── package.json             # 依赖和脚本配置
├── tsconfig.json            # TypeScript配置
└── .gitignore               # Git忽略配置

黑马

ajax

查csdn多的

16.yml

YAML是一种简洁易读的数据序列化语言，用缩进表示层级，支持字符串、列表、字典等结构，语法简单灵活。常用于配置文件（如Docker、K8s）、数据交换和静态内容管理。对比JSON/XML，它更易编写和理解，尤其适合人类直接读写的场景，是现代开发中主流的配置格式之一。

**YAML（YAML Ain't Markup Language）** 是一种人类可读的数据序列化语言，常用于配置文件、数据存储和通信协议中。它以简洁的语法和结构化的格式著称，相比传统的 XML 和 JSON 更易读、易写，且支持复杂的数据结构。


### **一、YAML 的核心特点**
1. **简洁易读**  
   - 采用缩进来表示层级关系（无大括号或关键词），语法简洁直观。  
   - 示例：  
     ```yaml
     server:
       host: "localhost"
       port: 8080
     ```

2. **支持多种数据结构**  
   - **标量（Scalar）**：字符串、数字、布尔值、null 等（如 `name: "Alice"`）。  
   - **列表（List）**：用 `-` 表示列表项（如 `fruits: - apple - banana`）。  
   - **映射（Map/对象）**：键值对结构（如 `user: {name: "Bob", age: 30}`）。  

3. **数据类型灵活**  
   - 无需显式声明类型，YAML 会自动识别（如 `age: 30` 为数字，`is_ready: true` 为布尔值）。  
   - 支持复杂结构嵌套，如多层级对象、列表嵌套列表等。  

4. **注释与多行内容**  
   - 注释以 `#` 开头（如 `# 这是一条注释`）。  
   - 多行文本可用 `|` 表示（保留换行）或 `>` 表示（折叠换行）：  
     ```yaml
     description: |
       这是一段
       多行文本，
       会保留换行。
     ```


### **二、YAML 基本语法规则**
1. **缩进规则**  
   - 用空格缩进表示层级关系（不允许使用制表符），同一层级缩进量需一致。  
   - 示例：  
     ```yaml
     parent:
       child1: value1  # 缩进2或4个空格（建议统一）
       child2: value2
     ```

2. **键值对表示**  
   - 键与值用 `:` 分隔，冒号后需加空格（如 `name: John`）。  
   - 字符串可加引号（单/双均可），也可省略（避免歧义时建议使用引号，如包含特殊字符）。  

3. **列表与集合**  
   - 列表项以 `- ` 开头（短横线 + 空格），同一列表项缩进一致：  
     ```yaml
     hobbies:
       - reading
       - gaming
       - coding
     ```  
   - 集合（Set）用 `*` 表示锚点和引用（高级用法，用于重复数据复用）：  
     ```yaml
     defaults: &default
       server: localhost
       port: 8080
     config:
       <<: *default  # 引用锚点default的值
       port: 8081     # 覆盖默认端口
     ```

4. **多行内容与转义**  
   - 字面量（Literal）：用 `|` 保留换行，`|+` 保留末尾换行，`|-` 忽略末尾换行：  
     ```yaml
     text: |
       第一行  
       第二行  # 输出包含换行
     ```  
   - 折叠式（Folded）：用 `>` 折叠换行，`>`+ 保留末尾空格：  
     ```yaml
     text: >
       第一行  
       第二行  # 输出为单行，用空格分隔
     ```


### **三、YAML 与其他格式的对比**
| 特性         | YAML                     | JSON                     | XML                      |
|--------------|--------------------------|--------------------------|--------------------------|
| **可读性**   | 高（缩进层级清晰）       | 中（依赖格式化）         | 低（标签冗余）           |
| **语法复杂度** | 简单（无标签/括号）      | 中等（需注意括号匹配）   | 复杂（标签嵌套繁琐）     |
| **适用场景** | 配置文件、数据交换       | API 数据传输             | 传统企业级数据交互       |
| **示例**     | `name: Alice\nage: 30`   | `{"name":"Alice","age":30}` | `Alice...` |


### **四、常见应用场景**
1. **配置文件**  
   - 如 Docker Compose、Kubernetes、Spring Boot 等工具的配置文件。  
   - 示例（`docker-compose.yml`）：  
     ```yaml
     version: '3'
     services:
       web:
         image: nginx:latest
         ports:
           - "80:80"
     ```

2. **数据存储与传输**  
   - 用于存储元数据（如 Jekyll 博客的 Front Matter）、日志结构化输出等。  

3. **CI/CD 流水线**  
   - 定义 GitHub Actions、GitLab CI 等持续集成流程（如 `.github/workflows/main.yml`）。  

4. **编程语言配置**  
   - 如 Ansible 剧本、Ruby on Rails 的本地化文件（`.yml` 后缀）。  


### **五、注意事项**
1. **严格区分大小写**：键名和值均大小写敏感（如 `Port` 和 `port` 视为不同键）。  
2. **避免语法歧义**：  
   - 字符串包含 `:`、`#` 等符号时需用引号包裹（如 `path: "/user/home#data"`）。  
   - 布尔值 `true/false`、`on/off`、`yes/no` 需小写。  
3. **工具支持**：  
   - 编辑器可安装 YAML 插件（如 VS Code 的 `Red Hat YAML`）进行语法高亮和校验。  
   - 命令行工具：`yaml2json` 可将 YAML 转为 JSON，方便脚本处理。  


### **六、快速入门示例**
#### 1. 简单对象
```yaml
person:
  name: John Doe
  age: 30
  is_student: false
  hobbies:
    - reading
    - hiking
```

#### 2. 列表嵌套
```yaml
books:
  - title: "The Great Gatsby"
    author: "F. Scott Fitzgerald"
    published: 1925
  - title: "1984"
    author: "George Orwell"
    published: 1949
```

#### 3. 多行文本与表达式
```yaml
description: |
  这是一个多行描述，
  支持变量插值：{{version}}
env:
  PORT: 8080
  HOST: ${HOST_IP:-localhost}  # 环境变量或默认值
```


YAML 凭借其简洁性和易读性，已成为现代开发中最流行的配置语言之一。掌握基础语法后，可通过实际项目（如编写 Kubernetes 部署文件）进一步加深理解。

17.apifox

Apifox 是一款 API 文档、调试、数据 Mock、自动化测试一体化协作平台1。其核心优势是通过一套系统、一份数据解决多个系统间的数据同步问题，让接口文档和开发调试在同一工具内闭环，确保文档与实际接口的一致性1。

它具有接口设计可视化、数据模型可复用、接口调试功能丰富、零配置人性化 Mock 数据、接口自动化测试便捷、代码自动生成、支持团队协作等特点，能有效提升 API 开发、测试效率，简化团队协作流程1

以下是Apifox的具体使用步骤：

### 安装与注册
1. **下载**：访问[Apifox官网](https://www.apifox.cn/)，根据自己的操作系统下载对应的版本，支持Windows、MacOS、Linux等。
2. **安装**：按照安装包的指引完成安装。
3. **注册账户**：推荐使用微信扫码登录，也支持手机、邮箱注册。

### 创建团队与项目
1. **创建团队**：登录后，在团队页面可以新建团队，也可以接受成员邀请加入已有团队。
2. **创建项目**：在团队下点击“新建项目”，输入项目名称等信息创建项目。

### 导入接口文档
1. 切换到主分支“main”。
2. 进入项目后，通过“项目设置”→“导入数据”或“接口管理”→“导入”来导入API文档。可以选择输入Swagger接口文档URL或上传文件，点击“继续”，选择“智能合并导入”，确保接口和数据模型一同导入。

### 接口调试
1. 选择环境：点击右上角选择测试环境等，若环境未配置，可点击“管理环境”进行配置，设置环境的协议、域名等信息。
2. 进入接口管理，选择要调试的接口，在接口运行界面修改请求参数等信息，点击“运行”或“发送”按钮，查看返回信息。调试成功后可暂存或保存为用例。

### Mock数据使用
1. 定义好API后，Apifox可自动根据数据结构和类型生成Mock数据，无需额外配置。
2. 若有特殊需求，可在接口的Mock模块中自定义Mock规则，支持正则表达式和野。在“运行”界面选择“Mock服务”，即可使用Mock数据进行调试。

### 自动化测试
1. 从已有用例中导入测试场景到自动化测试模块。
2. 在自动化测试页面添加组，在组下添加测试案例，导入接口案例后，可设置循环次数、线程等信息，点击“运行”进行批量执行，执行完成后可导出报告。

18.jdbc

JDBC（Java Database Connectivity） 是Java访问关系型数据库的标准API，通过抽象数据库操作实现统一接口。核心组件包括驱动（Driver）、驱动管理器（DriverManager）、连接（Connection）、语句执行对象（Statement/PreparedStatement）和结果集（ResultSet）。

基本流程：加载驱动→获取连接→创建语句→执行SQL→处理结果→释放资源。推荐使用预编译语句（PreparedStatement）防SQL注入，结合连接池（如HikariCP）提升性能。支持事务管理（手动提交/回滚）和批量操作，适用于细粒度控制数据库场景。 对比ORM框架（如MyBatis），JDBC需手写SQL但性能更高，是Java数据库开发的基础，广泛用于构建数据库应用底层逻辑。

### JDBC 概述  
**JDBC（Java Database Connectivity）** 是 Java 提供的一套用于操作数据库的标准 API（应用程序接口），允许 Java 程序与各种关系型数据库（如 MySQL、Oracle、SQL Server 等）进行连接、执行SQL语句并处理返回结果。它是 Java EE 平台的核心组件之一，通过抽象数据库操作细节，使开发者能够以统一的方式访问不同数据库。


### **核心组件与作用**  
#### 1. **Driver（驱动程序）**  
- **作用**：实现 JDBC 接口的具体数据库驱动（如 MySQL 驱动、Oracle 驱动），负责与数据库建立连接、执行 SQL 语句等底层操作。  
- **常见驱动类**：  
  - MySQL：`com.mysql.cj.jdbc.Driver`（5.x版本为`com.mysql.jdbc.Driver`）。  
  - Oracle：`oracle.jdbc.OracleDriver`。  

#### 2. **DriverManager（驱动管理器）**  
- **作用**：管理数据库驱动程序的注册、注销，以及创建数据库连接（`Connection`对象）。  
- **核心方法**：  
  - `registerDriver(Driver driver)`：注册驱动（自动注册机制已普及，手动注册逐渐淘汰）。  
  - `getConnection(String url, String user, String password)`：获取数据库连接。  

#### 3. **Connection（数据库连接）**  
- **作用**：代表与数据库的一次会话，用于创建执行 SQL 的语句对象（`Statement`/`PreparedStatement`），并管理事务。  
- **核心方法**：  
  - `createStatement()`：创建普通 SQL 语句执行对象。  
  - `prepareStatement(String sql)`：创建预编译 SQL 语句执行对象（推荐使用，防 SQL 注入）。  
  - `setAutoCommit(boolean autoCommit)`：设置是否自动提交事务（默认 `true`）。  
  - `commit()`/`rollback()`：提交/回滚事务。  

#### 4. **Statement/PreparedStatement（语句执行对象）**  
- **作用**：用于执行 SQL 语句并返回结果。  
  - **`Statement`**：执行静态 SQL 语句，存在 SQL 注入风险。  
  - **`PreparedStatement`**（推荐）：执行预编译 SQL 语句，支持参数化查询，安全性更高、性能更好。  
- **核心方法**：  
  - `executeQuery(String sql)`：执行查询语句（如 `SELECT`），返回 `ResultSet`。  
  - `executeUpdate(String sql)`：执行增删改语句（如 `INSERT/UPDATE/DELETE`），返回影响行数。  

#### 5. **ResultSet（结果集）**  
- **作用**：存储 SQL 查询返回的结果数据，以表格形式组织（行 + 列）。  
- **核心方法**：  
  - `next()`：移动光标到下一行，若有数据返回 `true`。  
  - `getXxx(int columnIndex/string columnLabel)`：获取指定列的数据（`Xxx` 为数据类型，如 `getString`、`getInt`）。  


### **JDBC 操作数据库的基本步骤**  
以 MySQL 为例，演示查询数据的流程：  

#### 1. **添加数据库驱动依赖**  
在项目中引入数据库驱动包（如 Maven 依赖）：  
```xml  
  
    mysql  
    mysql-connector-java  
    8.0.33  
  
```  

#### 2. **注册驱动程序（自动注册）**  
JDBC 4.0 后，驱动类会自动加载（通过 `Class.forName()` 隐式注册），无需手动调用 `DriverManager.registerDriver()`。  

#### 3. **获取数据库连接**  
```java  
String url = "jdbc:mysql://localhost:3306/test_db?useSSL=false&serverTimezone=UTC";  
String username = "root";  
String password = "your_password";  
Connection conn = DriverManager.getConnection(url, username, password);  
```  
- **URL 格式**：`jdbc:数据库类型://主机:端口/数据库名?参数`（如 MySQL 的时区、SSL 设置等）。  

#### 4. **创建语句执行对象**  
使用 `PreparedStatement` 执行参数化查询：  
```java  
String sql = "SELECT id, name, age FROM users WHERE age > ?";  
PreparedStatement pstmt = conn.prepareStatement(sql);  
pstmt.setInt(1, 18); // 设置参数（第一个问号对应值为 18）  
```  

#### 5. **执行 SQL 语句**  
```java  
ResultSet rs = pstmt.executeQuery(); // 执行查询语句  
```  

#### 6. **处理结果集**  
```java  
while (rs.next()) {  
    int id = rs.getInt("id");  
    String name = rs.getString("name");  
    int age = rs.getInt("age");  
    System.out.println("ID: " + id + ", 姓名: " + name + ", 年龄: " + age);  
}  
```  

#### 7. **释放资源**  
```java  
rs.close();  
pstmt.close();  
conn.close(); // 建议使用 try-with-resources 自动关闭  
```  
**最佳实践**：使用 `try-with-resources` 语句避免资源泄漏：  
```java  
try (Connection conn = DriverManager.getConnection(...);  
     PreparedStatement pstmt = conn.prepareStatement(...)) {  
    // 执行操作  
} catch (SQLException e) {  
    e.printStackTrace();  
}  
```  


### **关键特性与最佳实践**  
#### 1. **事务管理**  
- 手动开启事务：`conn.setAutoCommit(false);`  
- 提交：`conn.commit();`  
- 回滚：`conn.rollback();`  
```java  
try {  
    conn.setAutoCommit(false);  
    // 执行多个更新操作  
    conn.commit();  
} catch (Exception e) {  
    conn.rollback();  
}  
```  

#### 2. **预编译语句（PreparedStatement）**  
- **优势**：  
  - 防止 SQL 注入（参数与 SQL 分离）。  
  - 减少编译开销，提高性能（SQL 语句只编译一次）。  
  - 支持批量操作（`addBatch()`/`executeBatch()`）。  

#### 3. **连接池（Database Connection Pool）**  
- **作用**：复用数据库连接，避免频繁创建/销毁连接的开销，提升性能。  
- **常见实现**：HikariCP、C3P0、DBCP 等。  
- **示例（HikariCP）**：  
  ```java  
  HikariConfig config = new HikariConfig();  
  config.setJdbcUrl(url);  
  config.setUsername(username);  
  config.setPassword(password);  
  HikariDataSource dataSource = new HikariDataSource(config);  
  Connection conn = dataSource.getConnection();  
  ```  

#### 4. **类型映射**  
JDBC 自动映射 Java 数据类型与数据库字段类型（如 `Java int` → `数据库 INT`，`Java String` → `数据库 VARCHAR`）。  


### **与其他持久化技术的对比**  
| 技术         | 特点                                                                 |  
|--------------|----------------------------------------------------------------------|  
| **JDBC**     | 原生 API，性能高，需手写 SQL，适合细粒度控制数据库操作。             |  
| **MyBatis**  | 基于 JDBC 的 ORM 框架，通过 XML/注解映射 SQL，减少样板代码。           |  
| **Hibernate**| 全自动 ORM 框架，支持对象-关系映射，屏蔽 SQL 细节，适合复杂业务场景。 |  


### **总结**  
JDBC 是 Java 操作数据库的基础，核心流程围绕“连接→执行语句→处理结果→释放资源”展开。实际开发中，建议优先使用 `PreparedStatement` 和连接池，并结合 ORM 框架（如 MyBatis）简化开发。理解 JDBC 原理有助于深入掌握数据库操作的底层逻辑，提升问题排查能力。

19.NGINX

Nginx 是高性能开源 Web 服务器、反向代理及负载均衡软件，采用异步非阻塞架构，单进程可处理数千并发连接，内存占用极低。核心功能包括：静态资源服务、反向代理、负载均衡（支持轮询 / IP 哈希等算法）、HTTP 缓存及 HTTPS 处理。配置文件模块化，通过server和upstream定义虚拟主机与后端服务器组。常用作前端静态资源服务器、微服务网关或 API 限流工具，相比 Apache 更适合高并发场景。典型命令有nginx -s reload（重载配置）和nginx -t（检查语法）。

### **Nginx 概述**  
**Nginx**（发音为 "engine-x"）是一款轻量级、高性能的开源 Web 服务器、反向代理服务器及电子邮件（IMAP/POP3）代理服务器。它以**高并发处理能力**、**低内存占用**和**稳定性**著称，广泛应用于互联网企业（如淘宝、Netflix）作为负载均衡器或静态资源服务器。  


### **核心功能与应用场景**  
#### 1. **Web 服务器**  
- **静态资源服务**：高效处理 HTML、CSS、JavaScript、图片等静态文件请求，性能优于 Apache。  
- **动态内容代理**：通过反向代理将动态请求转发至后端应用服务器（如 Tomcat、Node.js）。  

#### 2. **反向代理**  
- **隐藏真实服务器**：客户端请求先到达 Nginx，由其转发至内部服务器，保护后端安全。  
- **负载均衡**：将请求分发到多个后端服务器，提高可用性和吞吐量。常见算法：  
  - **轮询**：按顺序依次分发。  
  - **IP哈希**：根据客户端 IP 固定分发到同一服务器（解决 session 共享问题）。  
  - **加权轮询**：根据服务器性能分配权重。  

#### 3. **负载均衡**  
- **应用场景**：高并发网站、微服务架构中的服务网关。  
- **健康检查**：定期检查后端服务器状态，自动剔除故障节点。  

#### 4. **HTTP 缓存**  
- **缓存静态内容**：减少后端服务器压力，提高响应速度。  
- **配置示例**：  
  ```nginx  
  proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m max_size=10g;  
  ```  

#### 5. **HTTPS 处理**  
- **SSL/TLS 终止**：集中处理 HTTPS 加密和解密，减轻后端服务器负担。  
- **HTTP/2 支持**：提升传输效率，支持多路复用和头部压缩。  


### **工作原理**  
Nginx 采用**事件驱动（Event-Driven）**、**异步非阻塞**的架构模型，核心设计理念：  
1. **Master-Worker 进程模型**：  
   - **Master 进程**：负责读取配置、管理 Worker 进程。  
   - **Worker 进程**：处理实际请求，单进程可处理数千并发连接（依赖 epoll/kqueue）。  

2. **事件驱动机制**：  
   - 通过一个进程处理多个连接，避免线程创建/切换开销，内存占用极低（单 Worker 约 2-10MB）。  


### **配置文件结构**  
Nginx 配置文件（通常为 `/etc/nginx/nginx.conf`）采用模块化结构：  
```nginx  
# 全局配置  
user nginx;  
worker_processes auto;  # 根据 CPU 核心数自动调整  

# 事件模块配置  
events {  
    worker_connections 1024;  # 每个 Worker 最大连接数  
}  

# HTTP 模块配置  
http {  
    include       mime.types;  
    default_type  application/octet-stream;  

    # 虚拟主机配置（可多个）  
    server {  
        listen       80;  
        server_name  example.com;  

        # 静态资源路径  
        location /static/ {  
            root /var/www/html;  
        }  

        # 反向代理配置  
        location /api/ {  
            proxy_pass http://backend_servers;  # 指向 upstream 定义的服务器组  
        }  
    }  

    # 上游服务器组（负载均衡）  
    upstream backend_servers {  
        server 192.168.1.101 weight=5;  # 权重为 5  
        server 192.168.1.102;  
        server 192.168.1.103 backup;  # 备份服务器  
    }  
}  
```  


### **常用命令**  
1. **启动/停止/重启**：  
   ```bash  
   nginx                  # 启动  
   nginx -s stop         # 快速停止  
   nginx -s quit         # 优雅停止  
   nginx -s reload       # 重新加载配置  
   ```  

2. **检查配置文件语法**：  
   ```bash  
   nginx -t  
   ```  

3. **查看版本和编译参数**：  
   ```bash  
   nginx -V  
   ```  


### **性能优化建议**  
1. **调整 Worker 进程数**：  
   ```nginx  
   worker_processes auto;  # 自动根据 CPU 核心数调整  
   ```  

2. **增大连接数限制**：  
   ```nginx  
   events {  
       worker_connections 65535;  # 根据内存调整  
   }  
   ```  

3. **启用 Gzip 压缩**：  
   ```nginx  
   gzip on;  
   gzip_types text/plain text/css application/json;  
   ```  

4. **配置缓存**：  
   ```nginx  
   proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m;  
   ```  


### **对比 Apache**  
| 特性               | Nginx                     | Apache                    |  
|--------------------|---------------------------|---------------------------|  
| **架构模型**       | 异步非阻塞                | 多进程/多线程（阻塞）     |  
| **并发处理**       | 高（单进程处理数千连接）  | 低（依赖进程/线程数）     |  
| **内存占用**       | 低（单进程约 2-10MB）     | 高（单进程约 10-20MB）    |  
| **模块扩展**       | 编译时添加                | 运行时动态加载            |  
| **静态资源处理**   | 优                        | 一般                      |  
| **动态资源处理**   | 通过反向代理              | 直接处理（需 mod_php 等） |  


### **典型应用案例**  
1. **作为前端静态资源服务器**：  
   - 处理 HTML、CSS、JS、图片等请求，减轻后端压力。  

2. **微服务网关**：  
   - 统一入口，负载均衡，路由转发，权限校验。  

3. **HTTPS 代理**：  
   - 配置 SSL 证书，处理加密流量，后端服务器使用 HTTP 通信。  

4. **API 限流**：  
   - 通过 `limit_req` 模块限制请求频率，防止 DDOS 攻击。  


### **总结**  
Nginx 凭借高性能、低资源消耗和灵活的配置，成为现代 Web 架构中不可或缺的组件。其核心优势在于处理高并发连接时的卓越表现，适合作为负载均衡器、静态资源服务器或反向代理服务器。掌握 Nginx 配置和优化，是构建高性能、高可用分布式系统的关键技能。

20.restful

RESTful 是一种基于HTTP的轻量级API设计架构风格，核心原则为资源导向（用URL唯一标识资源）、无状态（请求独立）、统一接口（用GET/POST/PUT/DELETE等HTTP方法操作资源）。设计规范包括：URL用名词复数，避免动词；严格使用HTTP状态码（如201创建成功、404未找到）；推荐JSON格式传输数据。优势在于简洁、易扩展、跨平台，广泛用于前后端分离架构。常见工具如Swagger（文档）、Postman（测试），需注意版本控制、幂等性及HTTPS安全防护，是现代API设计的主流标准。

### **RESTful 架构风格详解**

#### **一、概念与核心原则**
**REST（Representational State Transfer）** 是一种软件架构风格，用于设计网络应用程序和API。RESTful 是遵循 REST 原则的 API 设计方式，核心特点：
1. **资源导向**：将一切数据视为资源，用URL标识（如`/users/{id}`）。
2. **无状态**：每个请求独立，不依赖会话状态。
3. **统一接口**：通过HTTP动词（GET/POST/PUT/DELETE）操作资源。
4. **分层系统**：客户端不关心数据来源，服务端可多层部署。
5. **缓存支持**：响应可标记为可缓存或不可缓存。


#### **二、RESTful API 设计规范**
1. **URL 设计**：  
   - 使用名词复数表示资源集合（如`/products`）。  
   - 用路径参数表示资源层级（如`/users/{id}/orders`）。  
   - 避免动词（如`/getProducts`），用HTTP方法表达行为：  
     ```
     GET /users      # 获取用户列表
     POST /users     # 创建用户
     PUT /users/{id} # 更新用户
     DELETE /users/{id} # 删除用户
     ```

2. **HTTP 方法映射**：  
   | 方法  | 作用                  | 幂等性 |
   |-------|-----------------------|--------|
   | GET   | 查询资源              | ✅      |
   | POST  | 创建资源              | ❌      |
   | PUT   | 全量更新资源          | ✅      |
   | PATCH | 部分更新资源          | ✅      |
   | DELETE| 删除资源              | ✅      |

3. **状态码规范**：  
   - **200 OK**：成功响应（GET/PUT/DELETE）。  
   - **201 Created**：资源创建成功（POST）。  
   - **204 No Content**：操作成功但无返回体（DELETE）。  
   - **400 Bad Request**：参数错误。  
   - **401 Unauthorized**：未认证。  
   - **403 Forbidden**：权限不足。  
   - **404 Not Found**：资源不存在。  
   - **500 Internal Server Error**：服务器错误。

4. **数据格式**：  
   - 推荐使用JSON作为请求/响应格式。  
   - 复杂查询可通过URL参数（如`?page=1&size=10`）。


#### **三、与传统API的对比**
| 特性               | RESTful API                     | 传统API（如SOAP）                |
|--------------------|----------------------------------|----------------------------------|
| **接口风格**       | 资源导向（URL + HTTP方法）       | 方法导向（如`/addUser`）          |
| **数据格式**       | JSON/XML（轻量）                 | XML（复杂）                      |
| **状态码使用**     | 严格遵循HTTP状态码               | 自定义错误码                     |
| **缓存支持**       | 天然支持（如ETag、Cache-Control）| 需额外实现                       |
| **跨域支持**       | 简单（CORS）                     | 复杂（需额外配置）               |


#### **四、实战示例**
**需求**：设计一个图书管理系统的RESTful API。

1. **资源定义**：  
   - 图书（Books）：`/api/books`  
   - 评论（Reviews）：`/api/books/{id}/reviews`  

2. **接口设计**：  
   ```
   GET /api/books          # 获取所有图书
   GET /api/books/{id}     # 获取单本图书
   POST /api/books         # 创建图书
   PUT /api/books/{id}     # 全量更新图书
   PATCH /api/books/{id}   # 部分更新图书
   DELETE /api/books/{id}  # 删除图书

   GET /api/books/{id}/reviews  # 获取图书评论
   POST /api/books/{id}/reviews # 添加评论
   ```

3. **响应示例**：  
   ```json
   // GET /api/books/1
   {
     "id": 1,
     "title": "RESTful API 实战",
     "author": "John Doe",
     "reviews": [
       { "id": 101, "content": "很棒的书" }
     ]
   }
   ```


#### **五、最佳实践**
1. **版本控制**：在URL中加入版本号（如`/v1/books`）。  
2. **分页与过滤**：  
   ```
   GET /api/products?page=1&size=20&sort=price,desc
   ```
3. **错误处理**：统一错误响应格式：  
   ```json
   {
     "error": {
       "code": 404,
       "message": "Book not found",
       "details": ["ID 100 does not exist"]
     }
   }
   ```
4. **安全**：  
   - 使用HTTPS。  
   - 认证（JWT/OAuth）与授权（RBAC）。  
   - 请求参数校验。


#### **六、工具与框架**
- **后端**：Spring Boot（Java）、Django REST Framework（Python）、Express（Node.js）。  
- **测试**：Postman、curl、Swagger UI。  
- **文档**：OpenAPI（Swagger）、Redoc。  


#### **七、注意事项**
1. **非资源操作**：若行为无法映射到资源（如复杂计算），可使用自定义端点（如`/api/calculate`）。  
2. **幂等性**：确保PUT/DELETE操作多次调用效果相同。  
3. **性能**：大数据量可采用分页（`?page=1`）或流式传输。  


### **总结**
RESTful 是现代Web API设计的主流范式，通过统一接口、资源导向和无状态特性，使API更简洁、可扩展且易于维护。核心是将业务逻辑抽象为资源，并通过HTTP标准方法操作，配合合理的状态码和数据格式，构建高效、可靠的分布式系统。

快速回顾

1. 软件开发流程

• 需求分析：明确功能，输出《需求规格说明书》。

• 设计阶段：定技术栈、数据库、接口文档（Swagger）。

• 开发阶段：前后端并行，定期联调（Mock 数据）。

• 测试阶段：单元 / 集成 / 系统测试，修复缺陷。

• 部署维护：静态资源打包、服务部署、监控迭代。

2. 前端环境搭建（VSCode）

• 工具链：Node.js + npm，选框架（React/Vue），初始化项目（如 Create React App）。

• 目录结构：public（静态资源）、src（组件 / 页面）、配置文件（package.json/tsconfig.json）。

• 插件配置：ESLint（代码规范）、Prettier（格式化），保存时自动校验。

• 优化：集成 Tailwind CSS，配置代理解决跨域。

3. YAML

• 语法：缩进表示层级，键值对（:）、列表（-），字符串可省略引号。

• 特性：简洁易读，支持多行文本（|保留换行）、锚点引用（&/*）。

• 场景：配置文件（Docker Compose/Kubernetes）、CI/CD 流水线、数据交换。

• 注意：严格缩进（空格），布尔值小写（true/false）。

4. Apifox

• 功能：API 设计、调试、Mock、自动化测试一体化。

• 流程：导入 Swagger 文档→配置环境→调试接口（修改参数→运行）→生成 Mock 数据。

• 协作：团队共享项目，实时同步接口变更，支持自动化测试用例批量执行。

• 工具优势：减少文档与代码不一致，提升前后端联调效率。

5. JDBC

• 核心组件：Driver（驱动）、Connection（连接）、PreparedStatement（预编译语句）、ResultSet（结果集）。

• 流程：加载驱动→获取连接→执行 SQL（推荐预编译防注入）→处理结果→释放资源。

• 最佳实践：使用连接池（HikariCP）复用连接，手动管理事务（commit/rollback）。

• 对比：比 ORM 更底层，性能高，适合细粒度数据库操作。

6. Nginx

• 定位：高性能 Web 服务器 / 反向代理 / 负载均衡器，异步非阻塞架构。

• 核心功能：静态资源服务、反向代理（转发动态请求）、负载均衡（轮询 / IP 哈希）、HTTPS 处理。

• 配置：server定义虚拟主机，upstream配置后端服务器组，location匹配请求路径。

• 命令：nginx -s reload（重载配置），nginx -t（检查语法），适合高并发场景。

7. RESTful API

• 原则：资源导向（URL 唯一标识）、无状态、统一接口（HTTP 方法）。

• 设计规范：URL 用名词复数，状态码（201 创建 / 404 未找到），JSON 格式。

• 工具：Swagger（文档）、Postman（测试），支持版本控制（/v1/）、分页（?page=1）。

• 优势：简洁易扩展，前后端分离标配，需注意幂等性（PUT/DELETE）和 HTTPS 安全。