从 YAML 文件加载 JavaFX 形状的 LinkedList？

如文档中所述，

如果自定义 Java 类符合规范，则可以加载和转储它，而无需任何额外的代码。JavaBean

该类不符合规范，因为它不提供零参数构造函数。这就是错误消息试图告诉您的内容。com.sun.javafx.scene.NodeEventDispatcherJavaBean

您可以编写一个自定义构造函数来解决此限制，但正如其他人所说，直接存储 UI 类不是一个好方法——通常，自动序列化对于被动数据类是可行的，但通常不适用于任何 Java 类。

关于，这些只是应用于以下节点的标签。 应用于包含所有后续键值对的以下映射，而应用于以下空映射。映射是空的，因为该类没有任何公共属性（公共值或具有 getter 和 setter 的值）。!!!!javafx.scene.shape.Circle!!com.sun.javafx.scene.NodeEventDispatcher{}

标签帮助 SnakeYAML 确定它应该将一些映射加载到哪个类。当实际对象的类不等于属性的已定义静态类时，它们是必需的。例如，定义为 ，但序列化对象中的实际值是 .因此，SnakeYAML 添加了标记，以便在加载时知道它需要构造此派生类。 （然后它不起作用，因为该类不是 。eventDispatcherjavafx.event.EventDispatchercom.sun.javafx.scene.NodeEventDispatcherJavaBean

基于 YAML 文件格式序列化和反序列化形状的示例。

它使用杰克逊来协助编组操作。Jackson（目前）使用 SnakeYAML 作为其 YAML 实现，尽管这对通过 Jackson API 的使用是完全透明的。

它只允许单一的形状类型（a），但可以毫不费力地扩展到处理其他形状。Circle

应用输出

Wrote: /var/folders/87/r96kpgbj5tjdpsgml9gb_g8c0000gn/T/shapes-4277733445362494936.yaml
---
- !<Circle>
  centerX: 40.0
  centerY: 50.0
  radius: 20.0
  fill: "BLUE"
- !<Circle>
  centerX: 20.0
  centerY: 20.0
  radius: 10.0
  fill: "RED"

Read: /var/folders/87/r96kpgbj5tjdpsgml9gb_g8c0000gn/T/shapes-4277733445362494936.yaml
[CircleModel[centerX=40.0, centerY=50.0, radius=20.0, fill=BLUE], CircleModel[centerX=20.0, centerY=20.0, radius=10.0, fill=RED]]

使用 FXML 的替代实现

您可以将对象存储为 FXML，然后可以使用 FXMLLoader 加载它们。

如果您有一些工具来创建形状并以 FXML 格式导出它们，这可能会很好用。

但是，如果需要从应用程序中的模型对象以编程方式创建 FXML 文件，这可能有点困难。我知道没有容易获得的第三方库可以做到这一点。Jackson 与这里用于 YAML 的类似，可以通过一些额外的编程创建基本的 FXML 文件。但是，这超出了本答案的范围。

使用备用数据格式（JSON 或 XML）

若要将 JSON 用作序列化格式，请在类中使用：ShapeRepository

private final JsonFactory serializationFactory = new JsonFactory();

而不是 ：YamlFactory

private final JsonFactory serializationFactory = new YAMLFactory();

同样，对于 XML，请参阅：

• 使用 Jackson 进行 XML 序列化和反序列化。

应用代码

模块信息.java

module com.example.persistentcirclesapp {
    requires javafx.graphics;
    requires com.fasterxml.jackson.dataformat.yaml;
    requires com.fasterxml.jackson.databind;

    exports com.example.persistentcirclesapp;
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>PersistentCirclesApp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>PersistentCirclesApp</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-graphics</artifactId>
            <version>21.0.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
            <version>2.15.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>2.15.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

形状应用程序.java

package com.example.persistentcirclesapp;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.io.IOException;
import java.util.List;

public class ShapeApplication extends Application {
    @Override
    public void start(Stage stage) throws IOException {
        ShapeRepository shapeRepository = new ShapeRepository();
        shapeRepository.save(
                List.of(
                        new CircleModel(40, 50, 20, "BLUE"),
                        new CircleModel(20, 20, 10, "RED")
                )
        );

        List<ShapeModel> shapes = shapeRepository.load();

        ShapeRenderer shapeRenderer = new ShapeRenderer();

        stage.setScene(new Scene(shapeRenderer.render(shapes)));
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

形状模型.java

package com.example.persistentcirclesapp;

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.WRAPPER_OBJECT
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = CircleModel.class, name = "Circle")
})
public sealed interface ShapeModel permits CircleModel {}

CircleModel.java

package com.example.persistentcirclesapp;

public record CircleModel(
        double centerX,
        double centerY,
        double radius,
        String fill
) implements ShapeModel {}

形状存储库.java

package com.example.persistentcirclesapp;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectReader;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class ShapeRepository {
    private final Path shapeRepositoryPath;

    private final JsonFactory serializationFactory = new YAMLFactory();
    private final ObjectMapper mapper =
            new ObjectMapper(serializationFactory);

    private final CollectionType shapeCollectionType = mapper.getTypeFactory().constructCollectionType(
            List.class, ShapeModel.class
    );

    private final ObjectWriter writer = new ObjectMapper(serializationFactory)
            .writerFor(shapeCollectionType);

    private final ObjectReader reader = new ObjectMapper(serializationFactory)
            .readerFor(shapeCollectionType);

    public ShapeRepository() throws IOException {
        shapeRepositoryPath = Files.createTempFile("shapes-", ".yaml");
    }

    public ShapeRepository(Path shapeRepositoryPath) {
        this.shapeRepositoryPath = shapeRepositoryPath;
    }

    public void save(List<ShapeModel> shapes) throws IOException {
        writer.writeValue(
                shapeRepositoryPath.toFile(),
                shapes
        );

        System.out.println("Wrote: " + shapeRepositoryPath + "\n" + Files.readString(shapeRepositoryPath));
    }

    public List<ShapeModel> load() throws IOException {
        List<ShapeModel> shapes = reader.readValue(
                shapeRepositoryPath.toFile()
        );

        System.out.println("Read: " + shapeRepositoryPath + "\n" + shapes);

        return shapes;
    }
}

ShapeRenderer.java

package com.example.persistentcirclesapp;

import javafx.scene.layout.Pane;

import java.util.List;

public class ShapeRenderer {
    private final ShapeFactory shapeFactory = new ShapeFactory();

    public Pane render(List<ShapeModel> shapes) {
        Pane pane = new Pane();

        shapes.stream()
                .map(shapeFactory::createShape)
                .forEach(shape ->
                        pane.getChildren().add(shape)
                );

        return pane;
    }
}

ShapeFactory.java

package com.example.persistentcirclesapp;

import javafx.scene.paint.Paint;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Shape;

public class ShapeFactory {
    public Shape createShape(ShapeModel shapeModel) {
        return switch(shapeModel) {
            case CircleModel circleModel ->
                    new Circle(
                            circleModel.centerX(),
                            circleModel.centerY(),
                            circleModel.radius(),
                            Paint.valueOf(circleModel.fill())
                    );
        };
    }
    
    public ShapeModel createModel(Shape shape) {
        return switch(shape) {
            case Circle circle ->
                    new CircleModel(
                            circle.getCenterX(), 
                            circle.getCenterY(), 
                            circle.getRadius(), 
                            circle.getFill().toString() 
                    );
            default -> 
                    throw new IllegalArgumentException("Unsupported shape type " + shape.getClass().getName());
        };
    }
}