Estou tenho esse erro (java.io.NotSerializableException: javafx.scene.control.TreeView) ao tentar salvar o meu TreeView usando ObjectOutputStream.
Eu tenho 2 classes que implementa Serializable e 1 classe principal, que não implementa Serializable.
Os 2 classes são Vendor e endereço. classe de fornecedor contém 4 variáveis (nome, idade, sexo, endereço do tipo de classe Address), construtor que utiliza o método set para definir todas as variáveis, construtor que utiliza o método set para definir a variável de nome somente, e obter / método set para as variáveis.
classe de endereço contêm 2 variáveis (nome da rua e código postal), construtor padrão que utiliza o método set para definir as variáveis, e obter / método set para as variáveis.
Esta é a minha classe principal
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.FileChooser;
import javafx.stage.Stage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class SimpleTreeView extends Application {
private TreeView<Vendor> treeView;
public void start(Stage stage) {
stage.setTitle("Simple TreeView");
treeView = new TreeView<>();
TreeItem<Vendor> root = new TreeItem<>(new Vendor("Root"));
root.setExpanded(true);
treeView.setRoot(root);
treeView.setShowRoot(false);
TreeItem<Vendor> start = new TreeItem<>(new Vendor("Start"));
root.getChildren().add(start);
Button saveButton = new Button("Save");
saveButton.setOnMouseClicked(event -> saveTreeView(stage));
VBox vBox = new VBox(20);
vBox.getChildren().addAll(treeView, saveButton);
stage.setScene(new Scene(vBox));
stage.show();
}
private void saveTreeView(Stage stage) {
FileChooser fileChooser = new FileChooser();
fileChooser.setTitle("Save");
File file = fileChooser.showSaveDialog(stage);
if (file != null) {
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(file));
os.writeObject(treeView);
os.close();
}
catch (Exception e) {
System.out.println(e);
}
}
}
public static void main(String[] args) {
launch(args);
}
}
Nós não pode ser serializado (exceto, possivelmente, para os personalizados que você implementou o youself) há muitos estados internos que seriam demasiado complexo para restaurar. Sem a possibilidade de adicionar métodos / interfaces para nós (sem estender-los) torna impossível para adicionar a Serializableinterface e adicionar os métodos para salvar as partes dos dados que são necessários para restaurar o estado e ler esses dados corretamente.
Você é o melhor de criar uma classe de invólucro serializável que permite restaurar as propriedades que você está realmente interessados em IMHO é melhor não tentar nós serialize.; Criar um novo nó ao carregar os dados e preenchê-lo com os dados carregados.
O exemplo a seguir mostra como você poderia fazer isso com TreeItem<? extends Serializable>; Há falta de dados, tais como as propriedades expandidas, mas você deve ser capaz de restaurar a valuepropriedade e as crianças. (A implementação é um pouco mais complexo do que o necessário para TreeItemestruturas com pequena profundidade, mas determinadas profundidades você precisa estar ciente de que uma abordagem recursiva simples poderia levar a StackOverflowErrors.)
Neste caso, cada item é serializado escrevendo o número de crianças, é propriedade de valor próprio e, em seguida, fazendo o mesmo com cada criança. Isso resulta em uma sequência de int e os pares de valores que podem ser utilizados para restaurar os dados:
public class TreeItemSerialisation {
public static void main(String[] args) throws IOException, ClassNotFoundException {
TreeItem<String> root = new TreeItem<>("root");
TreeItem<String> c1 = new TreeItem<>("root.1");
TreeItem<String> c3 = new TreeItem<>("root.3");
root.getChildren().addAll(c1, new TreeItem<>("root.2"), c3);
TreeItem<String> c3_1 = new TreeItem<>("root.3.1");
c3_1.getChildren().add(new TreeItem<>("root.3.1.1"));
c3.getChildren().add(c3_1);
c1.getChildren().addAll(new TreeItem<>("root.1.1"), new TreeItem<>("root.1.2"));
// serialize
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try (ObjectOutputStream oos = new ObjectOutputStream(bos)) {
oos.writeObject(new TreeItemSerialisationWrapper(root));
}
// unserialize
TreeItem<String> root2;
try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()))) {
root2 = (TreeItem<String>) ois.readObject();
}
// TODO do something with root2
}
}
public class TreeItemSerialisationWrapper<T extends Serializable> implements Serializable {
private static final long serialVersionUID = 1L;
private transient TreeItem<T> item;
public TreeItemSerialisationWrapper(TreeItem<T> item) {
if (item == null) {
throw new IllegalArgumentException();
}
this.item = item;
}
/**
* Custom way of writing the TreeItem structure
*/
private void writeObject(ObjectOutputStream out)
throws IOException {
Stack<TreeItem<T>> stack = new Stack<>();
stack.push(item);
out.defaultWriteObject();
do {
TreeItem<T> current = stack.pop();
int size = current.getChildren().size();
out.writeInt(size);
// write all the data that needs to be restored here
out.writeObject(current.getValue());
// "schedule" serialisation of children.
// the first one is inserted last, since the top one from the stack is
// retrieved first
for (int i = size - 1; i >= 0; --i) {
stack.push(current.getChildren().get(i));
}
} while (!stack.isEmpty());
}
/**
* happens before readResolve; recreates the TreeItem structure
*/
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
class Container {
int count;
final TreeItem<T> item;
Container(ObjectInputStream in) throws ClassNotFoundException, IOException {
// read the data for a single TreeItem here
this.count = in.readInt();
this.item = new TreeItem<>((T) in.readObject());
}
}
in.defaultReadObject();
Container root = new Container(in);
this.item = root.item;
if (root.count > 0) {
Stack<Container> stack = new Stack<>();
stack.push(root);
do {
Container current = stack.peek();
--current.count;
if (current.count <= 0) {
// we're done with this item
stack.pop();
}
Container newContainer = new Container(in);
current.item.getChildren().add(newContainer.item);
if (newContainer.count > 0) {
//schedule reading children of non-leaf
stack.push(newContainer);
}
} while(!stack.isEmpty());
}
}
/**
* We're not actually interested in this object but the treeitem
* @return the treeitem
* @throws ObjectStreamException
*/
private Object readResolve() throws ObjectStreamException {
return item;
}
}
Para uma descrição de como readObject, readResolvee writeObjectde trabalho, consulte o javadoc deSerializable