发送不同的对象到Java服务器

Question

我有几个类。 学生，老师和书。

我想将这3个对象的实例从服务器发送到连接客户端。 我知道如何发送/使用下面的代码从服务器接收单一类型的学生，也就是实例客户

客户端

  Socket socket = new Socket(ip, port); 
     try { 
      ObjectInputStream objectInput = new ObjectInputStream(socket.getInputStream()); 
      try { 
       Object object =(Student) objectInput.readObject(); 
       Student std = (Student) object; 
       //do something with std 
      } catch (ClassNotFoundException e) { 
       e.printStackTrace(); 
      }   

服务器端

 Student a = new Student(); 
     ServerSocket myServerSocket = new ServerSocket(port); 
     Socket skt = myServerSocket.accept(); 
     try 
     { 
      ObjectOutputStream objectOutput = new ObjectOutputStream(skt.getOutputStream()); 
      objectOutput.writeObject(a);     
     } 
     catch (IOException e) 
     { 
      e.printStackTrace(); 
     } 

如何延长这段代码能够从服务器发送不同类型的对象并在客户端正确接收它们

是否需要将它们全部包装另一个对象，并给每一个类型？ 谢谢！

Answer 1

我是否需要将它们全部包装到另一个对象中并给每个对象一个类型？

1. 这可能是一个更好的设计创造，将聚集所有对象实例的类。这将防止错误并产生更多可读代码。

2. 如果您只是想在客户端和服务器之间交换纯java对象，最好使用类似Remote method invocation（文章中包含的示例）。

如何延长这段代码可以从服务器发送不同类型的对象 的？

如果你坚持学习套接字，你可以一个接一个地发送和接收对象实例。您可以发送对象数组。

客户例如：

public class Client { 
    public static void main(String[] args) throws IOException { 
     Socket socket = new Socket("127.0.0.1", 6060); 

     try { 
      ObjectInputStream objectInput = new ObjectInputStream(socket.getInputStream()); 
      Student student = (Student)objectInput.readObject(); 

      System.out.println("Received student (" + student + ")"); 

      objectInput = new ObjectInputStream(socket.getInputStream()); 
      Teacher teacher = (Teacher) objectInput.readObject(); 

      System.out.println("Received teacher (" + teacher + ")"); 

      //do something with std 
     } catch (ClassNotFoundException e) { 
      e.printStackTrace(); 
     } finally { 
      socket.close(); 
     } 
    } 
} 

服务器例如：

public class Server { 
    public static void main(String[] args) throws IOException { 
     ServerSocket myServerSocket = new ServerSocket(6060); 
     System.out.println("Up and running"); 
     Socket skt = myServerSocket.accept(); 
     try { 
      Student student = new Student(); 
      ObjectOutputStream objectOutput = new ObjectOutputStream(skt.getOutputStream()); 
      objectOutput.writeObject(student); 
      System.out.println("Sent student"); 

      Teacher teacher = new Teacher(); 
      objectOutput = new ObjectOutputStream(skt.getOutputStream()); 
      objectOutput.writeObject(teacher); 
      System.out.println("Sent teacher"); 
     } 
     catch (IOException e) { 
      e.printStackTrace(); 
     } finally { 
      myServerSocket.close(); 
     } 

     System.out.println("Shutting down"); 
    } 
} 

但这种方法很难理解和容易出现的错误，因为如果你没有得到正确的顺序既Client和Server那么这段代码将不起作用。

Answer 2

正如我所理解的问题，你想知道如何检测发送给你的是什么类型的对象 我怀疑instanceof和类似的方法将做的伎俩。

您也可以使用信封包装对象。这几乎完全相同，但可能会让您有机会在其中包含错误标志，路由信息和紧急标志。

public static class Envelope implements Serializable { 
    private final Object contents; 
    private final String type; 

    public Envelope(final Object contents, String type) { 
     this.contents = contents; 
     this.type = type; 
    } 

    public <T> T getContents(Class<T> clazz) { 
     return (T) contents; 
    } 

    public String getType() { 
     return type; 
    } 
} 

public static void main(String[] argv) { 

    Envelope stringEnvelope = new Envelope("abcd", "String"); 

    PipedInputStream reader = new PipedInputStream(); 
    PipedOutputStream writer = new PipedOutputStream(); 

    try { 
     reader.connect(writer); 
     ObjectOutputStream objectOutputStream = new ObjectOutputStream(writer); 
     ObjectInputStream objectInputStream = new ObjectInputStream(reader); 

     objectOutputStream.writeObject(stringEnvelope); 

     Envelope envelope = (Envelope) objectInputStream.readObject(); 
     String type = envelope.getType(); 
     if (type.equals("String")) { 
      String result = envelope.getContents(String.class); 
      System.out.println(result); 
     } 
    } catch (ClassNotFoundException c) { 

    } catch (IOException e) { 

    } 

} 

Answer 3

你可以换你的对象在一个新的类：

public class ObjectMessage{ 
    public objecttype; 
    public Object payload; 
    public ObjectMessage(int objt, Object pay){ 
     objecttype=objt; 
     payload=pay; 
    } 
} 

当然，您需要更改的客户端，也：

Socket socket = new Socket(ip, port); 
try { 
    ObjectInputStream objectInput = new ObjectInputStream(socket.getInputStream()); 
    try { 
     Object object = objectInput.readObject(); 
     ObjectMessage msg = (ObjectMessage) object; 
     if(msg.objecttype == 0){ 
      Student std = (Student) msg.payload; 
      //do something with std 
     }else if(msg.objecttype == 1){ 
      //do something with Teacher, Book or whatever 
     } 
    } catch (ClassNotFoundException e) { 
     e.printStackTrace(); 
    }  

而该服务器现在所做的：

Student a = new Student(); //or Teacher, Book etc. 
ObjectMessage message = new ObjectMessage(0,a); //use other numbers for other objects 
ServerSocket myServerSocket = new ServerSocket(port); 
Socket skt = myServerSocket.accept(); 
try 
{ 
    ObjectOutputStream objectOutput = new ObjectOutputStream(skt.getOutputStream()); 
    objectOutput.writeObject(message);     
} 
catch (IOException e) 
{ 
    e.printStackTrace(); 
} 

（你可能想要ta请看一下序列化：What is object serialization?）