傳輸完全相同的對象套接字

Question

我帶來了另一個問題

我有一個類服務器：

package server;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Observable;
import java.util.Observer;
import javax.swing.DefaultListModel;
import objects.Player;

public class Servidor implements Runnable, Observer {

int puerto;
public DefaultListModel<Player> players = new DefaultListModel<>();
public ArrayList<Socket> clients = new ArrayList<>();

public static Send m;

public Servidor(int puerto, Send m) {
    this.m = m;
    this.m.addObserver(this);
    this.puerto = puerto;
    System.out.println(this.m + " from the server")
}

@Override
public void run() {
    ServerSocket servidor = null;
    Socket sc = null;
    ObjectOutputStream output;

    try {
        servidor = new ServerSocket(puerto);
        System.out.println("Server Started");

        while (true) {
            sc = servidor.accept();
            System.out.println("New Cliente");

            output = new ObjectOutputStream(sc.getOutputStream());

            output.writeObject(m);
            clientes.add(sc);
        }
    } catch (IOException ex) {
    }
}

public void Send_Players() throws IOException {
    for (Socket sc : clients) {
        ObjectOutputStream output = new ObjectOutputStream(sc.getOutputStream());

        output.writeObject(players);
    }
}

@Override
public void update(Observable o, Object arg) {
    //Stuff
}

然后我有我的客戶端類：

package server;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.util.Observable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.DefaultListModel;
import objects.Player;

public class Client extends Observable implements Runnable {

String host;
int puerto;
Socket sc;

public Client(int purto, String host) {
    this.puerto = purto;
    this.host = host;

    try {
        sc = new Socket(host, puerto);
    } catch (IOException ex) {
    }
}

@Override
public void run() {
    DataInputStream in;
    ObjectInputStream input = null;
    DefaultListModel<Player> players = new DefaultListModel<>();
    try {
        in = new DataInputStream(sc.getInputStream());
        input = new ObjectInputStream(in);
    } catch (IOException ex) {
    }
    while (true) {
        Object objeto = null;
        try {
            objeto = input.readObject();
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
        if (objeto != null) {
            System.out.println("Is: " + objeto.getClass().getName());
            if (objeto instanceof DefaultListModel) {

                players = (DefaultListModel<Player>) objeto;

                this.setChanged();
                this.notifyObservers(players);
                this.clearChanged();
            } else {
                Send m = (Send) objeto;

                this.setChanged();
                this.notifyObservers(m);
                this.clearChanged();
            }
        }
    }
}
}

還有 Send 類：

package server;

import java.io.Serializable;
import java.util.Observable;

public class Send extends Observable implements Serializable{

private static final long serialVersionUID = 1L;

public void Send_(Object arg){
    this.setChanged();
    this.notifyObservers(arg);
    this.clearChanged();
}
}

現在我將解釋它是如何工作的：

1. 當我創建一個服務器時，我將它添加為類 Send 的觀察者

2. 當我創建一個新的客戶端時，服務器會檢測到它

3. 當一個新客戶來了。 它發送一個類型為 Send 的對象。

4. 在客戶端類中，它通過 observable 檢測到有什么東西來了，並通知一個名為 Main 的類。

5. 當 Main 類的觀察者收到通知時，它會執行以下操作：

    this.m = (Send) arg; System.out.println(this.m + " from the class Main");

但是來自服務器的類 Send 不等於來自類 Main 的類 Send 但我需要它們相等，以便我可以使用類 send 中的 Send_ 方法來通知觀察者

輸出：server.Send@6576a5d6 從服務器服務器啟動新客戶端 Es：server.Send Sipili server.Send@156ecdb0 從客戶端

我需要輸出的第一行（對象 1）需要與輸出的最后一行相同

注意：我認為這與序列化版本有關

Answer 1

遺憾的是你不能，在https://docs.oracle.com/javase/8/docs/api/java/io/ObjectInputStream.html它說它的工作方式是由。

1. 發送對象類型。
2. 創建新對象。
3. 用其他班級上的值替換這些值。

所以完全復制是不可能的。