Java网络编程，客户端和服务端相互发送信息，可是我写的双方都没读到对方发送的信息，代码如下

Posted 2023-03-21

这个地方有问题，第一，你必须写入newLine，要不会造成阻塞；第二，你必须先flush后才能读服务器；第三，你从控制台输入应该有个结束标志，要不你在while里面把bw关闭了，你还怎么循环

客户端这个地方重写一下，

while(true)
temp=br.readLine();
if(temp.equals("over"))
break;

bw.write(temp);
bw.newLine();//如果没有，使用readLine则会造成莫名等待
bw.flush();

 不一定改全了，你先试试这些改动，如有问题再找

参考技术A

把 System.out.println(reader.readLine()); 这句去掉

把 bw.close(); 去掉

下面是你的代码，运行试试

客户端

package com.pzr.demo20161021;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class demo3 
    public static void main(String args[])
        try 
            Socket socket  = new Socket("127.0.0.1",8888);
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            
            
            while(true)
                System.out.println("请输入消息：");
//                System.out.println("服务器发过来的消息:"+reader.readLine());
                bw.write(br.readLine());
                bw.newLine();  
                bw.flush();
            
         catch (UnknownHostException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
        
    

 服务端

package com.pzr.demo20161021;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class demo4 
    public static void main(String args[])
        try 
            ServerSocket serverSocket =new ServerSocket(8888);
            Socket socket = serverSocket.accept();
            System.out.println(socket.getInetAddress().getHostAddress()+"已连接");
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter witer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            String string = null;
            while((string = reader.readLine()) != null)
                System.out.println(string);
            
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            while((string = br.readLine()) != null)
                witer.write(string);
                witer.newLine();
                witer.flush();
            
            reader.close();
            br.close();
            
         catch (IOException e) 
            e.printStackTrace();
        
    

参考技术B tcp的东西忘记了，感觉应该是端口的问题。

Java Socket编程之TCP

基于TCP的Socket通信：

服务器端：

1. 创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
2. 调用accept()方法开始监听，等待客户端的连接
3. 连接建立后，通过输入流读取客户发送的请求信息
4. 通过输出流向客户端发送响应信息
5. 关闭相关资源

客户端：

1. 创建客户端Socket，指定服务器地址和端口
2. 连接建立后，通过输出流，向服务器端发送信息
3. 获取输入流，并读取服务器端的响应信息
4. 关闭资源

例：服务器端：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try {
            //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket=new ServerSocket(8888);
            Socket socket=null;
            //记录客户端的数量
            int count=0;
            System.out.println("***服务器即将启动，等待客户端的连接***");
            //循环监听等待客户端的连接
            while(true){
                //调用accept()方法开始监听，等待客户端的连接
                socket=serverSocket.accept();
                //创建一个新的线程
                ServerThread serverThread=new ServerThread(socket);
                //启动线程
                serverThread.start();
                count++;//统计客户端的数量
                System.out.println("客户端的数量："+count);
                InetAddress address=socket.getInetAddress();
                System.out.println("当前客户端的IP："+address.getHostAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

   客户端：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {
    public static void main(String[] args) {
        try {
            //1.创建客户端Socket，指定服务器地址和端口
            Socket socket=new Socket("localhost", 8888);
            //2.获取输出流，向服务器端发送信息
            OutputStream os=socket.getOutputStream();//字节输出流
            PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：alice;密码：789");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3.获取输入流，并读取服务器端的响应信息
            InputStream is=socket.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String info=null;
            while((info=br.readLine())!=null){
                System.out.println("我是客户端，服务器说："+info);
            }
            //4.关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器线程处理类：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class ServerThread extends Thread {
    // 和本线程相关的Socket
    Socket socket = null;
        public ServerThread(Socket socket) {
        this.socket = socket;
    }
    //线程执行的操作，响应客户端的请求
    public void run(){
        InputStream is=null;
        InputStreamReader isr=null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            //获取输入流，并读取客户端信息
            is = socket.getInputStream();
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String info=null;
            while((info=br.readLine())!=null){//循环读取客户端的信息
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //获取输出流，响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("欢迎您！");
            pw.flush();//调用flush()方法将缓冲输出
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //关闭资源
            try {
                if(pw!=null)
                    pw.close();
                if(os!=null)
                    os.close();
                if(br!=null)
                    br.close();
                if(isr!=null)
                    isr.close();
                if(is!=null)
                    is.close();
                if(socket!=null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用TCP通信传输对象:

       ObjectOutputStream oos=new ObjectOutputStream（os）；

       User user=new User(“admin”,”123”);//封装为对象

       oos.writeObject(user);//序列化

Tips:

 　　优先级问题：serverthread.setPriority();//降低优先级，以防运行速度较慢

        输入输出流问题：同一个Socket，关闭输出流则会关闭与之关联的Socket，所以不用关闭输出流，最后关闭Socket即可。