请求协助：老旧系统Socket消息字符串转对象的Java算法实现

Got it, let's break down how to solve this problem since you're stuck with that early 2000s legacy system and can't modify it. Intercepting those Socket messages and parsing them into structured objects is totally doable with some straightforward Java code. Here's a step-by-step approach:

1. Understand the Message Structure #

First, let's recap the format you provided:

"CALLNAME|FieldName_{Value|FieldName}Value|..."

The message is split by |—the first segment is the call name (like CallToPaymentModule), and every subsequent segment is a key-value pair separated by ~.

2. Create a Parser Utility #

We'll build a reusable parser to convert the raw string into a structured object. First, let's define a class to hold the parsed result (call name + field map):

public class ParsedLegacyMessage {
    private final String callName;
    private final Map<String, String> fieldMap;

    public ParsedLegacyMessage(String callName, Map<String, String> fieldMap) {
        this.callName = callName;
        this.fieldMap = fieldMap;
    }

    // Getters (no setters needed since this is immutable once parsed)
    public String getCallName() {
        return callName;
    }

    public Map<String, String> getFieldMap() {
        return new HashMap<>(fieldMap); // Return a copy to prevent external modification
    }
}

Next, the parser class itself—this handles splitting the message, validating format, and building the field map:

import java.util.HashMap;
import java.util.Map;

public class LegacyMessageParser {

    public static ParsedLegacyMessage parse(String rawMessage) throws IllegalArgumentException {
        // Guard against null/empty input
        if (rawMessage == null || rawMessage.isBlank()) {
            throw new IllegalArgumentException("Raw message cannot be null or empty");
        }

        // Split the message by | (use -1 to retain trailing empty segments if any)
        String[] messageSegments = rawMessage.split("\\|", -1);
        if (messageSegments.length == 0) {
            throw new IllegalArgumentException("Invalid message: missing call name");
        }

        // Extract and validate the call name
        String callName = messageSegments[0].trim();
        if (callName.isBlank()) {
            throw new IllegalArgumentException("Call name cannot be empty");
        }

        // Parse field key-value pairs
        Map<String, String> fieldMap = new HashMap<>();
        for (int i = 1; i < messageSegments.length; i++) {
            String fieldSegment = messageSegments[i].trim();
            if (fieldSegment.isBlank()) {
                continue; // Skip empty field segments
            }

            // Split each field into key and value (split only once to handle values with ~)
            String[] keyValuePair = fieldSegment.split("~", 2);
            if (keyValuePair.length != 2) {
                throw new IllegalArgumentException("Invalid field format: " + fieldSegment);
            }

            String fieldName = keyValuePair[0].trim();
            String fieldValue = keyValuePair[1].trim();
            if (fieldName.isBlank()) {
                throw new IllegalArgumentException("Field name cannot be empty in segment: " + fieldSegment);
            }

            fieldMap.put(fieldName, fieldValue);
        }

        return new ParsedLegacyMessage(callName, fieldMap);
    }
}

3. Integrate with Socket Interception #

Now, use this parser in your Socket listener code to intercept and process messages. Here's an example of a basic Socket client that reads messages and parses them:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class LegacySocketInterceptor {
    public static void main(String[] args) {
        // Replace with your legacy system's host and port
        String legacyHost = "your-legacy-system-host";
        int legacyPort = 12345;

        try (Socket socket = new Socket(legacyHost, legacyPort);
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

            String rawMessage;
            // Read messages continuously until the connection closes
            while ((rawMessage = reader.readLine()) != null) {
                try {
                    ParsedLegacyMessage parsedMessage = LegacyMessageParser.parse(rawMessage);
                    System.out.println("Received call: " + parsedMessage.getCallName());
                    System.out.println("Parsed fields: " + parsedMessage.getFieldMap());

                    // Example: Map to a custom POJO for specific call types
                    if ("CallToPaymentModule".equals(parsedMessage.getCallName())) {
                        Payment payment = mapToPayment(parsedMessage.getFieldMap());
                        // Process the payment object here (e.g., log, forward to new system)
                        System.out.println("Mapped payment: " + payment.getName() + " - $" + payment.getCost());
                    }
                } catch (IllegalArgumentException e) {
                    // Handle invalid messages without crashing the interceptor
                    System.err.println("Failed to parse message: " + e.getMessage());
                }
            }
        } catch (IOException e) {
            System.err.println("Socket connection error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    // Helper method to convert field map to a custom POJO
    private static Payment mapToPayment(Map<String, String> fieldMap) {
        Payment payment = new Payment();
        payment.setName(fieldMap.getOrDefault("Name", "Unknown"));
        // Safely parse numeric values (handle parsing errors if needed)
        try {
            payment.setCost(Integer.parseInt(fieldMap.getOrDefault("Cost", "0")));
        } catch (NumberFormatException e) {
            System.err.println("Invalid Cost value: " + fieldMap.get("Cost"));
            payment.setCost(0);
        }
        return payment;
    }

    // Example POJO for payment-related messages
    private static class Payment {
        private String name;
        private int cost;

        // Getters and setters
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getCost() {
            return cost;
        }

        public void setCost(int cost) {
            this.cost = cost;
        }
    }
}

4. Key Considerations #

• Error Handling: The parser includes validation for empty inputs, invalid field formats, and empty call names. You can extend this to handle edge cases like values containing special characters (if your legacy system uses escaped characters, you'll need to add unescaping logic).
• Type Safety: If you know the structure of messages for specific call names, mapping to custom POJOs (like the Payment class) adds type safety instead of relying on a generic Map.
• Performance: For high-volume message streams, consider using StringTokenizer instead of split() for faster string processing, but split() is more readable for most use cases.
• Immutability: The ParsedLegacyMessage class is immutable (no setters, returns a copy of the field map) to prevent unintended modifications after parsing.

内容的提问来源于stack exchange，提问作者Jose Lara