TCP流套接字编程(模拟多个客户端与服务器交互)

目录

一、ServerSocket API

1.1、ServerSocket构造方法

1.2、ServerSocket方法

二、Socket API 

2.1、socket构造方法 

2.2、socket方法

三、TCP 中的长短连接

四、示例 

实现聊天室功能

五、存在的问题 


一、ServerSocket API

ServerSocket 是创建TCP服务端Socket的API。

1.1、ServerSocket构造方法

方法签名 方法说明
ServerSocket(int port) 创建一个服务端流套接字Socket,并绑定到指定端口

1.2、ServerSocket方法

方法签名 方法说明
Socket accept() 开始监听指定端口(创建时绑定的端口),有客户连接之后,返回一个服务端Socket对象,并基于该Socket建立与客户端的连接,否则阻塞等待
void close() 关闭此套接字

二、Socket API 

Socket是客户端Socket,或服务端中接收到客户端建立连接(accpet方法)的请求后,返回的服务端Socket。

不管是客户端还是服务端Socket,都是双方建立连接以后,保存的对端信息,以及用来与对方收发数据的。

2.1、socket构造方法 

方法签名 方法说明
Socket(String host,int port) 创建一个客户端流套接字Socket,并与对应IP主机上,对应的端口的进程建立连接。

2.2、socket方法

方法签名 方法说明
InetAddress getInetAddress() 返回套接字所连接的地址
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流

三、TCP 中的长短连接

TCP发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接。

  1. 短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说短连接只能一次收发数据
  2. 长连接:不关闭连接,一致保持连接状态,双方不停的收发数据,即是长连接。也就是说长连接能够多次收发数据。 

对比以上长短连接,两者区别如下:

  • 建立连接、关闭连接的耗时:短连接每次请求、响应都需要建立连接,关闭连接;而长连接只需要建立一次连接即可,之后的请求、响应都可以直接传输。相对于说建立连接、关闭连接也是需要耗时的,长连接效率比较高。
  • 主动发送请求不同:短连接一般是客户端主动向服务端发起请求;而长连接不论是客户端还是服务端都可以向对方发起请求。
  • 两者使用的场景不同:短连接适用于客户端请求频率不高的场景,如浏览网页等。长连接使用于客户端与服务端通信频繁的场景,如聊天室等。

四、示例 

实现聊天室功能

  1. 客户端先接收键盘输入,循环接收客户端输入内容,发起聊天。
  2. 发送请求:用户输入的数据封装为输出流,发送到服务端 。
  3. 服务端接收并处理请求:接收请求数据,根据该请求数据来计算响应。
  4. 服务端返回响应:将响应数据封装为输出流,返回给客户端。
  5. 客户端接收响应:简单的打印输出所有的响应内容。

1、基于TCP的客户端


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 基于TCP的客户端
 */
public class TCPEchClient {
    //生命Socket对象
    public Socket socket;
    //通过构造方法来初始化Socket,指定IP地址,端口
    public TCPEchClient(String ServerIp, int port) throws IOException {
        //根据服务器的IP与端口号创建Socket对象
        this.socket=new Socket(ServerIp,port);
    }
    public void start(){
        System.out.println("客户端已启动...");
        try {
            InputStream inputStream=socket.getInputStream();
            OutputStream outputStream=socket.getOutputStream();
            //循环接收用户的输入
            while(true){
                System.out.print("->");
                Scanner sc=new Scanner(System.in);
                String request=sc.nextLine();
                if(request==null||request.equals("")){
                    System.out.println("输入内容不能为空!!!");
                    continue;
                }
                //2、把用户的输入封装到输出流中,可以用PrintWriter简化操作
                PrintWriter writer=new PrintWriter(outputStream);
                //3、把数据发送出去(写数据)
                writer.println(request);
                //强制刷新缓冲区
                writer.flush();
                //4、接收服务器的响应
                Scanner responseSc=new Scanner(inputStream);
                //5、解析相应的数据
                String response=responseSc.nextLine();
                //6、打印日志
                System.out.printf("request=%s,response=%s\n",request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //初始化客户端
    public static void main(String[] args) throws IOException {
        TCPEchClient tcpEchClient=new TCPEchClient("127.0.0.1",9090);
        tcpEchClient.start();
    }
}

2、基于TCP的服务端


import tcp.TCPEchoSever;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * 基于TCP的服务端
 */
public class TCPEchServer {
    //声明一个服务端的类
    public ServerSocket socket;
    //构造方法,初始化对象
    public TCPEchServer(int port) throws IOException {
        //校验端口
        if(port<1||port>65535){
            throw new RuntimeException("端口号建议在1025~65535之间");
        }
        //根据指定的端口号初始化Socket服务
        this.socket=new ServerSocket();
    }
    public void start() throws IOException {
        System.out.println("服务已启动等待客户端连接...");
        //循环接收服务器连接
        while(true){
            //接收客户端请求
            Socket clientSocket=socket.accept();
            //接收到客户端连接之后,交给专门处理连接的方法。
            processConnection(clientSocket);
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s %d]客户端已上线.\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //所有的通信数据都在Socket对象中clientSocket,Tcp传输的数据是字节流的形式
        //1、获取输入输出流
        try {
            InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream();
            //循环处理客户端发来的请求
            while(true){
                //Scanner简化字符串的获取
                Scanner sc=new Scanner(inputStream);
                //判断是否还有数据
                if(!sc.hasNextLine()){
                    System.out.printf("[%s:%d] 客户端已下线.\n",
                            clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                //获取用户发来的请求
                String request=sc.nextLine();
                String response=process(request);
                //把响应返回给客户端
                PrintWriter writer=new PrintWriter(outputStream);
                //强制刷新缓冲区
                writer.flush();
                System.out.printf("[%s:%d]request=%s,response=%d\n",clientSocket.getInetAddress().toString()
                        ,clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //关闭客户端连接
            clientSocket.close();
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TCPEchoSever tcpEchoSever=new TCPEchoSever(9090);
        tcpEchoSever.start();
    }
}

3、封装响应数据

import java.io.IOException;
import java.util.Scanner;

public class TCPMsgServer extends TCPEchoSever {

    public TCPMsgServer(int port) throws IOException {
        super(port);
    }

    //实现一个聊天的功能
    @Override
    protected String process(String request) {
        //1.打印发送方发来的消息
        System.out.println("->"+request.toString());
        //2.回复对方的消息
        Scanner sc=new Scanner(System.in);
        String response=sc.nextLine();
        //3.返回消息
        return response;
    }

    public static void main(String[] args) throws IOException {
        TCPMsgServer tcpMsgServer=new TCPMsgServer(9090);
        tcpMsgServer.start();
    }
}

运行结果:

TCP流套接字编程(模拟多个客户端与服务器交互)_第1张图片

五、存在的问题 

1、首先将客户端类对象设置为多实例创建状态,这样就可以创建出多个客户端对象

TCP流套接字编程(模拟多个客户端与服务器交互)_第2张图片

2、创建第二个客户端时,并没有按预想的连接服务端成功

TCP流套接字编程(模拟多个客户端与服务器交互)_第3张图片 3、出现这个现象的原因

TCP流套接字编程(模拟多个客户端与服务器交互)_第4张图片

4、如何去解决这个问题,实现多个客户端呢?这时就需要引入多线程来执行任务。

利用线程来执行不同的客户端任务,就需要创建一个线程服务端类,该类继承服务端类,重写start()方法。

import tcp.TCPEchoSever;
import java.io.IOException;
import java.net.Socket;

public class TCPThreadServer extends TCPEchoSever {
    public TCPThreadServer(int port) throws IOException {
        super(port);
    }
    @Override
    public void start() throws IOException {
        System.out.println("服务已启动,等待客户端连接.....");
        //循环接收服务器的连接
        while(true){
            //接收客户端请求
            Socket clientSocket = socket.accept();
            //为每一个连接创建线程
            Thread thread=new Thread(() ->{
                //接收到客户端连接之后,交给专门处理连接的方法
                try {
                    //在子线程中处理连接
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            //启动线程
            thread.start();
        }
    }

    public static void main(String[] args) throws IOException {
        TCPThreadServer tcpThreadServer=new TCPThreadServer(9090);
        tcpThreadServer.start();
    }
}

运行结果:

TCP流套接字编程(模拟多个客户端与服务器交互)_第5张图片

5、手动创建线程太过麻烦,可以利用线程池来进行创建线程 ,还是跟上述操作差不过,重写start()方法

import java.io.IOException;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TCPThreadPoolServer extends TCPEchServer {

    public TCPThreadPoolServer(int port) throws IOException {
        super(port);
    }

    @Override
    public void start() throws IOException {
        System.out.println("服务已启动,等待客户端上线...");
        //创建一个线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3,
                10,
                1,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10)); //阻塞队列可存10个服务器
        //循环接收连接
        while (true) {
            //接收客户端请求
            Socket clientSocket = socket.accept();
            //把处理请求连接的操作,加入到线程池中
            threadPool.submit(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }
    public static void main(String[] args) throws IOException {
        TCPThreadPoolServer server=new TCPThreadPoolServer(9090);
        server.start();
    }
}

你可能感兴趣的:(tcp/ip,网络,服务器)