问题描述
我正在开发一个 javaFx 项目,我们必须使用 ObservableList
来添加Listners。 ObservableList
包括人员模型。但我想通过序列化存储整个文件中的 ObservableList
对象。但它给了我一个例外。
我还对对象模型进行了序列化,但没有运气。是否有任何方法可以序列化 ObservableList ?
I am working on a javaFx project where we have to use ObservableList
to add Listners. ObservableList
includes Model of persons. But I want to store the whole ObservableList
Object in a file through serialization. But it gives me an Exception.I also implimented Serialization on the object Model but no luck. Is there any method to serialize ObservableList?
package com.company.Model;
import javax.persistence.*;
import java.io.Serializable;
/**
* Created by Sunny on 1/8/2016.
*/
@Entity
@Table(name = "Employee", schema = "", catalog = "PUBLIC")
public class EmployeeEntity implements Serializable {
private String empId;
private String empAddress;
private String empNumber;
private String empFirstName;
private String empLastName;
public EmployeeEntity(String empId, String empAddress, String empNumber, String empFirstName, String empLastName) {
this.empId = empId;
this.empAddress = empAddress;
this.empNumber = empNumber;
this.empFirstName = empFirstName;
this.empLastName = empLastName;
}
public EmployeeEntity() {
}
@Id
@Column(name = "emp_ID")
public String getEmpId() {
return empId;
}
public void setEmpId(String empId) {
this.empId = empId;
}
@Basic
@Column(name = "emp_address")
public String getEmpAddress() {
return empAddress;
}
public void setEmpAddress(String empAddress) {
this.empAddress = empAddress;
}
@Basic
@Column(name = "emp_number")
public String getEmpNumber() {
return empNumber;
}
public void setEmpNumber(String empNumber) {
this.empNumber = empNumber;
}
@Basic
@Column(name = "emp_firstName")
public String getEmpFirstName() {
return empFirstName;
}
public void setEmpFirstName(String empFirstName) {
this.empFirstName = empFirstName;
}
@Basic
@Column(name = "emp_lastName")
public String getEmpLastName() {
return empLastName;
}
public void setEmpLastName(String empLastName) {
this.empLastName = empLastName;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EmployeeEntity that = (EmployeeEntity) o;
if (empId != null ? !empId.equals(that.empId) : that.empId != null) return false;
if (empAddress != null ? !empAddress.equals(that.empAddress) : that.empAddress != null) return false;
if (empNumber != null ? !empNumber.equals(that.empNumber) : that.empNumber != null) return false;
if (empFirstName != null ? !empFirstName.equals(that.empFirstName) : that.empFirstName != null) return false;
if (empLastName != null ? !empLastName.equals(that.empLastName) : that.empLastName != null) return false;
return true;
}
@Override
public int hashCode() {
int result = empId != null ? empId.hashCode() : 0;
result = 31 * result + (empAddress != null ? empAddress.hashCode() : 0);
result = 31 * result + (empNumber != null ? empNumber.hashCode() : 0);
result = 31 * result + (empFirstName != null ? empFirstName.hashCode() : 0);
result = 31 * result + (empLastName != null ? empLastName.hashCode() : 0);
return result;
}
}
序列化
Serialization
public void write(ObservableList<EmployeeEntity> personObservalble) {
try {
// write object to file
FileOutputStream fos = new FileOutputStream("Objectsavefile.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(personsObservable);
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
例外
Exception
java.io.NotSerializableException: com.sun.javafx.collections.ObservableListWrapper
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at FileWriter.write(FileWriter.java:14)
at Main.main(Main.java:12)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:497)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
Process finished with exit code 0
推荐答案
ObservableList
的实施精神不是 Serializable
(基本上没有明智的方法来定义序列化监听器的行为,而且根本没有序列化监听器与序列化不可观察的列表相同使用相同的数据,我认为这就是你想要做的。)假设你的 Person
类是 Serializable
(并且实例可以被序列化),你可以这样做:
ObservableList
implementations are not Serializable
(Essentially there's no sensible way to define the behavior for serializing the listeners, and not serializing the listeners at all is just the same as serializing a non-observable list with the same data, which I think is what you want to do here.) Assuming your Person
class is Serializable
(and that instances can actually be serialized), you can do:
public void write(ObservableList<EmployeeEntity> personObservalble) {
try {
// write object to file
FileOutputStream fos = new FileOutputStream("Objectsavefile.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(new ArrayList<EmployeeEntity>(personsObservable));
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
要读回来,你会做:
ObjectInputStream ois = ... ;
List<EmployeeEntity> list = (List<EmployeeEntity>) ois.readObject();
personsObservable = FXCollections.observableList(list);
这是一个完整的测试。我运行它并且它工作(我删除了持久性注释,因为我在测试环境中没有在类路径上使用javax.persistence,但这应该没有区别)。
Here is a complete test. I ran this and it worked (I removed the persistence annotations, as I didn't have javax.persistence on the classpath in my test environment, but that should make no difference).
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
public class SerializeObservableListTest {
public static void main(String[] args) throws IOException {
EmployeeEntity bill = new EmployeeEntity("1000", "Seattle, WA", "1000", "Bill", "Gates");
EmployeeEntity tim = new EmployeeEntity("2000", "Mobile, AL", "2000", "Tim", "Cook");
ObservableList<EmployeeEntity> staff = FXCollections.observableArrayList(bill, tim);
Path temp = Files.createTempFile("employees", "ser");
write(staff, temp);
ObservableList<EmployeeEntity> listFromFile = read(temp);
System.out.println("Lists equal? "+listFromFile.equals(staff));
}
private static void write(ObservableList<EmployeeEntity> employees, Path file) {
try {
// write object to file
OutputStream fos = Files.newOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(new ArrayList<EmployeeEntity>(employees));
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
private static ObservableList<EmployeeEntity> read(Path file) {
try {
InputStream in = Files.newInputStream(file);
ObjectInputStream ois = new ObjectInputStream(in);
List<EmployeeEntity> list = (List<EmployeeEntity>) ois.readObject() ;
return FXCollections.observableList(list);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return FXCollections.emptyObservableList();
}
}
这篇关于如何序列化ObservableList的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!