第一次提交

src/programming/backend/java/AI试题/20250522.md

@@ -0,0 +1,168 @@
+---
+icon: mdi:clipboard-text
+date: 2025-05-22
+title: "20250522"
+category:
+  - Java
+tag:
+  - 面试题
+---
+
+
+
+
+
+### 选择题
+1. 以下关于 Java 中异常处理的说法，正确的是（  ）
+   A. try 块后必须跟 catch 块
+   B. try 块后可以不跟任何 catch 块，但必须跟 finally 块
+   C. 一个 try 块可以有多个 catch 块，且异常捕获顺序无关紧要
+   D. finally 块中的代码无论是否发生异常都会执行
+
+2. 下列关于 Java 多线程的说法，错误的是（  ）
+   A. 创建线程可以通过继承 Thread 类或实现 Runnable 接口
+   B. 线程的 start() 方法会调用 run() 方法
+   C. 多个线程可以同时访问同一个共享资源而不会产生任何问题
+   D. 可以使用 synchronized 关键字来实现线程同步
+
+### 填空题
+1. Java 中用于创建对象的关键字是__________。
+2. Java 中实现多态的两种方式是__________和__________。
+
+### 简答题
+1. 请简述 Java 中的垃圾回收机制及其作用。
+2. 简述 Spring 框架中 IoC（控制反转）和 DI（依赖注入）的概念及它们之间的关系。
+
+### 编程题
+1. 编写一个 Java 程序，实现一个简单的栈（Stack）数据结构，包含入栈（push）、出栈（pop）和查看栈顶元素（peek）的方法。
+
+### 场景题
+1. 在一个分布式系统中，有多个服务需要共享缓存数据。当缓存数据更新时，如何确保各个服务能及时获取到最新的缓存数据？请描述你的解决方案。
+
+### 论述题
+1. 论述 Java 中微服务架构的优势和挑战，并结合实际案例进行说明。
+
+### 综合题
+1. 假设你正在开发一个电商系统，该系统包含商品管理、订单管理和用户管理三个模块。请设计一个 Java 程序架构，说明各个模块之间的关系以及如何使用 Java 技术实现它们之间的交互。
+
+### 选择题答案
+1. **答案**：D
+   **解析**：A选项，try块后可以不跟catch块，但必须跟finally块或者catch块，所以A错误；B选项，try块后可以既不跟catch块也不跟finally块，不过这样就失去了异常处理的意义，所以B错误；C选项，一个try块可以有多个catch块，但异常捕获顺序是有要求的，子类异常的catch块要放在父类异常的catch块之前，所以C错误；D选项，finally块中的代码无论是否发生异常都会执行，这是finally块的特性，所以D正确。
+
+2. **答案**：C
+   **解析**：A选项，在Java中创建线程可以通过继承Thread类或实现Runnable接口，这是常见的创建线程的方式，所以A正确；B选项，线程的start()方法会启动线程，然后会调用run()方法执行线程的任务，所以B正确；C选项，多个线程同时访问同一个共享资源时，如果没有进行适当的同步控制，会产生数据不一致等问题，也就是线程安全问题，所以C错误；D选项，synchronized关键字可以用来实现线程同步，保证同一时间只有一个线程可以访问被synchronized修饰的代码块或方法，所以D正确。
+
+### 填空题答案
+1. **答案**：new
+   **解析**：在Java中，使用new关键字来创建对象。例如`Object obj = new Object();`，这里的new关键字会在堆内存中为对象分配空间，并调用对象的构造方法进行初始化。
+2. **答案**：方法重载；方法重写
+   **解析**：方法重载是指在同一个类中，有多个方法具有相同的方法名，但参数列表不同（参数的类型、个数或顺序不同）。通过方法重载，我们可以根据不同的参数来调用不同的方法，这是实现多态的一种方式。方法重写是指子类重写父类的方法，要求方法名、参数列表和返回值类型都相同。在运行时，根据对象的实际类型来调用相应的方法，这也是实现多态的重要方式。
+
+### 简答题答案
+1. **答案**：Java 中的垃圾回收机制是 Java 虚拟机（JVM）提供的一种自动内存管理机制。它会自动检测和回收那些不再被引用的对象所占用的内存空间。其作用主要有：一是减轻程序员的负担，程序员不需要手动释放对象的内存，避免了因忘记释放内存而导致的内存泄漏问题；二是提高内存的使用效率，及时回收不再使用的内存，使得内存可以被其他对象使用。
+   **解析**：垃圾回收机制的核心是通过垃圾回收器（GC）来实现的。GC 会定期或在内存不足时启动，它会遍历对象的引用关系，找出那些没有被任何引用指向的对象，将这些对象标记为垃圾对象，然后回收它们所占用的内存。在 Java 中，对象的生命周期由 JVM 自动管理，程序员只需要关注对象的创建和使用，而不需要关心对象的销毁，这大大提高了开发效率和程序的稳定性。
+
+2. **答案**：IoC（控制反转）是一种设计思想，它将对象的创建和依赖关系的管理从代码中转移到外部容器中。在传统的编程方式中，对象的创建和依赖关系是在代码中硬编码的，而在 IoC 模式下，对象的创建和依赖关系的配置由外部容器负责。DI（依赖注入）是 IoC 的一种具体实现方式，它通过外部容器将对象所依赖的其他对象注入到该对象中。IoC 和 DI 的关系是：DI 是实现 IoC 的一种手段，通过 DI 可以更好地实现 IoC 的思想。
+   **解析**：在 Spring 框架中，IoC 容器（如 ApplicationContext）负责管理对象的创建和依赖关系。通过配置文件（如 XML 配置文件）或注解（如 @Autowired），可以将对象之间的依赖关系注入到相应的对象中。例如，一个类 A 依赖于类 B，在传统编程中，类 A 会在自己的代码中创建类 B 的实例，而在 Spring 中，类 A 只需要声明对类 B 的依赖，Spring 容器会自动将类 B 的实例注入到类 A 中。这样可以降低代码的耦合度，提高代码的可维护性和可测试性。
+
+### 编程题答案
+1. **示例代码**：
+```java
+import java.util.EmptyStackException;
+
+// 自定义栈类
+class MyStack {
+    private int[] stack;
+    private int top;
+    private int capacity;
+
+    // 构造函数，初始化栈的容量
+    public MyStack(int capacity) {
+        this.capacity = capacity;
+        this.stack = new int[capacity];
+        this.top = -1;
+    }
+
+    // 入栈操作
+    public void push(int item) {
+        if (top == capacity - 1) {
+            throw new StackOverflowError("Stack is full");
+        }
+        stack[++top] = item;
+    }
+
+    // 出栈操作
+    public int pop() {
+        if (top == -1) {
+            throw new EmptyStackException();
+        }
+        return stack[top--];
+    }
+
+    // 查看栈顶元素
+    public int peek() {
+        if (top == -1) {
+            throw new EmptyStackException();
+        }
+        return stack[top];
+    }
+
+    // 判断栈是否为空
+    public boolean isEmpty() {
+        return top == -1;
+    }
+}
+
+public class StackExample {
+    public static void main(String[] args) {
+        MyStack stack = new MyStack(5);
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+        System.out.println("Top element: " + stack.peek());
+        System.out.println("Popped element: " + stack.pop());
+        System.out.println("Top element after pop: " + stack.peek());
+    }
+}
+```
+**解析**：首先定义了一个`MyStack`类，它包含一个整数数组`stack`用于存储栈中的元素，`top`变量表示栈顶的位置，`capacity`表示栈的容量。构造函数`MyStack(int capacity)`用于初始化栈的容量和数组。`push(int item)`方法用于将元素入栈，如果栈已满则抛出`StackOverflowError`异常。`pop()`方法用于将栈顶元素出栈，如果栈为空则抛出`EmptyStackException`异常。`peek()`方法用于查看栈顶元素，如果栈为空则抛出`EmptyStackException`异常。`isEmpty()`方法用于判断栈是否为空。在`main`方法中，创建了一个栈对象，并进行了入栈、查看栈顶元素和出栈等操作。
+
+### 场景题答案
+1. **答案**：可以采用以下解决方案来确保各个服务能及时获取到最新的缓存数据：
+    - 使用消息队列：当缓存数据更新时，更新服务向消息队列发送一条消息，各个需要使用缓存数据的服务订阅该消息队列。当接收到消息后，这些服务会主动去获取最新的缓存数据。
+    - 缓存失效机制：更新服务在更新缓存数据时，同时将旧的缓存数据标记为失效。各个服务在访问缓存时，如果发现缓存数据失效，会重新从数据源获取最新的数据并更新缓存。
+    - 定时刷新：各个服务设置定时任务，定期从缓存中获取最新的数据。这种方式可以保证在一定时间内各个服务能获取到最新的缓存数据，但可能存在一定的延迟。
+    - 缓存更新通知：更新服务在更新缓存数据后，直接向各个服务发送更新通知，各个服务接收到通知后，立即去获取最新的缓存数据。
+
+   **解析**：使用消息队列的好处是解耦了缓存更新和服务获取数据的过程，提高了系统的可扩展性和可靠性。缓存失效机制可以确保服务在访问缓存时能获取到最新的数据，但需要注意失效标记的管理。定时刷新的方式简单易行，但可能会造成不必要的资源浪费和数据延迟。缓存更新通知可以实时通知各个服务，但需要确保通知的可靠性和及时性。在实际应用中，可以根据系统的特点和需求选择合适的解决方案，也可以将多种方案结合使用。
+
+### 论述题答案
+1. **答案**：Java 中微服务架构的优势主要有：
+    - 可扩展性：微服务架构将一个大型应用拆分成多个小型的、自治的服务，每个服务可以独立进行扩展。例如，一个电商系统中的商品服务和订单服务可以根据各自的业务需求进行独立的水平扩展，提高系统的性能和处理能力。
+    - 可维护性：每个微服务都有自己独立的代码库和开发团队，开发人员可以更专注于自己负责的服务，降低了代码的复杂度，提高了代码的可维护性。例如，当需要对商品服务进行修改时，不会影响到其他服务的正常运行。
+    - 技术多样性：不同的微服务可以使用不同的技术栈来实现，根据服务的特点选择最合适的技术。例如，对于实时性要求较高的订单服务可以使用 Java 的高性能框架，而对于数据处理和分析的服务可以使用 Python 等语言。
+    - 快速部署：微服务可以独立部署，当一个服务发生变化时，只需要部署该服务即可，不需要重新部署整个应用，提高了开发和部署的效率。
+
+   微服务架构的挑战主要有：
+    - 服务间通信：微服务之间需要进行通信，这增加了系统的复杂性。例如，需要处理网络延迟、服务故障等问题。可以使用 RESTful API、消息队列等方式来实现服务间的通信。
+    - 服务管理：随着微服务数量的增加，服务的管理变得更加困难。需要使用服务注册与发现、配置管理等工具来管理微服务。
+    - 分布式事务：在微服务架构中，一个业务操作可能涉及多个服务，需要处理分布式事务的问题。可以使用两阶段提交、补偿事务等方式来解决分布式事务问题。
+
+   实际案例：Netflix 是一个典型的使用微服务架构的公司。它将视频流服务拆分成多个微服务，如用户认证服务、视频播放服务、推荐服务等。每个服务可以独立开发、部署和扩展，提高了系统的性能和可维护性。同时，Netflix 也面临着服务间通信、服务管理等挑战，它使用了 Eureka 进行服务注册与发现，使用 Hystrix 进行服务熔断和降级，解决了微服务架构中的一些问题。
+   **解析**：微服务架构的优势在于它能够更好地适应现代软件开发的需求，提高系统的灵活性和可扩展性。但同时也带来了一些挑战，需要开发人员掌握更多的技术和工具来解决这些问题。通过实际案例可以更直观地看到微服务架构的应用和解决问题的方法。
+
+### 综合题答案
+1. **答案**：以下是一个电商系统的 Java 程序架构设计：
+
+   **模块关系**：
+    - 用户管理模块负责用户的注册、登录、信息管理等功能。用户管理模块为商品管理模块和订单管理模块提供用户信息，例如在商品浏览和下单时需要验证用户的身份。
+    - 商品管理模块负责商品的添加、修改、删除和查询等功能。商品管理模块为订单管理模块提供商品信息，订单管理模块根据商品信息生成订单。
+    - 订单管理模块负责订单的创建、支付、发货、退款等功能。订单管理模块会更新商品的库存信息，同时会记录用户的订单历史。
+
+   **实现方式**：
+    - **分层架构**：采用 MVC（Model - View - Controller）或 MVVM（Model - View - ViewModel）分层架构，将业务逻辑、数据访问和视图展示分离。例如，在商品管理模块中，Controller 层负责接收用户的请求，Service 层负责处理业务逻辑，Dao 层负责与数据库进行交互。
+    - **数据库设计**：使用关系型数据库（如 MySQL）来存储用户信息、商品信息和订单信息。不同模块对应不同的数据库表，通过外键关联来建立表之间的关系。例如，订单表中会有用户 ID 和商品 ID 字段，分别关联用户表和商品表。
+    - **服务接口**：各个模块之间通过服务接口进行交互。可以使用 RESTful API 来实现服务接口，提高系统的可扩展性和兼容性。例如，订单管理模块可以通过调用商品管理模块的 API 来获取商品信息。
+    - **消息队列**：使用消息队列（如 Kafka 或 RabbitMQ）来实现模块之间的异步通信。例如，当订单创建成功后，订单管理模块可以向消息队列发送一条消息，商品管理模块订阅该消息，接收到消息后更新商品的库存信息。
+
+   **解析**：通过分层架构可以将不同的功能模块分离，提高代码的可维护性和可测试性。数据库设计是系统的基础，合理的数据库表结构可以提高数据的存储和查询效率。服务接口的使用可以实现模块之间的解耦，使得各个模块可以独立开发和部署。消息队列的引入可以实现模块之间的异步通信，提高系统的性能和可靠性。这种架构设计可以满足电商系统的高并发、高可用性和可扩展性的需求。 

src/programming/backend/java/AI试题/20250523.md

@@ -0,0 +1,136 @@
+---
+icon: mdi:clipboard-text
+title: "20250523"
+date: 2025-05-23
+category: 
+  - JAVA
+tag:
+  - 试题
+---
+
+2025-05-23 AI试题
+<!-- more -->
+
+### 选择题
+1. 以下关于 Java 类的构造方法，说法正确的是（  ）
+   A. 构造方法必须有返回值类型
+   B. 一个类只能有一个构造方法
+   C. 构造方法的名称必须与类名相同
+   D. 构造方法不能使用访问修饰符
+
+2. 下列关于 Java 中 String 类的描述，错误的是（  ）
+   A. String 类是不可变类，一旦创建，其值不能被修改
+   B. 可以使用“+”运算符来连接两个 String 对象
+   C. String 类的对象存储在栈内存中
+   D. String 类提供了很多方法，如 equals() 用于比较两个字符串的内容是否相等
+
+### 填空题
+1. Java 中用于实现线程同步的关键字除了 synchronized 外，还有__________。
+2. 在 Java 集合框架中，__________是一个有序的、可重复的集合接口。
+
+### 简答题
+1. 简述 Java 中反射机制的概念和用途。
+2. 请说明 Java 中抽象类和接口的区别。
+
+### 编程题
+1. 编写一个 Java 程序，实现对一个整数数组进行排序，并输出排序后的数组。要求使用冒泡排序算法。
+
+### 场景题
+1. 在一个 Java Web 项目中，用户登录后，需要将用户信息存储在会话（Session）中。当用户访问其他页面时，需要验证用户是否已经登录。请描述实现该功能的步骤。
+
+### 论述题
+1. 论述 Java 中性能优化的主要方面和常用方法，并结合实际案例进行说明。
+
+### 综合题
+1. 设计一个 Java 程序，模拟一个图书馆管理系统。该系统包含图书管理、读者管理和借阅管理三个模块。图书管理模块负责图书的添加、删除和查询；读者管理模块负责读者的注册、注销和信息查询；借阅管理模块负责图书的借阅和归还操作。请说明各个模块之间的关系以及如何实现它们之间的交互。
+
+### 选择题答案
+1. **答案**：C
+   **解析**：A选项，构造方法没有返回值类型，连 void 都不能写，所以 A 错误；B选项，一个类可以有多个构造方法，这就是构造方法的重载，所以 B 错误；C选项，构造方法的名称必须与类名相同，这是构造方法的基本定义，所以 C 正确；D选项，构造方法可以使用访问修饰符，如 public、private 等，所以 D 错误。
+2. **答案**：C
+   **解析**：A选项，String 类是不可变类，一旦创建，其值不能被修改，如果对 String 对象进行修改操作，实际上是创建了一个新的 String 对象，所以 A 正确；B选项，“+”运算符可以用于连接两个 String 对象，这是 Java 中常用的字符串连接方式，所以 B 正确；C选项，String 类的对象存储在堆内存中，而不是栈内存，所以 C 错误；D选项，String 类提供了很多方法，equals() 方法用于比较两个字符串的内容是否相等，而不是比较引用是否相等，所以 D 正确。
+
+### 填空题答案
+1. **答案**：Lock
+   **解析**：在 Java 中，除了使用 synchronized 关键字实现线程同步外，还可以使用 Lock 接口及其实现类（如 ReentrantLock）来实现线程同步。Lock 提供了更灵活的锁机制，例如可以实现公平锁、可中断锁等。
+2. **答案**：List
+   **解析**：在 Java 集合框架中，List 是一个有序的、可重复的集合接口。常见的实现类有 ArrayList、LinkedList 等。List 中的元素按照插入的顺序排列，并且可以包含重复的元素。
+
+### 简答题答案
+1. **答案**：Java 中的反射机制是指在运行时动态地获取类的信息、创建对象、调用方法和访问属性等。其用途主要有：一是在框架开发中，如 Spring 框架通过反射机制实现依赖注入；二是在开发工具中，如 IDE 可以通过反射机制获取类的信息，提供代码提示等功能；三是在插件开发中，可以通过反射机制动态加载和调用插件类的方法。
+   **解析**：反射机制的核心是 Java 的 Class 类，通过 Class 类可以获取类的各种信息，如构造方法、方法、属性等。然后可以使用这些信息来创建对象、调用方法和访问属性。反射机制打破了传统的编译时绑定，使得程序在运行时可以更加灵活地处理类和对象。
+2. **答案**：Java 中抽象类和接口的区别主要有：
+    - 定义方式：抽象类使用 abstract 关键字修饰类，接口使用 interface 关键字定义。
+    - 成员变量：抽象类可以有普通成员变量，也可以有常量；接口中的成员变量默认都是 public static final 类型的常量。
+    - 方法：抽象类可以有抽象方法和非抽象方法；接口中的方法默认都是 public abstract 类型的抽象方法（Java 8 及以后支持默认方法和静态方法）。
+    - 继承和实现：一个类只能继承一个抽象类，但可以实现多个接口。
+    - 设计目的：抽象类是对一类事物的抽象，包含了一些通用的属性和方法；接口是对行为的抽象，定义了一组行为规范。
+      **解析**：抽象类和接口在 Java 中都用于实现多态和代码复用，但它们的设计目的和使用场景有所不同。抽象类更侧重于对类的抽象，而接口更侧重于对行为的抽象。在实际开发中，需要根据具体的需求来选择使用抽象类还是接口。
+
+### 编程题答案
+1. **示例代码**：
+```java
+public class BubbleSort {
+    public static void bubbleSort(int[] arr) {
+        int n = arr.length;
+        for (int i = 0; i < n - 1; i++) {
+            for (int j = 0; j < n - i - 1; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    // 交换 arr[j] 和 arr[j+1]
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {64, 34, 25, 12, 22, 11, 90};
+        bubbleSort(arr);
+        System.out.println("排序后的数组:");
+        for (int num : arr) {
+            System.out.print(num + " ");
+        }
+    }
+}
+```
+**解析**：冒泡排序算法的基本思想是比较相邻的元素，如果顺序错误就把它们交换过来。外层循环控制排序的轮数，内层循环控制每一轮比较的次数。在每一轮中，将较大的元素逐步“冒泡”到数组的末尾。最后，数组就会按照从小到大的顺序排列。
+
+### 场景题答案
+1. **答案**：实现该功能的步骤如下：
+    - 用户登录验证：当用户提交登录信息时，在服务器端验证用户的用户名和密码是否正确。如果验证通过，将用户信息（如用户 ID、用户名等）存储在会话（Session）中。
+    - 会话管理：在用户访问其他页面时，首先获取当前会话对象。检查会话中是否包含用户信息，如果包含，则说明用户已经登录；如果不包含，则说明用户未登录，将用户重定向到登录页面。
+    - 会话过期处理：为了保证系统的安全性，需要设置会话的过期时间。当会话过期后，用户需要重新登录。
+
+   **解析**：在 Java Web 项目中，可以使用 HttpSession 对象来管理会话。通过 request.getSession() 方法可以获取当前会话对象。在登录验证通过后，使用 session.setAttribute() 方法将用户信息存储在会话中。在其他页面中，使用 session.getAttribute() 方法获取用户信息进行验证。同时，可以使用 session.setMaxInactiveInterval() 方法设置会话的过期时间。
+
+### 论述题答案
+1. **答案**：Java 中性能优化的主要方面和常用方法如下：
+    - **代码层面**：
+        - 避免创建过多的对象，尽量复用对象。例如，使用 StringBuilder 代替 String 进行字符串拼接，因为 String 是不可变类，每次拼接都会创建新的对象。
+        - 减少方法调用的开销，避免在循环中频繁调用方法。
+        - 合理使用数据结构，根据不同的需求选择合适的数据结构。例如，对于频繁查找操作，使用 HashMap 比使用 ArrayList 更高效。
+    - **内存管理层面**：
+        - 及时释放不再使用的对象，避免内存泄漏。例如，在使用完文件流、数据库连接等资源后，要及时关闭。
+        - 调整 JVM 的堆内存大小，根据应用程序的实际需求合理分配堆内存。
+    - **多线程层面**：
+        - 合理使用线程池，避免频繁创建和销毁线程。例如，使用 Executors 类创建线程池。
+        - 优化线程同步机制，减少锁的竞争。例如，使用读写锁代替普通的互斥锁。
+
+   实际案例：一个电商系统在高并发场景下，用户下单时响应时间过长。通过性能优化，发现是由于在下单过程中频繁创建对象和数据库连接导致的。于是，使用对象池来复用对象，使用数据库连接池来管理数据库连接，同时调整了 JVM 的堆内存大小。经过优化后，系统的响应时间明显缩短，性能得到了显著提升。
+   **解析**：Java 性能优化需要从多个方面入手，包括代码的编写、内存的管理和多线程的使用等。通过合理的优化措施，可以提高系统的性能和响应速度，减少资源的消耗。实际案例可以帮助我们更好地理解性能优化的重要性和具体方法。
+
+### 综合题答案
+1. **答案**：
+    - **模块关系**：
+        - 读者管理模块为借阅管理模块提供读者信息，只有已注册的读者才能进行借阅和归还操作。
+        - 图书管理模块为借阅管理模块提供图书信息，借阅管理模块根据图书信息判断图书是否可借。
+        - 借阅管理模块会更新图书管理模块中的图书库存信息和读者管理模块中的读者借阅记录。
+    - **实现方式**：
+        - **数据模型**：设计数据库表来存储图书信息、读者信息和借阅记录。例如，图书表包含图书 ID、书名、作者、库存等字段；读者表包含读者 ID、姓名、联系方式等字段；借阅记录表包含借阅 ID、图书 ID、读者 ID、借阅时间、归还时间等字段。
+        - **分层架构**：采用 MVC 分层架构，将业务逻辑、数据访问和视图展示分离。每个模块都有对应的 Service 层和 Dao 层，Service 层负责处理业务逻辑，Dao 层负责与数据库进行交互。
+        - **服务接口**：各个模块之间通过服务接口进行交互。例如，借阅管理模块可以调用图书管理模块的服务接口来获取图书信息，调用读者管理模块的服务接口来验证读者信息。
+        - **异常处理**：在各个模块中添加异常处理机制，确保系统的稳定性。例如，当图书库存不足时，抛出相应的异常并进行处理。
+
+   **解析**：通过合理的模块设计和交互方式，可以实现一个功能完整、结构清晰的图书馆管理系统。数据模型的设计是系统的基础，分层架构可以提高代码的可维护性和可测试性，服务接口的使用可以实现模块之间的解耦，异常处理可以保证系统的稳定性。 

src/programming/backend/java/README.md

@@ -0,0 +1,9 @@
+---
+title: Java
+index: false
+icon: mdi:language-java
+category:
+  - Java
+---
+
+<Catalog />

src/programming/backend/java/功能整理/01XJar.md

@@ -0,0 +1,231 @@
+---
+icon: mdi:shield-lock
+date: 2025-05-13
+category:
+  - JAVA
+  - 加密
+tag:
+  - xjar
+title: XJar
+---
+
+
+XJar：保护您的Java应用程序免受反编译和源码泄露
+<!-- more -->
+# XJar：保护您的Java应用程序免受反编译和源码泄露
+
+介绍一个强大且实用的工具——**XJar**。它专为Spring Boot JAR和原生JAR提供安全加密运行支持，能够有效防止源码泄露和反编译的风险。无论你是想保护个人项目还是企业级应用，XJar都能为你提供一个简单而高效的解决方案。
+
+GitHub: https://github.com/core-lib/xjar
+
+## 什么是XJar？
+
+XJar是一个开源工具，通过对JAR包内的资源进行加密，并结合扩展的ClassLoader，构建了一套程序加密启动和动态解密运行的机制。它特别适合Spring Boot项目，同时也支持原生JAR，旨在帮助开发者保护Java应用程序的安全性。
+
+## 功能特性
+
+XJar提供了以下核心功能，让它在加密工具中脱颖而出：
+
+- **无代码侵入**：无需修改源代码，只需对编译好的JAR包进行加密即可。
+- **完全内存解密**：资源在运行时动态解密，减少源码或字节码泄露的风险。
+- **支持所有JDK内置加解密算法**：灵活选择适合你的加密算法。
+- **资源加密灵活性**：支持选择需要加密的字节码或其他资源文件。
+- **Maven插件支持**：集成到构建流程，加密更便捷。
+- **Go启动器**：动态生成Go语言启动器，保护密码不泄露。
+
+## 环境依赖
+
+- **JDK版本**：1.7及以上
+
+## 使用步骤
+
+下面我将详细介绍如何使用XJar加密你的JAR包，步骤清晰易懂。
+
+### 1. 添加依赖
+
+首先，在你的Maven项目中添加XJar依赖，并配置jitpack.io仓库：
+
+```xml
+<project>
+    <!-- 设置jitpack.io仓库 -->
+    <repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+    </repositories>
+    <!-- 添加XJar依赖 -->
+    <dependencies>
+        <dependency>
+            <groupId>com.github.core-lib</groupId>
+            <artifactId>xjar</artifactId>
+            <version>4.0.2</version>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+> **小贴士**：如果只是用JUnit测试加密过程，可以将`<scope>`设置为`test`。
+
+### 2. 加密源码
+
+使用XJar提供的`XCryptos.encryption()`方法对JAR包进行加密：
+
+```java
+XCryptos.encryption()
+        .from("/path/to/read/plaintext.jar") // 待加密JAR包路径
+        .use("io.xjar")                      // 加密密码
+        .include("/io/xjar/**/*.class")      // 需要加密的字节码
+        .include("/mapper/**/*Mapper.xml")   // 需要加密的资源文件
+        .exclude("/static/**/*")             // 排除静态文件
+        .exclude("/conf/*")                  // 排除配置文件
+        .to("/path/to/save/encrypted.jar");  // 输出加密后的JAR包
+```
+
+- `include`和`exclude`支持ANT表达式或正则表达式，灵活控制加密范围。
+- 当两者同时使用时，加密范围为`include`内排除`exclude`后的资源。
+
+### 3. 编译脚本
+
+加密完成后，XJar会在输出目录生成一个`xjar.go`文件。这是Go语言编写的启动器源码，需要编译为可执行文件：
+
+- **Windows**：编译后生成`xjar.exe`
+- **Linux**：编译后生成`xjar`
+
+编译需要Go环境，但运行时无需Go支持。注意：启动器带有防篡改校验，无法通用。
+
+### 4. 启动运行
+
+使用编译好的启动器运行加密后的JAR包：
+
+```shell
+./xjar java -Xms256m -Xmx1024m -jar /path/to/encrypted.jar
+```
+
+- 启动器需放在Java命令之前。
+- 仅支持`-jar`方式启动，不支持`-cp`或`-classpath`。
+- 使用`nohup`时，需写为：`nohup ./xjar java -jar /path/to/encrypted.jar`。
+
+## 注意事项
+
+在使用XJar时，以下问题可能影响你的体验，我整理了解决方案供参考：
+
+### 1. Spring Boot Maven插件兼容性
+
+XJar不支持`spring-boot-maven-plugin`的`executable = true`和`embeddedLaunchScript`配置，需删除：
+
+```xml
+<plugin>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-maven-plugin</artifactId>
+    <!-- 删除以下配置 -->
+    <!-- <configuration>
+        <executable>true</executable>
+        <embeddedLaunchScript>...</embeddedLaunchScript>
+    </configuration> -->
+</plugin>
+```
+
+### 2. Spring Boot + JPA(Hibernate)报错
+
+若使用Hibernate，启动可能报错。解决方法：
+
+1. 克隆[XJar-Agent-Hibernate](https://github.com/core-lib/xjar-agent-hibernate)，编译生成`xjar-agent-hibernate-${version}.jar`。
+
+2. 启动命令添加代理：
+
+   ```shell
+   ./xjar java -javaagent:xjar-agent-hibernate-${version}.jar -jar your-app.jar
+   ```
+
+### 3. 静态文件加载问题
+
+加密静态文件可能导致浏览器加载失败，建议排除加密：
+
+```java
+.exclude("/static/**/*")
+.exclude("/META-INF/resources/**/*")
+```
+
+### 4. JDK 9+模块化问题
+
+在JDK 9及以上版本，需添加参数：
+
+```shell
+./xjar java --add-opens java.base/jdk.internal.loader=ALL-UNNAMED -jar /path/to/encrypted.jar
+```
+
+### 5. 阿里云Maven镜像问题
+
+使用阿里云镜像时，需在`mirrorOf`中排除jitpack.io：
+
+```xml
+<mirror>
+    <id>alimaven</id>
+    <mirrorOf>central,!jitpack.io</mirrorOf>
+    <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
+</mirror>
+```
+
+## 插件集成
+
+XJar提供了[xjar-maven-plugin](https://github.com/core-lib/xjar-maven-plugin)，可自动完成加密过程。
+
+### 配置示例
+
+```xml
+<project>
+    <pluginRepositories>
+        <pluginRepository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </pluginRepository>
+    </pluginRepositories>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>com.github.core-lib</groupId>
+                <artifactId>xjar-maven-plugin</artifactId>
+                <version>4.0.2</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>build</goal>
+                        </goals>
+                        <phase>package</phase>
+                        <configuration>
+                            <password>io.xjar</password>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+```
+
+### 执行方式
+
+- **自动构建**：`mvn clean package -Dxjar.password=io.xjar`
+- **手动执行**：`mvn xjar:build -Dxjar.password=io.xjar`
+
+> **强烈建议**：不要在`pom.xml`中写死密码，通过命令行传递更安全！
+
+## 参数说明
+
+以下是`xjar-maven-plugin`的主要参数：
+
+| 参数名称  | 命令参数         | 参数说明     | 参数类型 | 缺省值                     |
+| --------- | ---------------- | ------------ | -------- | -------------------------- |
+| password  | -Dxjar.password  | 密码字符串   | String   | 必须                       |
+| algorithm | -Dxjar.algorithm | 加密算法名称 | String   | AES/CBC/PKCS5Padding       |
+| keySize   | -Dxjar.keySize   | 密钥长度     | int      | 128                        |
+| ivSize    | -Dxjar.ivSize    | 密钥向量长度 | int      | 128                        |
+| sourceDir | -Dxjar.sourceDir | 源JAR目录    | File     | ${project.build.directory} |
+| targetDir | -Dxjar.targetDir | 目标JAR目录  | File     | ${project.build.directory} |
+
+更多详情见：[xjar-maven-plugin](https://github.com/core-lib/xjar-maven-plugin)。
+
+## 结尾
+
+XJar以其无侵入性、灵活性和高效性，成为保护Java应用的绝佳选择。无论是个人项目还是商业产品，它都能帮你轻松加密JAR包，确保代码安全。赶快试试吧！

src/programming/backend/java/功能整理/02Maven.md

@@ -0,0 +1,38 @@
+---
+icon: mdi:package-variant
+date: 2025-05-08
+category:
+  - 实用工具
+  - JAVA
+tag:
+  - maven
+title: Maven常用配置
+---
+
+
+
+maven常用配置
+<!-- more -->
+
+# 阿里云镜像
+
+```xml
+<mirror>
+    <id>aliyunmaven</id>
+    <mirrorOf>central</mirrorOf>
+    <name>阿里云公共仓库</name>
+    <url>https://maven.aliyun.com/repository/public</url>
+</mirror>
+```
+
+# 配置代理
+```xml
+<proxy>
+      <id>http-proxy</id>
+      <active>true</active>
+      <protocol>http</protocol>
+      <host>10.6.212.9</host>
+      <port>7897</port>
+      <nonProxyHosts>localhost|127.0.0.1|*.local</nonProxyHosts>
+</proxy>
+```

src/programming/backend/java/功能整理/03WebSocket和HTTP关系.md

@@ -0,0 +1,458 @@
+---
+icon: mdi:webhook
+date: 2025-05-08
+category:
+  - JAVA
+  - 通信协议
+tag:
+  - websocket
+  - http
+title: WebSocket和HTTP关系
+---
+
+
+# WebSocket和HTTP关系
+<!-- more -->
+## 1. WebSocket简介
+
+WebSocket 是 HTML5 提供的一种在单个 TCP 连接上进行全双工通讯的协议。它使客户端和服务器之间的数据交换变得更加简单高效，并允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需完成一次握手，便可创建持久性的连接，实现双向数据传输。
+
+## 2. WebSocket与HTTP的关系
+
+### 2.1 协议转换过程
+
+WebSocket依赖于HTTP连接初始化，但随后会进行协议升级。具体转换过程如下：
+
+1. **初始HTTP请求**：每个WebSocket连接都始于一个HTTP请求。客户端发送标准的HTTP请求，但包含特殊的头信息，表明希望升级为WebSocket协议：
+
+```
+GET /chat HTTP/1.1
+Host: server.example.com
+Upgrade: websocket
+Connection: Upgrade
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
+Origin: http://example.com
+Sec-WebSocket-Version: 13
+```
+
+2. **服务器响应升级**：如果服务器支持WebSocket协议，会返回101状态码，表示协议正在切换：
+
+```
+HTTP/1.1 101 Switching Protocols
+Upgrade: websocket
+Connection: Upgrade
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
+```
+
+3. **协议切换完成**：此时HTTP请求已完成其使命，如果协议升级成功，客户端会触发`onopen`事件；否则触发`onerror`事件。此后的所有通信都使用WebSocket协议，不再依赖HTTP。
+
+### 2.2 为什么WebSocket要依赖HTTP协议连接？
+
+WebSocket选择依赖HTTP协议有几个重要原因：
+
+1. **设计理念**：WebSocket设计之初就是为HTTP增强通信能力（尤其是全双工通信），因此在HTTP协议基础上扩展是自然的选择，能够复用HTTP的基础设施。
+
+2. **最大兼容性**：基于HTTP连接可获得最广泛的兼容支持。即使服务器不支持WebSocket，也能建立HTTP通信并返回相应错误，这比完全无响应要好得多。
+
+3. **防火墙友好**：大多数网络环境允许HTTP流量通过（80和443端口），基于HTTP的WebSocket更容易穿越防火墙和代理服务器。
+
+4. **减少实现复杂度**：复用现有的HTTP基础设施，无需从零开始构建新的协议栈。
+
+### 2.3 HTTP与WebSocket的主要区别
+
+|特性|HTTP|WebSocket|
+|---|---|---|
+|连接类型|无状态、短连接|有状态、长连接|
+|通信方式|单向（请求-响应）|双向（全双工）|
+|数据交互模式|客户端主动请求|双方均可主动发送|
+|数据传输量|每次请求都有HTTP头|握手后数据传输更轻量|
+|实时性|弱（通常需轮询）|强（可即时推送）|
+|使用场景|传统网页请求、RESTful API|聊天应用、实时数据更新、在线游戏等|
+
+## 3. WebSocket的优势与应用场景
+
+相比传统HTTP，WebSocket具有以下优势：
+
+1. **降低延迟**：一旦建立连接，通信双方可随时发送数据，无需重复建立连接。
+
+2. **减少网络流量**：WebSocket在握手后的通信中没有HTTP头的开销，数据传输更高效。
+
+3. **实时双向通信**：服务器可以主动推送信息给客户端，无需客户端轮询。
+
+4. **保持连接状态**：WebSocket是有状态协议，可维护连接上下文信息。
+
+典型应用场景：
+- 实时通讯应用（聊天室、即时通讯工具）
+- 在线协作工具（协同编辑文档）
+- 实时数据展示（股票行情、体育赛事直播）
+- 游戏应用（在线多人游戏）
+- 物联网设备通信
+
+## 4. 总结
+
+WebSocket与HTTP是相辅相成的关系，而非替代关系。WebSocket通过HTTP协议完成初始握手，随后升级为独立的协议，实现更高效的双向通信。两种协议各有优势，应根据应用场景选择合适的通信方式。在需要实时性、双向通信的场景中，WebSocket展现出明显优势；而对于简单的数据获取和传统网页浏览，HTTP仍然是最佳选择。
+
+## 5. 案例（服务端）
+### 5.1 项目结构
+![1746684922168.png](../../../../tools/assets/20210721105228.png)
+
+### 5.2 依赖配置
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.4.3</version>
+        <relativePath/>
+    </parent>
+
+
+    <artifactId>websocket</artifactId>
+    <packaging>jar</packaging>
+
+    <name>websocket</name>
+    <url>http://maven.apache.org</url>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-websocket</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+### 5.3 主应用类
+```java
+package com.mangmang;
+
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class WebSocketDemoApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(WebSocketDemoApplication.class, args);
+    }
+}
+```
+### 5.4 WebSocket配置类
+```java
+package com.mangmang.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
+import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
+
+@Configuration
+@EnableWebSocketMessageBroker
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+
+    @Override
+    public void registerStompEndpoints(StompEndpointRegistry registry) {
+        // 注册STOMP协议的节点(endpoint)
+        registry.addEndpoint("/ws").setAllowedOrigins("http://10.6.212.39:5173/");
+    }
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry registry) {
+        // 配置消息代理，前缀为/topic的消息将会被路由到消息代理
+        registry.enableSimpleBroker("/topic");
+        // 以/app开头的消息将会被路由到@MessageMapping注解的方法中
+        registry.setApplicationDestinationPrefixes("/app");
+    }
+
+}
+```
+### 5.5 消息实体类
+```java
+package com.mangmang.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+import lombok.NoArgsConstructor;
+
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Message {
+    private String content;
+    private String sender;
+    private MessageType type;
+
+
+    public enum MessageType {
+        CHAT,
+        JOIN,
+        LEAVE
+    }
+}
+```
+
+### 5.6 消息控制类
+```
+package com.mangmang.controller;
+
+import com.mangmang.model.Message;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.messaging.handler.annotation.MessageMapping;
+import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.messaging.handler.annotation.SendTo;
+import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
+import org.springframework.stereotype.Controller;
+
+import java.util.Objects;
+
+@Slf4j
+@Controller
+public class MessageController {
+
+    @MessageMapping("/chat.sendMessage")
+    @SendTo("/topic/public")
+    public Message sendMessage(@Payload Message message) {
+        log.info(message.toString());
+        return message;
+    }
+
+
+    @MessageMapping("/chat.addUser")
+    @SendTo("/topic/public")
+    public Message addUser(@Payload Message message, SimpMessageHeaderAccessor headerAccessor) {
+        log.info(message.toString());
+        // 将用户名添加到WebSocket会话
+        Objects.requireNonNull(headerAccessor.getSessionAttributes()).put("username", message.getSender());
+        return message;
+    }
+}
+```
+
+### 5.7 websocket断连通知类
+```java
+package com.mangmang.listener;
+
+import com.mangmang.model.Message;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.event.EventListener;
+import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
+import org.springframework.messaging.simp.SimpMessageSendingOperations;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.messaging.SessionDisconnectEvent;
+
+import java.util.Objects;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class WebSocketEventListener {
+
+    private final SimpMessageSendingOperations messagingTemplate;
+
+    @EventListener
+    public void handleWebSocketDisconnectListener(SessionDisconnectEvent event) {
+        // 获取会话属性
+        SimpMessageHeaderAccessor headerAccessor = SimpMessageHeaderAccessor.wrap(event.getMessage());
+
+        // 从会话中获取用户名
+        String username = (String) Objects.requireNonNull(headerAccessor.getSessionAttributes()).get("username");
+
+        if (username != null) {
+            log.info("用户断开连接: {}", username);
+
+            // 创建一个离开消息
+            Message message = Message.builder()
+                    .type(Message.MessageType.LEAVE)
+                    .sender(username)
+                    .content("下线了")
+                    .build();
+
+            // 发送消息到公共主题
+            messagingTemplate.convertAndSend("/topic/public", message);
+        }
+    }
+}
+```
+
+## 6. 案例（客户端）
+### 6.1 封装websocket
+```ts
+import {Client} from '@stomp/stompjs';
+
+interface ChatMessage {
+    content: string;
+    sender: string;
+    type: 'CHAT' | 'JOIN' | 'LEAVE';
+}
+
+class WebSocketService {
+    private stompClient: Client | null = null;
+
+    connect(username: string, onMessageReceived: (msg: ChatMessage) => void) {
+        // 创建原生 WebSocket 连接
+        const socket = new WebSocket('ws://10.6.212.39:8099/ws'); // 确保这里是 WebSocket 协议
+
+        this.stompClient = new Client({
+            webSocketFactory: () => socket,
+            onConnect: () => {
+                console.log('STOMP connected');
+                // 订阅公共主题
+                this.stompClient?.subscribe('/topic/public', (message) => {
+                    const chatMsg: ChatMessage = JSON.parse(message.body);
+                    onMessageReceived(chatMsg);
+                });
+
+                // 发送用户加入消息
+                this.sendAddUserMessage(username);
+            },
+            onStompError: (frame) => {
+                console.error('Broker reported error: ', frame.headers['message']);
+                console.error('Additional details: ', frame.body);
+            },
+            // 关闭时清理资源
+            onDisconnect: () => {
+                console.log('Disconnected from STOMP');
+                this.stompClient = null;
+            }
+        });
+
+        // 激活客户端
+        this.stompClient.activate();
+    }
+
+    sendMessage(chatMessage: Omit<ChatMessage, 'type'>) {
+        if (this.stompClient?.connected) {
+            this.stompClient.publish({
+                destination: '/app/chat.sendMessage',
+                body: JSON.stringify(chatMessage),
+            });
+        } else {
+            console.warn('WebSocket not connected');
+        }
+    }
+
+    sendAddUserMessage(username: string) {
+        if (this.stompClient?.connected) {
+            this.stompClient.publish({
+                destination: '/app/chat.addUser',
+                body: JSON.stringify({content: "加入聊天", sender: username, type: 'JOIN'}),
+            });
+        }
+    }
+
+    disconnect() {
+        if (this.stompClient) {
+            this.stompClient.deactivate();
+            this.stompClient = null;
+        }
+    }
+}
+
+export default new WebSocketService();
+```
+
+### 6.2 页面
+```vue
+<script setup lang="ts">
+import { ref, onMounted, onBeforeUnmount } from 'vue';
+import wsService from '../utils/websocket.service';
+
+const messages = ref<{ content: string; sender: string; type: 'CHAT' | 'JOIN' | 'LEAVE' }[]>([]);
+const messageInput = ref('');
+const username = ref(''); // 可替换为动态用户名
+
+// 处理发送消息
+function handleSendMessage() {
+  const content = messageInput.value.trim();
+  if (!content) return;
+
+  wsService.sendMessage({
+    content,
+    sender: username.value,
+  });
+
+  messageInput.value = '';
+}
+
+// 接收消息回调
+function onMessageReceived(msg: { content: string; sender: string; type: 'CHAT' | 'JOIN' | 'LEAVE' }) {
+  messages.value.push(msg);
+}
+
+function createConnect(){
+  // 建立连接并注册消息回调
+  wsService.connect(username.value, onMessageReceived);
+}
+
+onMounted(() => {
+
+});
+
+onBeforeUnmount(() => {
+  // 组件卸载前断开连接
+  wsService.disconnect();
+});
+
+</script>
+
+<template>
+  <div class="chat-container">
+    <h2>WebSocket 聊天室</h2>
+    <input v-model="username" placeholder="输入姓名" @keyup.enter="createConnect">
+    <div class="messages">
+      <div v-for="(msg, index) in messages" :key="index" class="message">
+        <strong>{{ msg.sender }}:</strong> {{ msg.content }}
+      </div>
+    </div>
+    <input
+        v-model="messageInput"
+        @keyup.enter="handleSendMessage"
+        placeholder="输入消息..."
+    />
+  </div>
+</template>
+
+<style scoped>
+.chat-container {
+  max-width: 600px;
+  margin: auto;
+  padding: 20px;
+}
+.messages {
+  border: 1px solid #ccc;
+  padding: 10px;
+  height: 300px;
+  overflow-y: auto;
+  margin-bottom: 10px;
+}
+.message {
+  margin-bottom: 5px;
+}
+input {
+  width: 100%;
+  padding: 8px;
+}
+</style>
+
+
+```

src/programming/backend/java/功能整理/05防止表单和参数重复提交.md

@@ -0,0 +1,765 @@
+---
+date: 2025-05-07
+category:
+  - JAVA
+tag:
+  - 表单
+  - 重复提交
+  - 防重
+icon: lock
+---
+
+防止表单和参数重复提交案例
+<!-- more -->
+# 防止表单和参数重复提交
+
+## 1. 编写注解
+
+```java
+/**
+ * 防止表单重复提交
+ *
+ * @author 氓氓编程
+ * @Date: 2021-06-08-16:35
+ * @Inherited @interface 自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节
+ * @Target 用于描述注解的使用范围（作用于方法上）
+ * @Retention 被描述的注解在什么范围内有效 （在运行时有效，即运行时保留）
+ */
+@Inherited
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface RepeatSubmit {
+
+}
+```
+
+## 2. 自定义拦截器
+
+```java
+/**
+ * @author 茫茫编程
+ * @Date: 2021-06-08-16:29
+ */
+@Slf4j
+@Component
+public abstract class RepeatSubmitInterceptor extends HandlerInterceptorAdapter {
+    /**
+     * @param request  是指经过spring封装的请求对象, 包含请求地址, 头, 参数, body(流)等信息.
+     * @param response 是指经过spring封装的响应对象, 包含输入流, 响应body类型等信息.
+     * @param handler  是指controller的@Controller注解下的"完整"方法名, 是包含exception等字段信息的.
+     * @return  是否放行
+     * @throws Exception 异常
+     */
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        //instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
+        if (handler instanceof HandlerMethod) {
+            log.info("进来了");
+            //把handler强转为HandlerMethod
+            HandlerMethod handlerMethod = (HandlerMethod) handler;
+            //获取当前请求的方法
+            Method method = handlerMethod.getMethod();
+            //获取当前去请求方法上是否有注解@RepeatSubmit
+            RepeatSubmit repeatSubmit = method.getAnnotation(RepeatSubmit.class);
+            //如果方法有@RepeatSubmit注解，进入if
+            if (repeatSubmit != null) {
+                //判断是否是重复提交，重复提交进入
+                if (isRepeatSubmit(request, response)) {
+                    //返回消息实体类
+                    R message = R.error().message("不允许重复提交");
+                    //把消息响应给客户端
+                    ServletUtils.renderString(response, JSONUtil.toJsonStr(message));
+                    //拦截
+                    return false;
+                }
+            }
+            //注解和不重复直接放行
+            return true;
+        } else {
+            //如果handler不是HandlerMethod或子类放行
+            return super.preHandle(request, response, handler);
+        }
+    }
+
+    /**
+     * 弗雷调用该方法会使用子类的实现
+     * 验证是否重复提交由子类实现具体的防重复提交的规则
+     *
+     * @param request 请求
+     * @return 是否是重复提交
+     */
+    public abstract boolean isRepeatSubmit(HttpServletRequest request,HttpServletResponse response);
+}
+```
+
+## 3. 自定义拦截器子类
+
+```java
+/**
+ * 判断请求url和数据是否和上一次相同，
+ * 如果和上次相同，则是重复提交表单。 有效时间为10秒内。
+ *
+ * @author 氓氓编程
+ * @Date: 2021-06-08-17:27
+ */
+@Slf4j
+@Component
+public class SameUrlDataInterceptor extends RepeatSubmitInterceptor {
+    /**
+     * 重复参数
+     */
+    public final String REPEAT_PARAMS = "repeatParams";
+
+    /**
+     * 重复时间
+     */
+    public final String REPEAT_TIME = "repeatTime";
+
+    /**
+     * 间隔时间单位秒
+     * 两次相同参数的请求，如果间隔时间大于该参数，系统不会认定为重复提交的数据
+     */
+    private int intervalTime = 120;
+
+    public SameUrlDataInterceptor(JwtUtil jwtUtil, RedisCache redisCache) {
+        this.jwtUtil = jwtUtil;
+        this.redisCache = redisCache;
+    }
+
+    public void setIntervalTime(int intervalTime) {
+        this.intervalTime = intervalTime;
+    }
+
+    private final JwtUtil jwtUtil;
+
+    /**
+     * 注入redis
+     */
+    private final RedisCache redisCache;
+
+    /**
+     * 重写父类判断是否重复的抽象方法
+     *
+     * @param request 请求
+     * @return true=重复提交  false=未重复
+     */
+    @SneakyThrows
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean isRepeatSubmit(HttpServletRequest request, HttpServletResponse response)  {
+        //1.声明当前参数
+        String nowParams = null;
+        //判断请求是否为空
+        if (request != null) {
+            //把request 转为可重复获取流的RepeatedlyRequestWrapper
+            RepeatedlyRequestWrapper repeatedlyRequest = new RepeatedlyRequestWrapper(request, response);
+            //获取body参数
+            nowParams = RepeatedlyRequestWrapper.getBodyString(repeatedlyRequest);
+        }
+        //如果请求体body参数为空，获取Parameter的参数
+        if (StringUtils.isEmpty(nowParams)) {
+            assert request != null;
+            nowParams = JSONUtil.toJsonStr(request.getParameterMap());
+            log.info("body=={}", nowParams);
+        }
+        //把数据存储起来
+        Map<String, Object> nowMap = new HashMap<>(80);
+        nowMap.put(REPEAT_PARAMS, nowParams);
+        nowMap.put(REPEAT_TIME, System.currentTimeMillis());
+        log.info("nowMap=={}", nowMap);
+
+        // 请求地址（作为存放cache的key值）
+        String url = request.getRequestURI();
+
+        //唯一标识-获取请求头的token值
+        String submitKey = request.getHeader(jwtUtil.getHeader());
+        //如果token为空,使用请求地址作为key
+        if (StringUtils.isEmpty(submitKey)) {
+            submitKey = url;
+        }
+        //唯一标识（指定key+消息头）
+        String cacheRepeatKey = "repeat_submit:" + submitKey;
+        log.info("repeat_submit=={}", cacheRepeatKey);
+
+        //缓存中获取上次请求数据
+        Object cacheObject = redisCache.getCacheObject(cacheRepeatKey);
+        log.info("cacheObject=={}", cacheObject);
+        //如果缓存中没有数据，则存放
+        if (cacheObject == null) {
+            Map<String, Object> cacheMap = new HashMap<>(109);
+            cacheMap.put(url, nowMap);
+            redisCache.setCacheObject(cacheRepeatKey, cacheMap, intervalTime, TimeUnit.SECONDS);
+        } else {
+            //强转为map
+            Map<String, Object> preDataMap = (Map<String, Object>) cacheObject;
+            //判断该map是否有url作为的键
+            if (preDataMap.containsKey(url)) {
+                //根据map中的键url 获取对应的参数
+                Map<String, Object> preMap = (Map<String, Object>) preDataMap.get(url);
+                return compareParams(nowMap, preMap) && compareTime(nowMap, preMap);
+            }
+        }
+
+        return false;
+    }
+    
+    /**
+     * 比较两次请求参数是否相同
+     *
+     * @param nowMap 现在的数据
+     * @param preMap 之前的数据
+     * @return true=相同  false=不相同
+     */
+    private boolean compareParams(Map<String, Object> nowMap, Map<String, Object> preMap) {
+        String now = (String) nowMap.get(REPEAT_PARAMS);
+        String pre = (String) preMap.get(REPEAT_PARAMS);
+        return now.equals(pre);
+    }
+
+    /**
+     * 比较两次请求时间间隔
+     *
+     * @param nowMap 现在的数据
+     * @param preMap 之前的数据
+     * @return true=相同  false=不相同
+     */
+    private boolean compareTime(Map<String, Object> nowMap, Map<String, Object> preMap) {
+        long now = (Long) nowMap.get(REPEAT_TIME);
+        long pre = (Long) preMap.get(REPEAT_TIME);
+        //如果两次间隔时间小于10秒
+        return (now - pre) < this.intervalTime * 1000L;
+    }
+} 
+```
+
+## 4. 配置拦截器到web中
+
+```java
+/**
+ * @author 氓氓编程
+ */
+@Configuration
+public class CorsConfig implements WebMvcConfigurer {
+
+    private final RepeatSubmitInterceptor repeatSubmitInterceptor;
+	//构造方法注入
+    public CorsConfig(RepeatSubmitInterceptor repeatSubmitInterceptor) {
+        this.repeatSubmitInterceptor = repeatSubmitInterceptor;
+    }
+	
+    
+     /**
+     * 解决跨域
+     * @return  CorsFilter
+     */
+    @Bean
+    public CorsFilter corsFilter() {
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        CorsConfiguration configuration = new CorsConfiguration();
+        // 设置访问源地址(允许那些地址访问服务器)
+        configuration.addAllowedOrigin("*");
+        // 设置访问源请求方法（方法）
+        configuration.addAllowedMethod("*");
+        // 设置访问源请求头（头部信息）
+        configuration.addAllowedHeader("*");
+        // 跨域需要暴露的请求头（因为跨域访问默认不能获取全部头部信息）
+        configuration.addExposedHeader("token");
+        // 注册配置
+        source.registerCorsConfiguration("/**", configuration);
+        return new CorsFilter(source);
+    }
+
+	/**
+     * 添加拦截器
+     * @param registry registry
+     */
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(repeatSubmitInterceptor);
+    }
+}
+
+```
+
+## 5. redis
+
+### 5.1  配置
+
+```java
+**
+ * @author 氓氓编程
+ * 
+ */
+@Configuration
+public class RedisCacheConfig extends CachingConfigurerSupport {
+    @Bean
+    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
+        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(redisConnectionFactory);
+        //key序列化
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        //value序列化
+        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
+}
+```
+
+> 以下是需要用到的工具类
+
+### 5.2 redis 工具类
+
+```java
+/**
+ * Redis 工具类
+ *
+ * @author 氓氓编程
+ * @Date: 2021-06-08-17:35
+ */
+@Component
+public class RedisCache {
+
+    private final RedisTemplate<Object, Object> redisTemplate;
+
+
+    public RedisCache(RedisTemplate<Object, Object> redisTemplate) {
+        this.redisTemplate = redisTemplate;
+    }
+
+
+    /**
+     * 缓存基本对象，Integer、String、实体类等
+     *
+     * @param key   键
+     * @param value 值
+     */
+    public void setCacheObject(final String key, final Object value) {
+        redisTemplate.opsForValue().set(key, value);
+    }
+
+    /**
+     * 带有效时间缓存基本对象，Integer、String、实体类等
+     *
+     * @param key      键
+     * @param value    值
+     * @param timeout  有效时间
+     * @param timeUnit 有效时间单位
+     */
+    public void setCacheObject(final String key, final Object value, final Integer timeout, final TimeUnit timeUnit) {
+        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
+    }
+
+    /**
+     * 给某个键设置有效时间
+     *
+     * @param key     需要设置有效时间的键
+     * @param timeout 设置的时间  默认是秒
+     * @return true=设置成功  false=设置失败
+     */
+    public boolean expire(final String key, final long timeout) {
+        return expire(key, timeout, TimeUnit.SECONDS);
+    }
+
+
+    /**
+     * 给某个键设置有效时间
+     *
+     * @param key      需要设置有效时间的键
+     * @param timeout  设置的时间
+     * @param timeUnit 有效时间单位
+     * @return true=设置成功  false=设置失败
+     */
+    public boolean expire(final String key, final long timeout, final TimeUnit timeUnit) {
+        Boolean isSuccess = redisTemplate.expire(key, timeout, timeUnit);
+        if (isSuccess != null) {
+            return isSuccess;
+        }
+        return false;
+    }
+
+    /**
+     * 根据键获取某个缓存的值
+     *
+     * @param key 键
+     * @return Object
+     */
+    public Object getCacheObject(final String key) {
+        return redisTemplate.opsForValue().get(key);
+    }
+
+
+    /**
+     * 根据建删除缓存
+     *
+     * @param key 键
+     * @return true=成功 false=失败
+     */
+    public boolean deleteObject(final String key) {
+        Boolean isDelete = redisTemplate.delete(key);
+        return isDelete != null && isDelete;
+    }
+
+    /**
+     * 根据键批量删除
+     *
+     * @param collection 装有键的集合
+     * @return 删除成功的数量
+     */
+    public long deleteObject(final Collection<Object> collection) {
+        Long count = redisTemplate.delete(collection);
+        return count == null ? 0 : count;
+    }
+
+    /**
+     * 缓存List集合数据
+     *
+     * @param key      键
+     * @param dataList 待缓存的List数据
+     * @return 缓存成功的数量
+     */
+    public long setCacheList(final String key, final List<Object> dataList) {
+        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
+        return count == null ? 0 : count;
+    }
+
+    /**
+     * 获取List缓存数据
+     *
+     * @param key 键
+     * @return 缓存键值对应的数据
+     */
+    public List<Object> getCacheList(final String key) {
+        return redisTemplate.opsForList().range(key, 0, -1);
+    }
+
+    /**
+     * 缓存Set
+     *
+     * @param key     键
+     * @param dataSet 待缓存的Set数据
+     * @return 缓存数据的对象
+     */
+    public BoundSetOperations<Object, Object> setCacheSet(final String key, final Set<Object> dataSet) {
+        BoundSetOperations<Object, Object> setOperations = redisTemplate.boundSetOps(key);
+        Iterator<Object> it = dataSet.iterator();
+        if (it.hasNext()) {
+            setOperations.add(it.next());
+        }
+        return setOperations;
+    }
+
+
+    /**
+     * 获取Set缓存数据
+     *
+     * @param key 键
+     * @return 缓存键值对应的数据
+     */
+    public Set<Object> getCacheSet(final String key) {
+        return redisTemplate.opsForSet().members(key);
+    }
+
+    /**
+     * @param key     键
+     * @param dataMap 缓存的map数据
+     */
+    public void setCacheMap(final String key, final Map<String, Object> dataMap) {
+        if (dataMap != null) {
+            redisTemplate.opsForHash().putAll(key, dataMap);
+        }
+    }
+
+
+    /**
+     * 获得缓存的Map
+     *
+     * @param key 键
+     * @return 获得缓存的数据
+     */
+    public Map<Object, Object> getCacheMap(final String key) {
+        return redisTemplate.opsForHash().entries(key);
+    }
+
+
+    /**
+     * 往Hash中存入数据
+     *
+     * @param key   Redis键
+     * @param hKey  Hash键
+     * @param value 值
+     */
+    public void setCacheMapValue(final String key, final String hKey, final Object value) {
+        redisTemplate.opsForHash().put(key, hKey, value);
+    }
+
+    /**
+     * 获取Hash中的数据
+     *
+     * @param key  Redis键
+     * @param hKey Hash键
+     * @return Hash中的对象
+     */
+    public Object getCacheMapValue(final String key, final String hKey) {
+        return redisTemplate.opsForHash().get(key, hKey);
+    }
+
+    /**
+     * 获取多个Hash中的数据
+     *
+     * @param key   Redis键
+     * @param hKeys Hash键集合
+     * @return Hash对象集合
+     */
+    public List<Object> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
+        return redisTemplate.opsForHash().multiGet(key, hKeys);
+    }
+
+    /**
+     * 获得缓存的基本对象列表
+     *
+     * @param pattern 字符串前缀
+     * @return 对象列表
+     */
+    public Collection<Object> keys(final String pattern) {
+        return redisTemplate.keys(pattern);
+    }
+}
+```
+
+## 6. Servlet参数发送的工具类
+
+```java
+/**
+ * 客户端工具类
+ *
+ * @author 氓氓编程
+ * @Date: 2021-06-08-16:50
+ */
+public class ServletUtils {
+    /**
+     * 获取String参数
+     */
+    public static String getParameter(String name) {
+        return getRequest().getParameter(name);
+    }
+
+    /**
+     * 获取String参数,如墨没有设置一个默认值
+     */
+    public static String getParameter(String name, String defaultValue) {
+        return Convert.toStr(getRequest().getParameter(name), defaultValue);
+    }
+
+    /**
+     * 获取session
+     */
+    public static HttpSession getSession() {
+        return getRequest().getSession();
+    }
+
+    /**
+     * 获取Integer参数
+     */
+    public static Integer getParameterToInt(String name) {
+        return Convert.toInt(getRequest().getParameter(name));
+    }
+
+    /**
+     * 获取response
+     */
+    public static HttpServletResponse getResponse() {
+        return getRequestAttributes().getResponse();
+    }
+
+    /**
+     * 获取request
+     */
+    public static HttpServletRequest getRequest() {
+        return getRequestAttributes().getRequest();
+    }
+
+    /**
+     * 获取到当前的HttpServletRequest
+     *
+     * @return ServletRequestAttributes
+     */
+    public static ServletRequestAttributes getRequestAttributes() {
+        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
+        return (ServletRequestAttributes) attributes;
+    }
+
+    /**
+     * @param response 当前请求的响应
+     * @param string   传输的文字
+     */
+    public static void renderString(HttpServletResponse response, String string) {
+        try {
+            response.setStatus(200);
+            response.setContentType("application/json");
+            response.setCharacterEncoding("UTF-8");
+            response.getWriter().print(string);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+} 
+```
+
+## 7. 可重复读取流的RepeatedlyRequestWrapper 
+
+```java
+/**
+ * 构建可重复读取inputStream的请求request
+ *
+ * @author 氓氓编程
+ * @Date: 2021-06-09-8:47
+ */
+@Slf4j
+public class RepeatedlyRequestWrapper extends HttpServletRequestWrapper {
+
+    /**
+     * 存放请求体中的数据
+     */
+    private final byte[] body;
+
+    public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws UnsupportedEncodingException {
+        super(request);
+        request.setCharacterEncoding("UTF-8");
+        response.setCharacterEncoding("UTF-8");
+        this.body = getBodyString(request).getBytes(StandardCharsets.UTF_8);
+    }
+
+    @Override
+    public BufferedReader getReader() {
+        return new BufferedReader(new InputStreamReader(getInputStream()));
+    }
+
+    @Override
+    public ServletInputStream getInputStream(){
+        //1.创建一个字节数组流存放请求体
+        final ByteArrayInputStream bodyInputStream = new ByteArrayInputStream(body);
+        //2.返回获取的body中的数据流
+        return new ServletInputStream() {
+            @Override
+            public int read(){
+                return bodyInputStream.read();
+            }
+
+            @Override
+            public int available(){
+                return body.length;
+            }
+
+            @Override
+            public boolean isFinished() {
+                return false;
+            }
+
+            @Override
+            public boolean isReady() {
+                return false;
+            }
+
+            @Override
+            public void setReadListener(ReadListener readListener) {
+
+            }
+        };
+    }
+
+
+    /**
+     * 获取请求体
+     *
+     * @param request 请求
+     * @return 字符串
+     */
+    public static String getBodyString(ServletRequest request) {
+        //1.创建一个StringBuilder
+        StringBuilder sb = new StringBuilder();
+        //2.声明一个读缓存的流
+        BufferedReader reader = null;
+        //3.获取请求中的流
+        try (InputStream inputStream = request.getInputStream()) {
+            //把请求中的流读取出来给reader
+            reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
+            //声明line存放每一行的数据
+            String line;
+            //一行一行的读取数据并赋值给line，line不为空
+            while ((line = reader.readLine()) != null) {
+                //追加写入
+                sb.append(line);
+            }
+        } catch (IOException e) {
+            log.warn("获取请求体中数据出现问题");
+        } finally {
+            //如果reader不为空，关闭流
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                    log.error(ExceptionUtil.getMessage(e));
+                }
+            }
+        }
+        return sb.toString();
+    }
+}
+
+```
+
+## 8. 让可重复读的流生效
+
+```java
+/**
+ * 使用重写后的RepeatedlyRequestWrapper
+ * <p>
+ * Repeatable 过滤器
+ */
+public class RepeatableFilter implements Filter {
+    /**
+     * startsWithIgnoreCase 判断开始部分是否与二参数相同。不区分大小写
+     *
+     * @param request  请求
+     * @param response 响应
+     * @param chain    放行
+     * @throws IOException      io异常
+     * @throws ServletException 异常
+     */
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        //声明一个ServletRequest
+        ServletRequest requestWrapper = null;
+        //判断request是HttpServletRequest或子类并且request.getContentType()开头包含application/json
+        if (request instanceof HttpServletRequest && StringUtils.startsWithIgnoreCase(request.getContentType(), MediaType.APPLICATION_JSON_VALUE)) {
+            //创建一个可重复获取流的RepeatedlyRequestWrapper赋值给ServletRequest
+            requestWrapper = new RepeatedlyRequestWrapper((HttpServletRequest) request, response);
+        }
+        //为空，直接放行
+        if (null == requestWrapper) {
+            chain.doFilter(request, response);
+        } else {
+            //赋值完毕可重复读流继续向下传
+            chain.doFilter(requestWrapper, response);
+        }
+    }
+}
+```
+
+```java
+ 	@SuppressWarnings({ "rawtypes", "unchecked" })
+    @Bean
+    public FilterRegistrationBean someFilterRegistration() {
+        FilterRegistrationBean registration = new FilterRegistrationBean();
+        registration.setFilter(new RepeatableFilter());
+        registration.addUrlPatterns("/*");
+        registration.setName("repeatableFilter");
+        registration.setOrder(FilterRegistrationBean.LOWEST_PRECEDENCE);
+        return registration;
+    }
+```
+