java网络编程TCP聊天全双工

我正在服务器和客户端之间实现一个简单的tcp聊天。我使用多线程，以便服务器和客户端可以同时发送和接收数据（全双工）。该程序可以工作，但如果服务器有一个控制台，既可以键入发送消息，也可以显示接收消息（客户端的情况相同），则当从另一方收到消息时，我无法编辑应发送给服务器或客户端的键入消息。例如：

运行（服务器控制台）：

输入消息以发送客户端：

你：

客户端：hi-server

客户端：再见服务器。

对于这个例子，我键入了一条消息，当客户机已经说hi server bye server时发送给客户机。在收到客户的邮件之前，我看到了我键入的内容，但在收到邮件之后，我既看不到邮件，也无法编辑邮件

我只能使用控制台，因为我不擅长GUI，我希望发送和接收数据都使用相同的控制台

程序代码如下所示

import java.net.*;
import java.io.*;
import java.util.Scanner;
public class ThreadServerSend implements Runnable {
String d;
Socket s1 = null;
Scanner sc = new Scanner(System.in);
public ThreadServerSend(Socket s)
{
    s1=s;
}

public void run()
{
    System.out.println("input msg to send client: ");
    while (true){
    try{

        PrintStream p = new PrintStream(s1.getOutputStream());
    System.out.println("you: ");

                                d=sc.nextLine();
                                p.println(d);
                                if (d.charAt(d.length()-1)=='.'){
                            s1.close();
                            break;}
    }
    catch(IOException e){}
    }
    }
}



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class ThreadServerReceive implements Runnable {

 String m;
Socket s2 = null;
Scanner sc = new Scanner(System.in);
public ThreadServerReceive(Socket s)
{
    s2=s;
}

public void run()
{
    while (true){
    try{

     BufferedReader b = new BufferedReader(new InputStreamReader(s2.getInputStream()));
        m = b.readLine();
                        System.out.println("client: "+m);

                        if (m.charAt(m.length()-1)=='.'){
                            s2.close();
                            break;}}
    catch(IOException e){}
    }
    }
}




import java.io.*;
import java.net.*;
import java.util.*;
public class Server {

public static void main(String[] args) throws UnknownHostException, IOException{
    // TODO Auto-generated method stub


    ServerSocket s = new ServerSocket(444);

            Socket s1 = s.accept();

            new Thread(new ThreadServerSend(s1)).start();
            ServerSocket s4 = new ServerSocket(443);
    Socket s2=s4.accept();
    new Thread(new ThreadServerReceive(s2)).start();



}
}



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
public class ThreadClientSend implements Runnable {

 String d;
Socket s1 = null;
Scanner sc = new Scanner(System.in);
public ThreadClientSend(Socket s)
{
    s1=s;
}

public void run()
{
    System.out.println("Input msg to send server: ");
    while (true){
    try{

        PrintStream p = new PrintStream(s1.getOutputStream());

    System.out.println("you: ");
    String d = new Scanner(System.in).nextLine();



    p.println(d);
            if (d.charAt(d.length()-1)=='.'){
                            s1.close();
                            break;}
      }
    catch(IOException e){}
    }
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
public class ThreadClientReceive implements Runnable {

 String m;
Socket s1 = null;
Scanner sc = new Scanner(System.in);
public ThreadClientReceive (Socket s)
{
    s1=s;
}

public void run()
{
    while (true){
    try{
        BufferedReader b = new BufferedReader(new InputStreamReader(s1.getInputStream()));
        m= b.readLine();
        System.out.println("Server: "+m);
                     if (m.charAt(m.length()-1)=='.')
                        {
                            s1.close();
                              break;  
                        }
      }
    catch(IOException e){}
    }
    }

}


import java.io.*;
import java.net.*;
import java.util.*;
public class Client {

public static void main(String[] args) throws UnknownHostException, IOException{
    // TODO Auto-generated method stub


    Socket s1= new Socket("localhost",444);
            Socket s2 = new Socket("localhost",443);
            new Thread(new ThreadClientReceive(s1)).start();

    new Thread(new ThreadClientSend(s2)).start();




}

}

---

有点晚了，但我实际上为我的编程课提供了这个聊天客户端的工作版本。我想我还是把它贴在这里吧。我将TCP（全双工）与多线程结合使用，并使其在控制台中工作。小问题是您看不到自己的名字（因为控制台只有一个活动行），但在其他方面它工作得很好

服务器（客户端大致相同，显然

Sockets

是普通套接字，而不是

ServerSockets

）：

import java.net.*；
导入javax.swing.*；
导入java.awt.*；
导入java.util.*；
导入java.io.*；
导入java.awt.event.*；
导入java.awt.geom.*；
导入java.awt.image.*；
@抑制警告（“串行”）
公共类serverProgII扩展线程
{
私有静态ObjectOutputStream oos；
私有静态对象输出流ois；
专用静态套接字连接；
私有静态服务器套接字服务器；
私有静态字符串ip，clientIP，textin，exitword=“exit”；
专用静态网络消息n消息；
私有静态布尔连接=false；
私有静态布尔值done=false；
私有静态字符串myName=“”；
专用静态整数计数器=0；
公共静态布尔启动=false；
公共字符串类型；
公共静态void main（字符串[]args）
{
试一试{
BufferedReader brin=新的BufferedReader（新的InputStreamReader（System.in））；
System.out.print（“输入您的姓名：>”；//向DOS窗口发送提示
myName=brin.readLine（）；//读入用户输入
setupConnection（）；
setupStreams（）；
开始=真；
}捕获（例外e）{
System.out.println（“设置流和连接时出现问题！”）；
}
serverProgII发送方=新的serverProgII（“发送方”）；
serverProgII接收器=新的serverProgII（“接收器”）；
sender.start（）；
receiver.start（）；
}
公共服务器程序II（字符串t）
{
超级（）；
类型=t；
}
公开募捐{
while（启动）{
开关（类型）{
“发件人”一案：
发送者（）；
打破
案例“接收人”：
接收器（）；
打破
}
试一试{
Thread.sleep（500）；//毫秒
}捕获（例外e）{}
}   
}
/*runServer（）
这是所有实际工作完成的地方。
*/
公共无效发送者（）
{
试一试{
BufferedReader inn=新的BufferedReader（新的InputStreamReader（System.in））；
textin=inn.readLine（）；
发送数据（文本输入）；
if（textin.equals（exitword））//如果在关闭服务器时键入“exit”。
{
开始=错误；
服务器关闭（）；
}
}
捕获（例外e）{
e、 printStackTrace（）；
}
}
公共接管人（）{
试一试{
getData（）；
}捕获（例外e）{
System.out.println（“获取数据时出错”）；
}
}
//设置连接
公共静态void setupConnection（）引发IOException
{
System.out.println（“服务器模式激活”）；
server=newserversocket（8000）；//在端口8000处创建套接字
System.out.println（“等待连接…”）；
connection=server.accept（）；//等待连接
System.out.println（“接收到的连接：+connection.getInetAddress（））；
clientIP=”“+connection.getInetAddress（）；//打印出客户端IP地址
}//setupconnection（）
//设置流连接
公共静态void setupStreams（）引发IOException
{
//开河
System.out.println（“流设置”）；
oos=newObjectOutputStream（connection.getOutputStream（））；//构造对象输出流
ois=newObjectInputStream（connection.getInputStream（））；
oos.flush（）；
}//setupStreams（）
//写入/发送网络数据的方法
公共void sendData（字符串toSend）引发IOException
{
尝试
{
nmessage=新的网络消息（myName，toSend）；
oos.writeObject（n消息）；
}//试一试
捕获（IOException IOException）
{
System.out.println（“sendData中的IO异常”）；
}
}//sendData（）
//读取网络数据的方法
public void getData（）引发IOException
{
尝试
{
networkmessagein=（networkmessage）（ois.readObject（））；
System.out.println（messageIn.ipnum+“有点晚了，但我实际上为我的编程类想出了这个聊天客户端的一个工作版本。我想我也可以在这里发布它。我使用了TCP（全双工）和多线程，并且我让它在控制台中工作。小问题是你看不到自己的名字（因为console只有一条活动线路），但在其他方面它工作得很好

服务器（客户端大致相同，显然
Sockets
是普通套接字，而不是
ServerSockets
）：

import java.net.*；
导入javax.swing.*；
导入java.awt.*；
导入java.util.*；
导入java.io.*；
导入java.awt.event.*；
进口
import java.net.*;
import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.io.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;


@SuppressWarnings("serial")
public class serverProgII extends Thread
{

private static ObjectOutputStream oos;
private static ObjectInputStream ois;
private static Socket connection;
private static ServerSocket server;
private static String ip, clientIP, textin, exitword ="exit";
private static networkmessage nmessage;
private static boolean connected = false;
private static boolean done = false;
private static String myName = "";
private static int counter = 0;

public static boolean started = false;
public String type;

public static void main(String[] args)
{
    try {
        BufferedReader brin = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("Enter your name:> "); //send prompt to DOS window
        myName = brin.readLine();       //read in user input
        setupConnection();
        setupStreams();
        started = true;
    } catch (Exception e) {
        System.out.println("Problem setting up streams and connection!");
    }

    serverProgII sender = new serverProgII("sender");
    serverProgII receiver = new serverProgII("receiver");
    sender.start();
    receiver.start();
}

public serverProgII(String t)
{
    super();
    type = t;
}

public void run() {
    while(started) {
        switch(type) {
            case "sender":
                sender();
                break;
            case "receiver":
                receiver();
                break;
        }
        try {
            Thread.sleep(500); //milliseconds
        } catch(Exception e){}
    }   
}

/*  runServer()
    This is where all the actual work gets done.
*/

public void sender()
{
    try {

        BufferedReader inn = new BufferedReader(new InputStreamReader(System.in));
        textin = inn.readLine();

        sendData(textin);

        if (textin.equals(exitword))  // if "exit" is typed in shutdown the server.
        {
            started = false;
            serverShutdown();
        }

    }
    catch (Exception e) {
        e.printStackTrace();
    }
}

public void receiver() {
    try {
        getData();
    } catch(Exception e) {
        System.out.println("Error getting data");
    }
}


//setup connection
public static void setupConnection() throws IOException
{
    System.out.println("SERVER MODE ACTIVATED");
    server = new ServerSocket (8000);                       //create the socket at port 8000
    System.out.println("Waiting For Connection...");
    connection = server.accept();                           //wait for a connection
    System.out.println("Received connection: "+connection.getInetAddress());
    clientIP=""+connection.getInetAddress();                //print out the client IP address

}//setupconnection()

//Setup streams connection
public static void setupStreams() throws IOException
{
    //Open up Streams
    System.out.println("Streams Setup");
    oos=new ObjectOutputStream(connection.getOutputStream()); //construct object output stream
    ois=new ObjectInputStream(connection.getInputStream());
    oos.flush();

}//setupStreams()


//method to write/send network data
public void sendData(String toSend) throws IOException
{
    try
    {
        nmessage = new networkmessage(myName, toSend);
        oos.writeObject(nmessage);
    }//try

    catch (IOException ioException)
    {
        System.out.println("IO exception in sendData");
    }

}//sendData()

//method to read in network data
public void getData() throws IOException
{
    try
    {
        networkmessage messageIn =(networkmessage)(ois.readObject());
        System.out.println(messageIn.ipnum +" << "+messageIn.text);

    }//try

    catch (Exception exp1)
    {
        System.out.println("IO exception in sendData");
    }
}//getData()


public void serverShutdown()
{
    System.out.println("exiting initiated");

    try
    {
        done = true;
        textin = "Chat is terminated.  Have a nice day.";
        oos.close();
        server.close();
        connection.close();
    }

    catch (Exception One)
    {
        System.out.println("bad termination");
    }
}


}  // class serverProg