如何在覆盖的 run() 方法中使用现有对象？

Question

I'm a beginner in programming and do strugle a bit. So I'm building a TCP peer to peer Chat and that requires me to divide the tasks -> Threads. So I want to built a Thread for the "writing" part of that connection (Scanner, DataOutputStream etc.) In order to do that i implemented Runnable and that forces me to write my Thread in the overwritten run() method. Now I have a bit of a problem, because in Order to send my messages out to the "other end (another client) I need the "socket.getOutputStream" but I cant use it in the run() method and i dont know how to fix this problem, sitting already a week on this problem. Any ideas?

public class ClientHorcher implements Runnable {

    public static void main(String[] args) {
        
        try {
            ServerSocket serverSocket = new ServerSocket(11111);
            System.out.println("Waiting For Connection:-");
            Socket socket = serverSocket.accept();
            Scanner scanner = new Scanner(System.in);
            DataInputStream datenRein = new DataInputStream(socket.getInputStream());
            DataOutputStream datenRaus = new DataOutputStream(socket.getOutputStream());
            String nickname;
            System.out.print("Gib einen Nickname ein: ");
            nickname = scanner.nextLine();
            while (true) {
                String vonMsg = datenRein.readUTF(in);
                System.out.println("Client:-" + vonMsg);
                if (vonMsg.equals("exit")) {
                    System.out.println("Beenden!!!");
                    datenRein.close();
                    datenRaus.close();
                    scanner.close();
                    socket.close();
                    serverSocket.close();
                    System.exit(0);
                }

                System.out.print(nickname + ":-");
                String zuMsg = scanner.nextLine();
                datenRaus.writeUTF(zuMsg);
                if (zuMsg.equals("exit")) {
                    System.out.println("Quiting!!!");
                    datenRein.close();
                    datenRaus.close();
                    scanner.close();
                    socket.close();
                    serverSocket.close();
                    System.exit(0);
                }
            }
        } catch (IOException e) {
        
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
       
        
    }

}`
`public class ClientVerbinder implements Runnable  {
    


    public static void main(String[] args) {

        try {
            Socket socket = new Socket("Localhost", 11111);
            System.out.println("Connected");
            Scanner scanner = new Scanner(System.in);
            DataInputStream datenRein = new DataInputStream(socket.getInputStream());
            DataOutputStream datenRaus = new DataOutputStream(socket.getOutputStream());
            String nickname;
            System.out.print("Gib einen Nickname ein: ");
            nickname = scanner.nextLine();

            while (true) {
                System.out.print(nickname+":-");
                String zuMsg = scanner.nextLine();
                datenRaus.writeUTF(zuMsg);
                if (zuMsg.equals("exit")) {
                    System.out.println("Beenden!!!");
                    datenRein.close();
                    datenRaus.close();
                    scanner.close();
                    socket.close();
                    System.exit(0);
                }
                String vonMsg = datenRein.readUTF();
                System.out.println("CLient"+":-" + vonMsg);
                if (vonMsg.equals("exit")) {
                    System.out.println("Quiting!!!");
                    datenRein.close();
                    datenRaus.close();
                    scanner.close();
                    socket.close();
                    System.exit(0);
                }
            }
        } catch (UnknownHostException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }

    }
    @Override
    public void run() {
       
        
    
    }

}

Answer 1

Multiple possibilities.

1. Use static variables. Normally you would not do that, but because your code is all-static, you could

2. Use member variables in an OO-style code.

3. If you wanted to do it properly, you'd split the server into two parts:

   1. The ServerSocket listener that only listens to connections ( Socket connectionToClient = ss.accept ), and whenever a connection comes in, creates a new
   2. ClientHandler, passes in the Socket, and the ClientHandler then starts its own thread internally

This way, the ClientHandler has all the data it needs (again as member variables) and can work on its own concerns (aka 'separation of concerns).

Update

This is what I created. Really simple.

1. Start Server
2. Start 1st client
3. Start 2nd client
4. In any client, type message
5. Other client receives it

Classes:

SimpleServer

package stackoverflow.simplemtserver;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingDeque;

public class SimpleServer { // make it closeable and close sockets if this is not standalone



    public static void main(final String[] args) throws IOException {
        final int port = 7623;
        new SimpleServer(port);
    }



    final LinkedBlockingDeque<SimpleServerClientHandler> clientHandlers = new LinkedBlockingDeque<>();

    private final ServerSocket mServerSocket;

    public SimpleServer(final int pPort) throws IOException {
        mServerSocket = new ServerSocket(pPort);

        final Thread m = new Thread(() -> runLoop(), getClass().getSimpleName() + " Main Loop");
        m.start();
    }



    private void runLoop() {
        while (true) {
            try {
                System.out.println("Server waiting for connection...");
                @SuppressWarnings("resource") final Socket cs = mServerSocket.accept(); // do NOT close the socket here, no try-resource, will interrupt threaded communication!
                final SimpleServerClientHandler ch = new SimpleServerClientHandler(this, cs);
                clientHandlers.add(ch);
                System.out.println("Connection accepted, handler started. Handlers active: " + clientHandlers.size());

            } catch (final IOException e) {
                // handle this how you need it
                e.printStackTrace();
            }
        }
    }



    public void signOffClientHandler(final SimpleServerClientHandler pClientHandler) {
        clientHandlers.remove(pClientHandler); // we could also accommplish this using stack trace to avoid access from outside, but this is the easier solution
    }



    public void spreadMessageToClients(final String pMessageFromClient, final SimpleServerClientHandler pSimpleServerClientHandler) {
        for (final SimpleServerClientHandler ch : clientHandlers) {
            if (ch != pSimpleServerClientHandler) ch.relayMessageToClient(pMessageFromClient); // we can work with identity == and != here
        }
    }



}

SimpleServerClientHandler

package stackoverflow.simplemtserver;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class SimpleServerClientHandler {



    private final SimpleServer      mParentServer;
    private final Socket            mClientSocket;
    private final DataInputStream   mDIS;
    private final DataOutputStream  mDOS;

    public SimpleServerClientHandler(final SimpleServer pSimpleServer, final Socket pCS) throws IOException {
        mParentServer = pSimpleServer;
        mClientSocket = pCS;

        mDIS = new DataInputStream(mClientSocket.getInputStream());
        mDOS = new DataOutputStream(mClientSocket.getOutputStream());
        final Thread t = new Thread(() -> runComms(), getClass().getSimpleName() + " Comms Loop");
        t.setDaemon(true); // threads now stop once server stops. this is NOT a soft exit
        t.start();
    }



    private void runComms() {
        try {
            try {
                while (true) {
                    // do all your logic here, work with DIS and DOS

                    final String messageFromClient = mDIS.readUTF();
                    if (messageFromClient == null) break;

                    if (!messageFromClient.startsWith("*")) mParentServer.spreadMessageToClients(messageFromClient, this);
                }

            } catch (final Exception e) {
                // TODO: handle exception
            }

        } finally {
            try {
                mClientSocket.close(); // also closes DataIn/Out
            } catch (final IOException e) { /* ignore */ }
            mParentServer.signOffClientHandler(this);
        }
    }



    public void relayMessageToClient(final String pMessageFromClient) {
        try {
            mDOS.writeUTF("*" + pMessageFromClient);
        } catch (final IOException e) {
            // ignore unless needed otherwise
        }
    }



}

SimpleClient

package stackoverflow.simplemtserver;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class SimpleClient {



    public static void main(final String[] args) throws UnknownHostException, IOException {
        final String hostname = "localhost";
        final int port = 7623;

        try (final Socket s = new Socket(hostname, port);
                final DataInputStream dis = new DataInputStream(s.getInputStream());
                final DataOutputStream dos = new DataOutputStream(s.getOutputStream());
                final Scanner scanner = new Scanner(System.in);) {

            final Thread t = new Thread(() -> runListenerLoop(dis), SimpleClient.class.getSimpleName() + " Reader Thread");
            t.setDaemon(true);
            t.start();

            while (true) {
                System.out.println("Enter message:");
                System.out.flush();
                final String msg = scanner.nextLine();
                if (msg == null) break;

                System.out.println("Spreading message: " + msg);
                dos.writeUTF(msg);
            }
        }
    }

    private static void runListenerLoop(final DataInputStream pDis) {
        while (true) {
            try {
                System.out.println("Waiting for incoming messages...");
                final String msg = pDis.readUTF();
                System.out.println("Received: " + msg);

            } catch (final SocketException e) {
                //              if ("java.net.SocketException: Connection reset".equals(e.getMessage())) 
                break;
            } catch (final IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }



}

From here on, there's now more ways you can extend this client/server communication:

• use opcodes (read/write int constants or enums before data) to distinguish for special operations and/or messages (like this here puts an asterisk in front of the string to prevent re-re-laying the same message indefinitely over the network)
• read multiple strings for user, message, additional options
• implement this is a user friendly UI so you dont have to use console I/O

Update 2

The pure peer-to-peer solution is this one.

• If the app is run without params, it goes into listening mode, waiting for a connection.
• If the app is run with one arguments, it interprets it as listening port and also goes into listening mode.
• If the app is un with [hostname] [port] arguments, it will try to connect there

Example:

• start first app without arguments (listening)
• start second app with arguments "localhost 7642" (connecting)
• both apps will now
• • connect,
• • then set up I/O resources,
• • then start the listening thread for incoming messages
• • then go into the read-keyboard-and-write-to-socket loop
• now you can type a message in one of the apps, the other one will receive it

p2p code:

package stackoverflow.simplemtserver;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class SimplePeerToPeerClient {



    static public final int DEFAULT_PORT = 7642;



    public static void main(final String[] args) throws UnknownHostException, IOException {
        if (args.length == 0) {
            System.out.println("Waiting on default port " + DEFAULT_PORT);
            waitForConnection(DEFAULT_PORT);
        } else if (args.length == 1) {
            final int port = Integer.parseInt(args[0]);
            System.out.println("Waiting on port " + port);
            waitForConnection(port);
        } else if (args.length == 2) {
            final String hostName = args[0];
            final int port = Integer.parseInt(args[1]);
            System.out.println("Connecting to " + hostName + " on port " + port);
            connectToOtherSide(hostName, port);
        } else throw new IllegalArgumentException("Invalid amount of argument! Need none (listen) or 2: [hostname] [port] (connect)");
    }



    private static void waitForConnection(final int pPort) throws IOException {
        try (final ServerSocket ss = new ServerSocket(pPort);) {
            @SuppressWarnings("resource") final Socket socket = ss.accept(); // will get closed later
            startComms(socket);
        } // closes ServerSocket after 1st connection
    }
    private static void connectToOtherSide(final String pHostName, final int pPort) throws UnknownHostException, IOException {
        @SuppressWarnings("resource") final Socket socket = new Socket(pHostName, pPort); // will get closed later
        startComms(socket);
    }



    private static void startComms(final Socket pSocket) throws IOException {
        try (
                final DataInputStream dis = new DataInputStream(pSocket.getInputStream());
                final DataOutputStream dos = new DataOutputStream(pSocket.getOutputStream());
                final Scanner scanner = new Scanner(System.in);) {

            // run the listener loop
            final Thread t = new Thread(() -> runListenerLoop(dis), SimpleClient.class.getSimpleName() + " Reader Thread");
            t.setDaemon(true);
            t.start();

            // run my keyboard-input-send loop
            while (true) {
                System.out.println("Enter message:");
                System.out.flush();
                final String msg = scanner.nextLine();
                if (msg == null) break; // empty input ends client

                System.out.println("Spreading message: " + msg);
                dos.writeUTF(msg);
            }

        } finally {
            try {
                pSocket.close();
            } catch (final IOException e) { /* ignore */ }
        }
    }



    private static void runListenerLoop(final DataInputStream pDis) {
        while (true) {
            try {
                System.out.println("Waiting for incoming messages...");
                final String msg = pDis.readUTF();
                System.out.println("Received: " + msg);

            } catch (final SocketException e) {
                //              if ("java.net.SocketException: Connection reset".equals(e.getMessage()))
                break;
            } catch (final IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }



}