独立导出类至XML：实现Node无需Container单独导出的方法

Alright, let's break down how to add standalone XML export functionality to your Node class without relying on the Container wrapper. Here's a straightforward, maintainable approach:

Let's start by mapping out your current code setup to make sure we're on the same page (this helps highlight where we can extend functionality):

// Existing Exportable interface with import/export contracts
public interface Exportable {
    void importFromXML(String xml);
    void exportToXML();
}

// Existing Container class that wraps a Node and uses SaveManager
public class Container implements Exportable {
    private Node rootNode;

    public Container(Node rootNode) {
        this.rootNode = rootNode;
    }

    @Override
    public void importFromXML(String xml) {
        // Existing import logic tied to Container
    }

    @Override
    public void exportToXML() {
        // Delegates the actual export work to SaveManager
        SaveManager.export(this.rootNode);
    }
}

// Existing SaveManager with core XML serialization logic
public class SaveManager {
    // This method already knows how to serialize a Node to XML
    public static void export(Node rootNode) {
        // Core logic: traverse Node hierarchy, generate XML output
    }
}

Since SaveManager.export() already handles the heavy lifting of turning a Node into XML, we can simply add a dedicated method to the Node class that leverages this existing logic. No need to rewrite serialization code!

public class Node {
    // Existing Node properties (e.g., child nodes, attributes) and methods...

    // New method for standalone XML export
    public void exportXML() {
        // Pass the current Node instance as the root to SaveManager
        SaveManager.export(this);
    }
}

If you want Node to follow the same export contract as Container, you can have it implement the Exportable interface too. This is useful if you ever need to treat Node and Container interchangeably in export workflows:

public class Node implements Exportable {
    // Existing Node properties and methods...

    @Override
    public void importFromXML(String xml) {
        // Implement import logic here if needed, or leave empty if Node doesn't support imports
    }

    @Override
    public void exportToXML() {
        SaveManager.export(this);
    }

    // Keep the intuitive exportXML method as a convenience wrapper
    public void exportXML() {
        this.exportToXML();
    }
}

Now you can export any Node directly, no Container required:

// Create and configure your Node
Node nodeA = new Node();
// Add child nodes, set attributes, etc.

// Standalone export in one line
nodeA.exportXML();

• Reuse, don't rewrite: We're leaning on the existing SaveManager logic to avoid redundant code and keep your XML serialization consistent across both Container and standalone Node exports.
• Check SaveManager dependencies: Ensure SaveManager.export() doesn't secretly rely on Container state. If it does, refactor it to only depend on Node's structure (this is good practice regardless).
• Keep it intuitive: The exportXML() method name makes it clear what the method does, even for developers new to your codebase.

内容的提问来源于stack exchange，提问作者Louis Etienne