当前位置： 首页 > article >正文

幂等性小记

article 2024/11/13 12:52:35


1、什么是幂等性


幂等性是指一个操作无论执行多少次，其结果都是相同的。在计算机科学中，特别是在网络请求和数据库操作中，幂等性是一个重要的概念。也就是说，重复执行某个操作不会对系统的状态产生额外的影响。

2、幂等性的使用场景


2.1. HTTP请求


  - GET请求：获取资源的请求，重复请求不会改变资源的状态。
  - PUT请求：用于更新资源，重复执行相同的更新请求，其结果保持一致。
  - DELETE请求：删除资源的请求，重复执行不会造成错误，结果始终是资源被删除。

//示例1：幂等的HTTP PUT请求
import java.net.HttpURLConnection;
import java.net.URL;

public class IdempotentHttpPut {
    public static void main(String[] args) throws Exception {
        String url = "http://example.com/api/users/1";
        String jsonInputString = "{\"email\": \"example@example.com\"}";

        for (int i = 0; i < 3; i++) {
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setRequestMethod("PUT");
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.getOutputStream().write(jsonInputString.getBytes("UTF-8"));
            connection.getResponseCode(); // 发送请求
            connection.disconnect();
        }
    }
}

2.2. 数据库操作


  - 更新用户信息：如更新用户的电子邮件地址，重复更新不会导致数据不一致。
  - 插入记录：在插入记录前检查记录是否存在，以避免重复插入。

3、数据库操作幂等性分析


在数据库中，幂等性通常通过设计来实现。例如：
- UPDATE操作：如  UPDATE users SET email = 'example@example.com' WHERE id = 1 ，无论执行多少次，用户ID为1的电子邮件始终是 example@example.com 。
- INSERT操作：可以使用  INSERT IGNORE  或者  INSERT ... ON DUPLICATE KEY UPDATE  语句，确保即使多次执行也不会导致重复记录。

- 示例：数据库操作的幂等性


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class IdempotentDatabaseUpdate {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String user = "root";
        String password = "password";

        try (Connection connection = DriverManager.getConnection(url, user, password)) {
            String sql = "UPDATE users SET email = ? WHERE id = ?";
            try (PreparedStatement statement = connection.prepareStatement(sql)) {
                statement.setString(1, "example@example.com");
                statement.setInt(2, 1);
                statement.executeUpdate(); // 执行更新
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


4、如何避免重复提交


4.1. 使用唯一标识符

        为每个请求生成一个唯一的ID，服务器在处理请求时检查该ID是否已处理过。
  在Web应用程序中，用户可能因为网络延迟、误操作或者其他原因导致重复提交相同的请求。为了避免这种情况，我们可以使用唯一标识符（例如请求ID）来标识每个请求。通过在服务器端记录已处理的请求ID，我们可以在接收到请求时检查该ID是否已经存在，从而避免重复处理。 

 实现步骤:
  1. 生成唯一标识符：在客户端生成一个唯一的请求ID，例如使用UUID。 
  2. 发送请求：将请求ID作为请求的一部分发送到服务器。 
  3. 服务器端处理： 
    - 检查请求ID是否已经在数据库或内存中记录。 
    - 如果请求ID已存在，返回已处理的结果；如果不存在，则处理请求并记录该ID。
    - 示例：用户在支付时生成一个唯一的交易ID，服务器记录已处理的交易ID，避免重复支付。

/**
    1. **生成唯一请求ID
       **：使用  UUID.randomUUID().toString()  生成一个唯一的请求ID。 
    2. **存储已处理的请求ID**：使用  HashSet  来存储已处理的请求ID，以便快速查找。 
    3. **检查请求ID**：在  processRequest  方法中，首先检查该请求ID是否已经存在于            
     processedRequests  集合中。 
       - 如果存在，输出提示信息，避免重复处理。 
       - 如果不存在，则处理请求，并将该请求ID添加到集合中。 
*/
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

public class UniqueIdentifierExample {
    // 用于存储已处理的请求ID
    private static Set<String> processedRequests = new HashSet<>();

    public static void main(String[] args) {
        // 模拟多个请求
        for (int i = 0; i < 100; i++) {
            String requestId = UUID.randomUUID().toString(); // 生成唯一请求ID
            processRequest(requestId);
        }
    }

    public static void processRequest(String requestId) {
        // 检查请求ID是否已处理
        if (processedRequests.contains(requestId)) {
            System.out.println("请求ID " + requestId + " 已处理过，避免重复提交。");
            return;
        }

        // 处理请求
        System.out.println("处理请求ID: " + requestId);
        // 这里可以添加具体的业务逻辑，例如转账、订单创建等

        // 记录已处理的请求ID
        processedRequests.add(requestId);
        System.out.println("请求ID " + requestId + " 处理完成。");
    }
}


  总结，通过使用唯一标识符，我们可以有效地避免重复提交的问题。这种方法简单易行，适用于各种Web应用程序，尤其是在需要确保请求的幂等性和数据一致性的场景中。

4.2. 客户端禁用按钮

        在用户提交请求后，禁用提交按钮，防止用户重复点击。
        在客户端（APP、H5、小程序、 PC管理系统）用户提交表单后，立即禁用“提交”按钮，直到收到服务器响应。

4.3. 事务机制

        利用数据库的事务特性，确保操作的原子性和一致性。
        在数据库操作中，事务是一组操作的集合，这些操作要么全部成功，要么全部失败。通过使用事务机制，我们可以确保在执行一系列数据库操作时，如果其中任何一个操作失败，整个操作都会被回滚，从而避免数据的不一致性。这在避免重复提交时尤为重要。

 
  - 示例：在进行转账操作时，使用事务确保扣款和入账要么同时成功，要么同时失败。

/**
    1. **连接数据库**：首先，我们建立与数据库的连接。 
    2. **关闭自动提交**：通过  connection.setAutoCommit(false)  关闭自动提交模式，这样我们        可以手动控制事务的提交和回滚。 
    3. **执行转账操作**： 
       - **扣款**：从一个账户中扣除指定金额。 
       - **加款**：向另一个账户中添加指定金额。 
    4. **提交事务**：如果所有操作成功，调用  connection.commit()  提交事务。 
    5. **异常处理**：如果在执行过程中出现异常，则调用  connection.rollback()  回滚事务，确保数据的一致性。 
*/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class TransactionExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String user = "root";
        String password = "password";

        // 模拟转账操作
        int fromAccountId = 1;
        int toAccountId = 2;
        double amount = 100.0;

        try (Connection connection = DriverManager.getConnection(url, user, password)) {
            // 关闭自动提交
            connection.setAutoCommit(false);

            // 执行转账操作
            try {
                // 从一个账户扣款
                String deductSql = "UPDATE accounts SET balance = balance - ? WHERE id = ?";
                try (PreparedStatement deductStatement = connection.prepareStatement(deductSql)) {
                    deductStatement.setDouble(1, amount);
                    deductStatement.setInt(2, fromAccountId);
                    deductStatement.executeUpdate();
                }

                // 向另一个账户加款
                String creditSql = "UPDATE accounts SET balance = balance + ? WHERE id = ?";
                try (PreparedStatement creditStatement = connection.prepareStatement(creditSql)) {
                    creditStatement.setDouble(1, amount);
                    creditStatement.setInt(2, toAccountId);
                    creditStatement.executeUpdate();
                }

                // 提交事务
                connection.commit();
                System.out.println("转账成功！");
            } catch (Exception e) {
                // 如果出现异常，回滚事务
                connection.rollback();
                System.out.println("转账失败，已回滚。");
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


        在实际应用中，用户可能会因为网络延迟或其他原因重复提交转账请求。为了避免这种情况，可以在转账操作前生成一个唯一的请求ID，并在数据库中记录已处理的请求ID。这样，在处理请求时可以首先检查该请求ID是否已存在，以避免重复处理。


4.4. 使用Redis

        在分布式系统中，确保操作的幂等性是非常重要的。使用Redis可以有效地解决幂等性问题，特别是在处理高并发请求时。Redis的高性能和原子性操作，使其成为存储和管理请求状态的理想选择。 

        实现思路 :
          - 生成唯一请求ID：在客户端生成一个唯一的请求ID（如UUID），并将其作为请求的一部分发送到服务器。 
          - 使用Redis存储请求ID：在处理请求之前，先检查该请求ID是否已经存在于Redis中。 
          - 如果存在，说明该请求已经被处理过，直接返回之前的结果。 
          - 如果不存在，则处理请求，并将请求ID存入Redis，以标记该请求已被处理。 
          - 设置过期时间：为了防止Redis中存储的请求ID无限增长，可以为每个请求ID设置过期时间。 

 使用Redis来控制幂等性的Java示例。 
a、你需要在项目中添加Redis客户端库的依赖，例如使用Jedis：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.3</version>
</dependency>


b、使用以下代码示例

/**
    1. **连接Redis**：使用Jedis连接到Redis服务器。 
    2. **生成唯一请求ID**：在示例中， requestId 是一个唯一的请求ID，通常在实际应用中会动态生成（例如使用UUID）。 
    3. **使用SETNX命令**：通过 jedis.set(requestId, "processed", "NX", "EX", 600) 命令，尝试将请求ID存入Redis。 
       -  NX 参数表示只有当键不存在时才设置成功（即请求ID未处理过）。 
       -  EX 参数设置键的过期时间为600秒（10分钟）。 
    4. **处理请求**：如果设置成功，执行请求的具体处理逻辑；如果请求ID已存在，输出提示信息，避免重复处理。 
 
*/
import redis.clients.jedis.Jedis;

public class IdempotentRequestExample {
    private static final String REDIS_HOST = "localhost"; // Redis服务器地址
    private static final int REDIS_PORT = 6379; // Redis服务器端口

    public static void main(String[] args) {
        String requestId = "unique-request-id"; // 生成唯一请求ID
        processRequest(requestId);
    }

    public static void processRequest(String requestId) {
        try (Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT)) {
            // 使用SETNX命令设置请求ID，确保只有第一次请求能够成功
            // 设置过期时间为10分钟
            String result = jedis.set(requestId, "processed", "NX", "EX", 600);

            if ("OK".equals(result)) {
                // 处理请求
                System.out.println("处理请求ID: " + requestId + "，创建资源...");
                // 这里添加具体的业务逻辑，例如创建资源
            } else {
                // 请求ID已存在，说明请求已被处理
                System.out.println("请求ID " + requestId + " 已处理过，返回之前的结果。");
            }
        }
    }
}


总结 ,通过使用Redis，我们可以有效地管理请求的幂等性。Redis的高性能和原子性操作使得在高并发场景下保持请求的唯一性和一致性成为可能。这种方法特别适合于需要确保请求幂等性的Web应用程序和分布式系统。

5、如何避免ABA问题


        ABA问题是指在检查某个值是否为A时，值可能被改变为B，然后又改回A，这可能导致错误的判断。避免ABA问题的方法包括：

5.1. 版本号

        在数据中添加版本号，每次更新时检查版本号，确保操作的有效性。
        - 示例：在更新用户信息时，检查当前版本号是否与预期版本号一致。

5.2. 使用乐观锁

        通过在更新时检查当前状态与预期状态是否一致来防止ABA问题。
         - 示例：在更新商品库存时，使用乐观锁机制，确保库存数量在更新前未被其他操作修改。

//示例:避免ABA问题的乐观锁
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class OptimisticLockExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String user = "root";
        String password = "password";

        try (Connection connection = DriverManager.getConnection(url, user, password)) {
            connection.setAutoCommit(false);
            
            // 读取当前版本号
            String selectSql = "SELECT version FROM users WHERE id = ?";
            int userId = 1;
            int currentVersion = 0;
            try (PreparedStatement selectStatement = connection.prepareStatement(selectSql)) {
                selectStatement.setInt(1, userId);
                ResultSet resultSet = selectStatement.executeQuery();
                if (resultSet.next()) {
                    currentVersion = resultSet.getInt("version");
                }
            }

            // 更新操作
            String updateSql = "UPDATE users SET email = ?, version = version + 1 WHERE id = ? AND version = ?";
            try (PreparedStatement updateStatement = connection.prepareStatement(updateSql)) {
                updateStatement.setString(1, "newemail@example.com");
                updateStatement.setInt(2, userId);
                updateStatement.setInt(3, currentVersion);
                int rowsAffected = updateStatement.executeUpdate();
                
                if (rowsAffected == 0) {
                    System.out.println("更新失败，版本号不匹配。");
                } else {
                    System.out.println("更新成功。");
                }
            }

            connection.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.3. 使用时间戳

        记录每次修改的时间戳，以便在进行操作时进行验证。
        - 示例：在进行数据更新时，检查数据的最后修改时间，确保在更新时数据未被其他操作改变。

以上代码示例，均为伪代码，仅用于辅助学习使用。


http://www.kler.cn/a/305638.html

相关文章：

  • ODOO学习笔记（1）：ODOO的SWOT分析和技术优势是什么？
  • Redis - String 字符串
  • Java API类与接口：类的转换方法与正则表达式
  • 【设计模式】结构型模式（四）：组合模式、享元模式
  • 100+SCI科研绘图系列教程（R和python）
  • AI 大模型如何赋能电商行业，引领变革
  • C# SQL 辅助工具
  • 321. 拼接最大数
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理
  • PostgreSQL 与 MySQL：如何为你的项目选择合适的数据库？
  • 闲鱼 sign 阿里228滑块 分析
  • Spring事务传播行为详解
  • 【JavaScript】LeetCode：36-40
  • 使用Python实现深度学习模型：智能饮食建议与营养分析
  • OSS对象资源管理
  • React函数组件传参
  • 大数据-127 - Flink State 04篇 状态原理和原理剖析：状态存储 Part2
  • 汽车以太网100BASE-T1 和 1000BASE-T1特性
  • QXml 使用方法
  • 关于linux里的df命令以及inode、数据块-stat链接数以及关于awk文本处理命令中内置函数sub、gsub、sprintf
  • Excel 国产化替换新方案
  • cc2530按键中断实现控制LED
  • 【MySQL】MySQL索引与事务的透析——（超详解）
  • 情感识别系统源码分享
  • 【hot100-java】【搜索二维矩阵 II】
  • 如何应对突发的技术故障和危机？