我正在开发一个 Java 服务器，两个控制一个 Android 在线游戏。

是否可以将 myserversocket.accept() 的客户端套接字保存在 Client 类的变量中？

这非常有用，因为这样，服务器可以在服务器需要时与客户端通信，而在客户端联系服务器时则不能。

我的实际代码是:

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.UUID;

import sal.app.shared.Packet;


public class Server {

    private ArrayList games = new ArrayList();
    private ArrayList pendent_clients = new ArrayList();
    private Packet read_packet= new Packet();
    private Packet sent_packet = new Packet();
    private Socket clientSocket = null;

    public static void main(String[] args) throws ClassNotFoundException{
        ServerSocket serverSocket = null;

        //DataInputStream dataInputStream = null;
        //DataOutputStream dataOutputStream = null;
        ObjectOutputStream oos=null;
        ObjectInputStream ois=null;
        Server myServer = new Server();


        thử {
            serverSocket = new ServerSocket(7777);
            System.out.println("Listening :7777");
        } bắt (IOException e) {
            // TODO Khối catch được tạo tự động
            e.printStackTrace();
        }

        while(true){
            thử {
                myServer.clientSocket = new Socket();
                myServer.clientSocket = serverSocket.accept();
                myServer.read_packet = new Packet();
                myServer.sent_packet = new Packet();

                oos = new ObjectOutputStream(myServer.clientSocket.getOutputStream());

                ois = new ObjectInputStream(myServer.clientSocket.getInputStream());

                //dataInputStream = new DataInputStream(clientSocket.getInputStream());
                //dataOutputStream = new DataOutputStream(clientSocket.getOutputStream());
                //System.out.println("ip: " + clientSocket.getInetAddress());
                //System.out.println("message: " + ois.read());
                //dataOutputStream.writeUTF("Hello!");

                /*while ((myServer.read_packet = (Packet) ois.readObject()) != null) {

                    myServer.handlePacket(myServer.read_packet);
                    phá vỡ;
                }*/

                myServer.read_packet=(Packet) ois.readObject();
                myServer.handlePacket(myServer.read_packet);
                //oos.close();

            } bắt (IOException e) {
                // TODO Khối catch được tạo tự động
                e.printStackTrace();
            }
            finally{
                if( myServer.clientSocket!= null){
                    /*try {
                        //myServer.clientSocket.close();

                    } bắt (IOException e) {
                        // TODO Khối catch được tạo tự động
                        e.printStackTrace();
                    }*/
                }

                /*if( ois!= null){
                    thử {
                        ois.close();
                    } bắt (IOException e) {
                        // TODO Khối catch được tạo tự động
                        e.printStackTrace();
                    }
                }

                if( oos!= null){
                    thử {
                        oos.close();
                    } bắt (IOException e) {
                        // TODO Khối catch được tạo tự động
                        e.printStackTrace();
                    }
                }*/
            }
        }
    }

    public void handlePacket(Packet hp) throws IOException
    {
        if(hp.getOpCode() == 1)
        {
            registPlayer(hp);
        }
    }

    public void registPlayer(Packet p) throws IOException
    {
        Client registClient = new Client(this.clientSocket);
        this.pendent_clients.add(registClient);

        if(pendent_clients.size() == 2)
        {
            initAGame();
        }
        khác
        {
            ObjectOutputStream out=null;
            Packet to_send = new Packet();
            to_send.setOpCode(4);
            out = new ObjectOutputStream(registClient.getClientSocket().getOutputStream());
            out.writeObject(to_send);

        }
    }

    public void initAGame() throws IOException
    {
        Client c1 = pendent_clients.get(0);
        Client c2 = pendent_clients.get(1);
        Packet to_send = new Packet();
        ObjectOutputStream out=null;

        GameSession incomingGame = new GameSession(c1,c2);
        games.add(incomingGame);

        to_send.setGameId(incomingGame.getGameId());
        to_send.setOpCode(5);
        out = new ObjectOutputStream(c1.getClientSocket().getOutputStream());
        out.writeObject(to_send);

        out = new ObjectOutputStream(c2.getClientSocket().getOutputStream());
        out.writeObject(to_send);

        pendent_clients.clear();

    }

    public Client getClientById(UUID given_id)
    {
        for(GameSession gs: games)
        {
            if(gs.getClient1().getClientId().equals(given_id))
            {
                return gs.getClient1();
            }
            else if(gs.getClient2().getClientId().equals(given_id))
            {
                return gs.getClient2();
            }
        }

        trả về giá trị null;
    }
}

使用这段代码我得到了这个错误:

java.net.SocketException: Broken pipe
    at java.net.SocketOutputStream.socketWrite0(Native Method)
    at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:92)
    at java.net.SocketOutputStream.write(SocketOutputStream.java:136)
    at java.io.ObjectOutputStream$BlockDataOutputStream.drain(ObjectOutputStream.java:1847)
    at java.io.ObjectOutputStream$BlockDataOutputStream.setBlockDataMode(ObjectOutputStream.java:1756)
    at java.io.ObjectOutputStream.writeNonProxyDesc(ObjectOutputStream.java:1257)
    at java.io.ObjectOutputStream.writeClassDesc(ObjectOutputStream.java:1211)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1395)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158)
    at java.io.ObjectOutputStream.writeFatalException(ObjectOutputStream.java:1547)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:333)
    at Server.initAGame(Server.java:146)
    at Server.registPlayer(Server.java:120)
    at Server.handlePacket(Server.java:106)
    at Server.main(Server.java:63)

当第二个客户端连接并且服务器尝试在以下代码中的函数 initGame() 中将数据包发送到前一个客户端 1 时，会发生此错误:

out = new ObjectOutputStream(c1.getClientSocket().getOutputStream());
out.writeObject(to_send);

我的android代码是这样的:

package sal.app;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

import sal.app.logic.DataBaseManager;
import sal.app.shared.Packet;
import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class MultiPlayerWaitActivity extends Activity{

    private DataBaseManager db;

    public void onCreate(Bundle savedInstanceState) {

        super.requestWindowFeature(Window.FEATURE_NO_TITLE);
        super.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.multiwaitlayout);

        db=DataBaseManager.getSalDatabase(this);
        db.teste();
        thử {
            db.createDataBase();
        } bắt (IOException e) {
            // TODO Khối catch được tạo tự động
            e.printStackTrace();
        }

        Socket socket = null;
        ObjectOutputStream outputStream = null;
        ObjectInputStream inputStream = null;
        //System.out.println("dadadad");
        thử {
            socket = new Socket("192.168.1.4", 7777);
            //Game = new MultiPlayerGame(new ServerManager("192.168.1.66"),new Session(), new Player(""));
            outputStream = new ObjectOutputStream(socket.getOutputStream());
            inputStream = new ObjectInputStream(socket.getInputStream());
            //dataOutputStream.writeUTF(textOut.getText().toString());
            //textIn.setText(dataInputStream.readUTF());
            Packet p = new Packet();
            Packet r = new Packet();
            p.setOpCode(1);
            outputStream.writeObject(p);

            /*try {
                r=(Packet)inputStream.readObject();
            } catch (ClassNotFoundException e) {
                // TODO Khối catch được tạo tự động
                e.printStackTrace();
            }*/
            //while(true){



                //dataInputStream = new DataInputStream(clientSocket.getInputStream());
                //dataOutputStream = new DataOutputStream(clientSocket.getOutputStream());
                //System.out.println("ip: " + clientSocket.getInetAddress());
                //System.out.println("message: " + ois.read());
                //dataOutputStream.writeUTF("Hello!");

                /*while ((r= (Packet) inputStream.readObject()) != null) {

                        handPacket(r);
                        phá vỡ;
                    }*/


                r=(Packet) inputStream.readObject();
                handPacket(r);
                //oos.close();


            //}

            /*System.out.println(r.getOpCode());

            if(r.getOpCode() == 5)
            {
                this.finish();
            }*/


        } catch (UnknownHostException e) {
            // TODO Khối catch được tạo tự động
            e.printStackTrace();
        } bắt (IOException e) {
            // TODO Khối catch được tạo tự động
            e.printStackTrace();
        }
        /*finally{
            if (socket != null){
                thử {
                    socket.close();
                } bắt (IOException e) {
                    // TODO Khối catch được tạo tự động
                    e.printStackTrace();
                }
            }

            if (outputStream != null){
                thử {
                    outputStream.close();
                } bắt (IOException e) {
                    // TODO Khối catch được tạo tự động
                    e.printStackTrace();
                }
            }

            if (inputStream != null){
                thử {
                    inputStream.close();
                } bắt (IOException e) {
                    // TODO Khối catch được tạo tự động
                    e.printStackTrace();
                }
            }
        }*/ //catch (ClassNotFoundException e) {
        // TODO Khối catch được tạo tự động
        //e.printStackTrace();
        //}
        catch (ClassNotFoundException e) {
            // TODO Khối catch được tạo tự động
            e.printStackTrace();
        }
    }

    public void handPacket(Packet hp)
    {
        if(hp.getOpCode() == 5)
        {
            this.finish();
        }

        this.finish();
    }

}

问候

1 Câu trả lời

如果您希望服务器能够在需要时联系客户端，那么每当服务器使用accept()方法获取客户端Socket对象时，根据您的需要将其存储在HashMap或ArrayList中。现在您已经将客户端套接字对象与服务器一起保存了。

关于java - 在 Java 服务器中重用客户端 java 套接字，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/10870892/