酷阿鲸森林农场：基于Java自主研发的P2P节点自动加入区块链电商系统

+----------------+        +----------------+        +----------------+
|  节点 A (桌面) | <----> |  节点 B (桌面) | <----> |  节点 C (桌面) |
+----------------+        +----------------+        +----------------+
      ↑                        ↑                        ↑
      |                        |                        |
  区块同步 (P2P Socket)      节点广播与发现        自动加入与数据对齐

import java.util.Date;

public class Block {
    public String previousHash;
    public String data;
    public long timestamp;
    public String hash;

    public Block(String data, String previousHash) {
        this.data = data;
        this.previousHash = previousHash;
        this.timestamp = new Date().getTime();
        this.hash = calculateHash();
    }

    public String calculateHash() {
        return StringUtil.applySha256(previousHash + Long.toString(timestamp) + data);
    }
}

import java.security.MessageDigest;

public class StringUtil {
    public static String applySha256(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes("UTF-8"));
            StringBuilder hexString = new StringBuilder();
            for (byte elem : hash) {
                String hex = Integer.toHexString(0xff & elem);
                if(hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
        } catch(Exception e) {
            throw new RuntimeException(e);
        }
    }
}

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

public class Node {
    private static final int PORT = 6000;
    private static Set<Socket> peers = ConcurrentHashMap.newKeySet();
    private static List<Block> blockchain = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws IOException {
        blockchain.add(new Block("创世区块", "0")); // 初始化链

        // 监听其他节点
        ServerSocket server = new ServerSocket(PORT);
        new Thread(() -> {
            while (true) {
                try {
                    Socket client = server.accept();
                    peers.add(client);
                    new Thread(() -> handleClient(client)).start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 连接到默认节点
        connectToPeer("127.0.0.1", PORT); // 可替换为远程IP

        // 主动广播新区块
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String data = scanner.nextLine();
            Block newBlock = new Block(data, blockchain.get(blockchain.size() - 1).hash);
            blockchain.add(newBlock);
            broadcastBlock(newBlock);
        }
    }

    private static void connectToPeer(String host, int port) {
        try {
            Socket socket = new Socket(host, port);
            peers.add(socket);
            new Thread(() -> handleClient(socket)).start();
        } catch (IOException e) {
            System.out.println("无法连接到节点：" + host);
        }
    }

    private static void handleClient(Socket client) {
        try (BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()))) {
            String line;
            while ((line = in.readLine()) != null) {
                Block received = deserializeBlock(line);
                if (isValidNewBlock(received)) {
                    blockchain.add(received);
                    System.out.println("接收到新区块：" + received.data);
                }
            }
        } catch (IOException e) {
            System.out.println("节点断开：" + client.getInetAddress());
        }
    }

    private static void broadcastBlock(Block block) {
        for (Socket peer : peers) {
            try {
                PrintWriter out = new PrintWriter(peer.getOutputStream(), true);
                out.println(serializeBlock(block));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static String serializeBlock(Block block) {
        return block.previousHash + "|" + block.timestamp + "|" + block.data + "|" + block.hash;
    }

    private static Block deserializeBlock(String data) {
        String[] parts = data.split("\\|");
        Block b = new Block(parts[2], parts[0]);
        b.timestamp = Long.parseLong(parts[1]);
        b.hash = parts[3];
        return b;
    }

    private static boolean isValidNewBlock(Block block) {
        Block last = blockchain.get(blockchain.size() - 1);
        return block.previousHash.equals(last.hash) && block.hash.equals(block.calculateHash());
    }
}