一、EVENODD 码基础认知
EVENODD 码是一种面向存储系统的纠删码（Erasure Code），由 Patterson 等人于 1994 年提出，核心功能是：
纠正单个磁盘故障（数据完全恢复）
检测双磁盘故障（发现错误但无法完全恢复）
其设计基于有限域 GF (2ⁿ) 上的运算，特别适用于 n 为质数的场景（如 RAID 阵列），通过引入 2 个校验盘（EVEN 校验盘 + ODD 校验盘）实现冗余，冗余度为 2/k（k 为数据盘数量），在可靠性与存储效率间取得平衡。
二、EVENODD 码核心原理
假设存在一个 m×n 的数据矩阵（m 为行数，n 为列数且 n 是质数），数据盘对应 n 列，额外引入 2 个校验盘：
EVEN 校验盘：每行数据的异或（XOR）结果，即对每行所有元素执行a₁⊕a₂⊕…⊕aₙ，确保每行奇偶性正确。
ODD 校验盘：对角线元素的异或结果，对第 i 行，取元素(i, j)、(i, j+1)、…、(i, j+i) mod n（基于 n 为质数的特性，对角线可覆盖所有列）。
三、Java 硬核实现
以下代码完整实现 EVENODD 码的编码、故障模拟与数据恢复过程，包含核心算法细节：

import java.util.Random;

public class EvenOddCode {
    private int m; // 行数
    private int n; // 列数（数据盘数量，需为质数）
    private int[][] dataMatrix; // 数据矩阵：m行n列
    private int[] evenParity; // EVEN校验盘：m个元素（每行异或结果）
    private int[] oddParity;  // ODD校验盘：m个元素（对角线异或结果）

    // 构造函数：初始化数据矩阵维度
    public EvenOddCode(int rows, int cols) {
        if (!isPrime(cols)) {
            throw new IllegalArgumentException("列数n必须是质数（EVENODD码要求）");
        }
        this.m = rows;
        this.n = cols;
        this.dataMatrix = new int[m][n];
        this.evenParity = new int[m];
        this.oddParity = new int[m];
    }

    // 生成随机数据并填充矩阵
    public void generateRandomData() {
        Random random = new Random();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dataMatrix[i][j] = random.nextInt(256); // 生成0-255的随机字节数据
            }
        }
    }

    // 计算EVEN校验盘（每行异或）
    private void computeEvenParity() {
        for (int i = 0; i < m; i++) {
            int xor = 0;
            for (int j = 0; j < n; j++) {
                xor ^= dataMatrix[i][j];
            }
            evenParity[i] = xor;
        }
    }

    // 计算ODD校验盘（对角线异或）
    private void computeOddParity() {
        for (int i = 0; i < m; i++) {
            int xor = 0;
            for (int j = 0; j < n; j++) {
                // 对角线索引：(j + i) mod n（基于n为质数，确保覆盖所有列）
                int diagonalCol = (j + i) % n;
                xor ^= dataMatrix[i][diagonalCol];
            }
            oddParity[i] = xor;
        }
    }

    // 执行编码：计算两个校验盘
    public void encode() {
        computeEvenParity();
        computeOddParity();
    }

    // 模拟磁盘故障（0~n-1：数据盘；n：EVEN校验盘；n+1：ODD校验盘）
    public void simulateFailure(int diskIndex) {
        if (diskIndex < 0 || diskIndex > n + 1) {
            throw new IllegalArgumentException("无效磁盘索引（0~n+1）");
        }

        if (diskIndex < n) { // 数据盘故障：清零对应列
            int col = diskIndex;
            for (int i = 0; i < m; i++) {
                dataMatrix[i][col] = 0; // 模拟数据丢失
            }
        } else if (diskIndex == n) { // EVEN校验盘故障
            for (int i = 0; i < m; i++) {
                evenParity[i] = 0;
            }
        } else { // ODD校验盘故障
            for (int i = 0; i < m; i++) {
                oddParity[i] = 0;
            }
        }
    }

    // 恢复故障磁盘数据
    public void recover(int failedDiskIndex) {
        if (failedDiskIndex < 0 || failedDiskIndex > n + 1) {
            throw new IllegalArgumentException("无效磁盘索引（0~n+1）");
        }

        if (failedDiskIndex < n) { // 恢复数据盘
            int failedCol = failedDiskIndex;
            for (int i = 0; i < m; i++) {
                // 数据盘恢复：用EVEN校验异或其他数据列
                int recovery = evenParity[i];
                for (int j = 0; j < n; j++) {
                    if (j != failedCol) {
                        recovery ^= dataMatrix[i][j];
                    }
                }
                dataMatrix[i][failedCol] = recovery;
            }
        } else if (failedDiskIndex == n) { // 恢复EVEN校验盘（直接重新计算）
            computeEvenParity();
        } else { // 恢复ODD校验盘（直接重新计算）
            computeOddParity();
        }
    }

    // 验证数据完整性（检查校验是否匹配）
    public boolean verify() {
        int[] tempEven = new int[m];
        int[] tempOdd = new int[m];

        // 重新计算校验值
        for (int i = 0; i < m; i++) {
            int evenXor = 0;
            for (int j = 0; j < n; j++) {
                evenXor ^= dataMatrix[i][j];
            }
            tempEven[i] = evenXor;

            int oddXor = 0;
            for (int j = 0; j < n; j++) {
                int diagonalCol = (j + i) % n;
                oddXor ^= dataMatrix[i][diagonalCol];
            }
            tempOdd[i] = oddXor;
        }

        // 对比校验值
        for (int i = 0; i < m; i++) {
            if (tempEven[i] != evenParity[i] || tempOdd[i] != oddParity[i]) {
                return false;
            }
        }
        return true;
    }

    // 辅助函数：判断一个数是否为质数
    private boolean isPrime(int num) {
        if (num <= 1) return false;
        if (num == 2) return true;
        if (num % 2 == 0) return false;
        for (int i = 3; i <= Math.sqrt(num); i += 2) {
            if (num % i == 0) return false;
        }
        return true;
    }

    // 测试主函数
    public static void main(String[] args) {
        // 初始化：3行5列（n=5是质数）
        EvenOddCode evenOdd = new EvenOddCode(3, 5);
        evenOdd.generateRandomData();
        evenOdd.encode();

        System.out.println("编码后数据完整性验证：" + (evenOdd.verify() ? "通过" : "失败"));

        // 模拟第2个数据盘故障（索引1）
        int failedDisk = 1;
        evenOdd.simulateFailure(failedDisk);
        System.out.println("故障后数据完整性验证：" + (evenOdd.verify() ? "通过" : "失败"));

        // 恢复故障盘
        evenOdd.recover(failedDisk);
        System.out.println("恢复后数据完整性验证：" + (evenOdd.verify() ? "通过" : "失败"));
    }
}

四、代码核心解析
数据结构：
dataMatrix：存储原始数据（m 行 n 列，n 为质数）
evenParity/oddParity：分别存储行校验和对角线校验结果
编码过程：
EVEN 校验：逐行异或所有元素（computeEvenParity）
ODD 校验：逐行异或对角线元素（(j+i) mod n确保覆盖所有列，computeOddParity）
故障恢复：
数据盘故障：通过 EVEN 校验异或其他数据列恢复（recover方法）
校验盘故障：直接重新计算校验值
验证机制：重新计算校验值并与原始校验对比，确保数据一致性（verify方法）
五、EVENODD 码的应用与优势
适用场景：RAID-6、分布式存储（如 Ceph）等需要容错的系统
核心优势：
冗余度低（2 个校验盘支持任意 n 个数据盘）
编码 / 解码速度快（基于异或运算，硬件友好）
单故障恢复能力强，双故障可检测