多客户端java客户端服务器聊天_Java_Multithreading_Server_Client_Chat

多客户端java客户端服务器聊天

java multithreading server

多客户端java客户端服务器聊天,java,multithreading,server,client,chat,Java,Multithreading,Server,Client,Chat,我正在尝试写一个多客户端服务器聊天。所有东西都应该在同一台计算机上运行，每个客户端都在不同的shell终端控制台中。我读了这方面的几个线程，人们说，我应该在服务器上为每个连接的客户端运行新线程。这就是我所做的。尽管如此，服务器仍在其控制台上打印来自每个客户端的消息，但客户端只能看到他们编写的消息，而不能看到聊天时提交的所有消息。我该怎么做才能修好它以下是代码：服务器：服务器线程： import java.io.IOException; import java.io.PrintStream;

我正在尝试写一个多客户端服务器聊天。所有东西都应该在同一台计算机上运行，每个客户端都在不同的shell终端控制台中。我读了这方面的几个线程，人们说，我应该在服务器上为每个连接的客户端运行新线程。这就是我所做的。尽管如此，服务器仍在其控制台上打印来自每个客户端的消息，但客户端只能看到他们编写的消息，而不能看到聊天时提交的所有消息。我该怎么做才能修好它

以下是代码：服务器：

服务器线程：

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Scanner;


public class ServerThread extends Thread {
    Socket socket=null;
    private Scanner sc;
    private PrintStream ps;
    public ServerThread(Socket s) {
        this.socket=s;

    }



        public void run(){
            DateFormat df = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
            Calendar cal = Calendar.getInstance();
            String response;    
                while(true){    
                try {
                        sc = new Scanner(socket.getInputStream());
                        ps = new PrintStream(socket.getOutputStream());
                } catch (IOException e) {
                            // TODO Auto-generated catch block
                        e.printStackTrace();
                }

                if((response=sc.nextLine())!=null){


                    System.out.println(df.format(cal.getTime())+" Napisal "+response);

                    ps.println(df.format(cal.getTime())+" Napisal :"+response);

                    }   
            }


        }


}

和客户

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;




public class Client {
    static Scanner sc;
    static Scanner sc2;
    static Socket s;
    static String response;
    public static void main(String[]args) throws UnknownHostException, IOException{
        String send;
        sc=new Scanner(System.in);  //client send scanner
        s = new Socket("127.0.0.1", 5051);
        sc2 = new Scanner(s.getInputStream());  //client response scanner
        PrintStream ps = new PrintStream(s.getOutputStream());

        while(true){

            System.out.println(">");    
            send = sc.nextLine();

            ps.println(send);       
            // I tried run new thread for responses
            //Thread thread = new Thread(new Runnable(){
                //public void run(){
                    //while(true){
                        response=sc2.nextLine();        
                        System.out.println(response);
                //  }   
                //}
            //});
        }

    }
}

客户端需要两个线程：

一个用来读取来自服务器的消息
另一个线程从用户处获取输入

第一个线程（来自服务器的读取器）只是读取传入消息并将其打印到控制台

第二个线程（服务器写入器）获取用户输入并将其发送到服务器

实际上，在您的代码中，客户机上只有一个线程（主线程）

您必须实现ServerThread实例与服务器之间的通信（例如通过接口）。必须将ServerThread获取的消息通知服务器，然后将此消息转换到其他（以前建立的）套接字（必须跟踪这些套接字）

您的客户端有两个扫描仪，但其中一个实际上会在nextLine（）调用中阻止另一个。因此，您必须在单独的线程中运行其中一个扫描仪

以下代码适用于我，但必须考虑螺纹安全：

public interface MessageListener {
  void acceptMessage(String message);
}

public class Server {
  private static final int PORT_NUM = 5051;
  private static ServerSocket serS;
  private static List<PrintStream> sockets = new ArrayList<PrintStream>();
  public static void main(String[] args) throws IOException{
    DateFormat df = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
    Calendar cal = Calendar.getInstance();
    System.out.println(df.format(cal.getTime())+" Server waiting on port "+PORT_NUM);
    try {
        serS = new ServerSocket(PORT_NUM);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    MessageListener listener = new MessageListener() {
        @Override
        public void acceptMessage(String message) {
            Iterator<PrintStream> it = sockets.iterator();
            while (it.hasNext()) {
                PrintStream ps = it.next();
                ps.println("Have got message: " + message);
            }
        }
    };

    while(true){
        try {
            Socket s = serS.accept();
            sockets.add(new PrintStream(s.getOutputStream()));
            System.out.println("New user connected");
            ServerThread st=new ServerThread(s, listener);
            st.start();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }
}


public class ServerThread extends Thread {
  Socket socket=null;
  private Scanner sc;
  //private PrintStream ps;
  private final MessageListener listener;

  public ServerThread(Socket s, MessageListener listener) {
    this.socket=s;
    this.listener = listener;
  }

  public void run(){
    DateFormat df = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
    Calendar cal = Calendar.getInstance();
    String response;
    while(true){
        try {
            sc = new Scanner(socket.getInputStream());
            //ps = new PrintStream(socket.getOutputStream());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if((response=sc.nextLine())!=null){


            System.out.println(df.format(cal.getTime())+" Napisal "+response);

            //ps.println(df.format(cal.getTime())+" Napisal :"+response);
            listener.acceptMessage(response);
        }
      }


  }


}

public class Client {
  static Scanner sc;
  static Scanner sc2;
  static Socket s;
  static String response;
  public static void main(String[]args) throws UnknownHostException, IOException{
    String send;
    sc=new Scanner(System.in);  //client send scanner
    s = new Socket("127.0.0.1", 5051);
    ResponseListener l = new ResponseListener(new Scanner(s.getInputStream()));
    Thread t = new Thread(l);
    t.start();

    PrintStream ps = new PrintStream(s.getOutputStream());

    while(true){

        System.out.println(">");
        send = sc.nextLine();

        ps.println(send);
    }

}

static class ResponseListener implements Runnable {
    private final Scanner scanner;

    ResponseListener(Scanner scanner) {
        this.scanner = scanner;
    }

    @Override
    public void run() {
        while (true) {
            response = scanner.nextLine();
            System.out.println(response);
        }
    }
}

公共接口MessageListener{
无效接受消息（字符串消息）；
}
公共类服务器{
专用静态最终int端口_NUM=5051；
专用静态服务器；
私有静态列表套接字=新的ArrayList（）；
公共静态void main（字符串[]args）引发IOException{
DateFormat df=新的简化格式（“日/月/年HH:MM:ss”）；
Calendar cal=Calendar.getInstance（）；
System.out.println（df.format（cal.getTime（））+“服务器等待端口”+端口号）；
试一试{
serS=新服务器套接字（端口号）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
MessageListener=新建MessageListener（）{
@凌驾
公共无效接受消息（字符串消息）{
Iterator it=sockets.Iterator（）；
while（it.hasNext（））{
PrintStream ps=it.next（）；
ps.println（“收到消息：+消息”）；
}
}
};
while（true）{
试一试{
套接字s=serS.accept（）；
添加（新的打印流（s.getOutputStream（））；
System.out.println（“新用户连接”）；
ServerThread st=新的ServerThread（s，侦听器）；
st.start（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
公共类ServerThread扩展线程{
套接字=空；
私人扫描仪sc；
//私人印刷品；
私有最终消息侦听器；
公共服务器线程（套接字、消息侦听器）{
这个.socket=s；
this.listener=listener；
}
公开募捐{
DateFormat df=新的简化格式（“日/月/年HH:MM:ss”）；
Calendar cal=Calendar.getInstance（）；
字符串响应；
while（true）{
试一试{
sc=新扫描仪（socket.getInputStream（））；
//ps=新的打印流（socket.getOutputStream（））；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
if（（response=sc.nextLine（））！=null）{
System.out.println（df.format（cal.getTime（））+“Napisal”+响应）；
//ps.println（df.format（cal.getTime（））+“Napisal:”+响应）；
acceptMessage（响应）；
}
}
}
}
公共类客户端{
静态扫描仪；
静态扫描仪sc2；
静态插座；
静态字符串响应；
公共静态void main（字符串[]args）抛出UnknownHostException、IOException{
字符串发送；
sc=新扫描仪（System.in）；//客户端发送扫描仪
s=新插座（“127.0.0.1”，5051）；
ResponseListener l=新的ResponseListener（新的扫描仪（s.getInputStream（））；
螺纹t=新螺纹（l）；
t、 start（）；
PrintStream ps=新的PrintStream（s.getOutputStream（））；
while（true）{
System.out.println（“>”）；
send=sc.nextLine（）；
ps.println（发送）；
}
}
静态类ResponseListener实现Runnable{
私人最终扫描仪；
应答员（扫描仪）{
this.scanner=扫描器；
}
@凌驾
公开募捐{
while（true）{
响应=scanner.nextLine（）；
System.out.println（响应）；
}
}
}

}

事实上是的，现在客户端只有一个线程（main）。过去，我有第二个线程接收来自服务器的消息，但它不起作用。所以我把它扔掉了。

public interface MessageListener {
  void acceptMessage(String message);
}

public class Server {
  private static final int PORT_NUM = 5051;
  private static ServerSocket serS;
  private static List<PrintStream> sockets = new ArrayList<PrintStream>();
  public static void main(String[] args) throws IOException{
    DateFormat df = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
    Calendar cal = Calendar.getInstance();
    System.out.println(df.format(cal.getTime())+" Server waiting on port "+PORT_NUM);
    try {
        serS = new ServerSocket(PORT_NUM);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    MessageListener listener = new MessageListener() {
        @Override
        public void acceptMessage(String message) {
            Iterator<PrintStream> it = sockets.iterator();
            while (it.hasNext()) {
                PrintStream ps = it.next();
                ps.println("Have got message: " + message);
            }
        }
    };

    while(true){
        try {
            Socket s = serS.accept();
            sockets.add(new PrintStream(s.getOutputStream()));
            System.out.println("New user connected");
            ServerThread st=new ServerThread(s, listener);
            st.start();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }
}


public class ServerThread extends Thread {
  Socket socket=null;
  private Scanner sc;
  //private PrintStream ps;
  private final MessageListener listener;

  public ServerThread(Socket s, MessageListener listener) {
    this.socket=s;
    this.listener = listener;
  }

  public void run(){
    DateFormat df = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
    Calendar cal = Calendar.getInstance();
    String response;
    while(true){
        try {
            sc = new Scanner(socket.getInputStream());
            //ps = new PrintStream(socket.getOutputStream());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if((response=sc.nextLine())!=null){


            System.out.println(df.format(cal.getTime())+" Napisal "+response);

            //ps.println(df.format(cal.getTime())+" Napisal :"+response);
            listener.acceptMessage(response);
        }
      }


  }


}

public class Client {
  static Scanner sc;
  static Scanner sc2;
  static Socket s;
  static String response;
  public static void main(String[]args) throws UnknownHostException, IOException{
    String send;
    sc=new Scanner(System.in);  //client send scanner
    s = new Socket("127.0.0.1", 5051);
    ResponseListener l = new ResponseListener(new Scanner(s.getInputStream()));
    Thread t = new Thread(l);
    t.start();

    PrintStream ps = new PrintStream(s.getOutputStream());

    while(true){

        System.out.println(">");
        send = sc.nextLine();

        ps.println(send);
    }

}

static class ResponseListener implements Runnable {
    private final Scanner scanner;

    ResponseListener(Scanner scanner) {
        this.scanner = scanner;
    }

    @Override
    public void run() {
        while (true) {
            response = scanner.nextLine();
            System.out.println(response);
        }
    }
}