我已经构建了一个客户端-服务器应用程序,具有有效的连接设置和处理功能。我希望客户端发送不同类型的请求,每个请求都有唯一的字段,但所有这些都继承自“Request”父类(super class)。有办法做到这一点吗?
例如,我有一个实现可序列化的 Foo 类
class Foo implements Serializable{
public String name;
public Foo() {
this.name = "Default";
}
public Foo(String name) {
this.name = name;
}
}
以及扩展它的两个子类
class BarOne extends Foo {
public String name;
public int id;
public Bar(String name, int id) {
super(name);
this.id = id;
}
}
class BarTwo extends Foo {
public String name;
public String lastName;
public Bar(String name, String lastName) {
super(name);
this.lastName = lastName;
}
}
有没有一种方法可以让客户端通过 ObjectOutputStream 发送 BarOne 和 BarTwo 的实例,并让服务器确定它接收到的是其中一个的实例还是另一个的实例?
最佳答案
这里没有限制,你可以毫无困难地序列化子类。
在这里,我提供了一个快速示例,使用与您相同的结构(但有具体示例)。
抽象类。
public abstract class Pojo implements Serializable {
private static final long serialVersionUID = -4947411931465651278L;
protected int id;
public Pojo() {
// TODO Auto-generated constructor stub
}
public Pojo(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
第一个子类Person
class Person extends Pojo {
private static final long serialVersionUID = -7814628079202659483L;
private String name;
private int age;
public Person(int id, String name, int age) {
super(id);
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", id=" + id + "]";
}
}
第二个子类地址
class Address extends Pojo {
private static final long serialVersionUID = -8266402026827561883L;
private String address;
private String city;
public Address(int id, String address, String city) {
super(id);
this.address = address;
this.city = city;
}
@Override
public String toString() {
return "Address [address=" + address + ", city=" + city + ", id=" + id
+ "]";
}
}
然后,您可以为此示例创建一个集合来保存这两种类型的实例:
List<Pojo> pojos = new ArrayList<>();
pojos.add(new Address(1, "Address 1", "city1"));
pojos.add(new Address(2, "Address 2", "city2"));
pojos.add(new Person(1, "Name1", 5));
pojos.add(new Person(2, "Name2", 10));
pojos.add(new Person(3, "Name3", 15));
您可以使用文件进行序列化(因为我没有时间创建套接字系统;))使用:
private static void serialize(String filename, Serializable data)
throws IOException {
try (OutputStream outStream = new FileOutputStream(filename);
ObjectOutputStream fileObjectOut = new ObjectOutputStream(
outStream)) {
fileObjectOut.writeObject(data);
}
}
private static Object deserialize(String filename) throws IOException,
ClassNotFoundException {
try (InputStream inStream = new FileInputStream(filename);
ObjectInputStream fileObjectIn = new ObjectInputStream(inStream)) {
return fileObjectIn.readObject();
}
}
让列表序列化和反序列化以查看类型是否已恢复:
serialize("data.ser", pojos);
List<Pojo> tmp = deserialize("data.ser");
System.out.println(tmp);
您将看到具有正确类型的实例的结果:
[
Address [address=Address 1, city=city1, id=1],
Address [address=Address 2, city=city2, id=2],
Person [name=Name1, age=5, id=1], Person [name=Name2, age=10, id=2],
Person [name=Name3, age=15, id=3]
]
所以你可以对任何东西做同样的事情,只序列化一个Person
,你需要首先恢复Object
并使用instanceof
查看恢复的类型。
Pojo p1 = new Person(1, "Name1", 10);
serialize("person.ser", p1);
Object o1 = deserialize("person.ser");
System.out.println(o1);
System.out.println(o1.getClass());
System.out.println(o1 instanceof Person);
输出
Person [name=Name1, age=10, id=1]
class serial.Person
true
关于java - 有没有办法发送可序列化类的不同子类的实例?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/56039201/