【JavaEE精炼宝库】网络编程套接字——UDP业务逻辑 | TCP流套接字编程及业务逻辑实现

文章目录

一、UDP业务逻辑实现
二、TCP流套接字编程
- 2.1 API 介绍：
- - 2.1.1 ServerSocket：
  - 2.1.2 Socket：
- 2.2 Java流套接字通信模型：
- 2.3 代码示例：
- - 2.3.1 TCP Echo Server：
  - 2.3.2 TCP Echo Client：
  - 2.3.3 TCP Echo Server优化：
- 2.4 长短连接：
三、TCP业务逻辑实现

一、UDP业务逻辑实现

在上一节：网络编程套接字（上）中我们已经初识了网络编程和利用UDP数据报套接字进行编程。为了更加熟练掌握网络编程，接下来我们会利用UDP套接字来实现一个查询英语单词的简单业务逻辑。

业务目标： 编写UDP版本的字典客户端和字典服务器：
业务实现逻辑： 添加业务逻辑一般都是修改服务器。因为服务器是在我们手里的，客户端不是，且请求的回响是根据服务器来完成的。因此我们只需修改服务器代码即可，客户端的代码不用修改。
业务实现：

通过对比我们发现，要在服务器实现一个查询英语单词的逻辑，其实只要修改将请求生成回响的过程即可。 由于我们前面编写的UDPServer是回显服务器，所以我们可以通过继承的方式，重写process方法即可。具体代码如下：

注意：要修改成自己电脑的 IP 地址才行。

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;
public class UdpDicServer extends UdpEchoServer{
    private Map<String,String> hash = new HashMap<>();
    public UdpDicServer(int port) throws SocketException {
        super(port);
        hash.put("hello","你好");
        hash.put("dog","小狗");
        hash.put("cat","小猫");
    }

    @Override
    public String process(String request) {
        return hash.getOrDefault(request,"该词汇未被查询到");
    }

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

实现效果如下：
在这里插入图片描述

二、TCP流套接字编程

2.1 API 介绍：

2.1.1 ServerSocket：

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

ServerSocket 构造方法：

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

ServerSocket 普通方法：

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

2.1.2 Socket：

Socket是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。

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

Socket 构造方法：

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

Socket 普通方法：

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

2.2 Java流套接字通信模型：

TCP流套接字较UDP数据报套接字就要灵活许多，通信双方建立联系后，就可以通过我们前面学过的 IO 流进行数据传输，非常方便。
在这里插入图片描述

2.3 代码示例：

2.3.1 TCP Echo Server：

首先创建 ServerSocket，接着通过 accept 方法接收Socket，建立连接后通过 IO 流进行数据交互。

代码如下：

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;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpEchoServer {
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动！");
//        单线程
        while(true){
            Socket clientSocket = serverSocket.accept();
            //连接后的逻辑
            processConnection(clientSocket);
        }
    }

    /**
     * 处理连接后的逻辑
     * @param clientSocket
     * @throws IOException
     */
    private void processConnection(Socket clientSocket) throws IOException {
        //这种写法的好处是：可以优雅的 close
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            Scanner in = new Scanner(inputStream);
            while (true) {
                //读取完毕
                if (!in.hasNext()) {
                    System.out.printf("[%s:%d]客户端下线", clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                //获取请求
                String request = in.next();
                //根据请求计算响应
                String response = process(request);
                //将响应写回给客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                //刷新缓存区
                printWriter.flush();
                //打印日志
                System.out.printf("[%s:%d] req:%s resp:%s\n", clientSocket.getInetAddress(), clientSocket.getPort(), request,
                        response);
            }
        }finally{
            clientSocket.close();
        }

    }

    //根据请求计算响应
    public String process(String request) {
        return request;
    }

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

2.3.2 TCP Echo Client：

创建 Socket 向 ServerSocket 发起连接请求，连接成功后，通过 IO 流进行数据交互。

代码如下：

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

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        socket = new Socket(serverIp, serverPort);
    }

    public void start() throws IOException {
        System.out.println("客户端启动！");
        Scanner in = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            while (true) {
                //提示输入请求
                System.out.print("请输入请求:");
                //输入请求
                String request = in.next();
                //发送给服务器获取响应
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                //保证数据发送出去了
                printWriter.flush();
                Scanner scanner = new Scanner(inputStream);
                String response = scanner.next();
                //打印响应
                System.out.println(response);
            }
        }

    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("192.168.0.198", 9090);
        client.start();
    }
}

演示效果如下：

2.3.3 TCP Echo Server优化：

普通的 TCP Echo Server 存在服务器一次只能与一个客户端进行连接的问题，这显然不是我们想要的。

我们可以通过前面所学的多线程来解决这个问题。给每个客户端都分配一个线程。

多线程优化：

由于修改的只是 start 方法，下面就只给出 start 多线程版本，大家自己替换一下即可。

public void start() throws IOException {
        System.out.println("服务器启动！");
//        使用多线程来解决多个客户端的情况
        while (true) {
            Socket clientSocket = serverSocket.accept();
            Thread thread = new Thread(()->{
                try {
                    //用该方法来封装一个连接的逻辑
                    processConnection(clientSocket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
            thread.start();
        }

    }

多线程的效果如下：

线程池优化：

采用线程池的优势有：

1. 减低资源开销： 避免频繁的创建和销毁线程带来的系统资源开销。
2. 提高响应速度： 可以直接利用线程池中存在的线程，不用等待创建线程的时间。
3. 可管理性： 进行统一的分配，可以避免大量因抢占式系统资源分配带来的阻塞。

代码如下：

public void start() throws IOException {
        System.out.println("服务器启动！");
        //线程池解决多个客户端的情况
        ExecutorService service = Executors.newCachedThreadPool();
        while(true){
            Socket clientSocket = serverSocket.accept();
            service.submit(()->{
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        }
    }

线程池效果如下：

2.4 长短连接：

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

短连接： 每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接： 不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

对比以上长短连接，两者区别如下：

建立连接、关闭连接的耗时： 短连接每次请求、响应都需要建立连接，关闭连接，而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
主动发送请求对象： 短连接一般是客户端主动向服务端发送请求，而长连接可以是客户端主动发送请求，也可以是服务端主动发。
两者的使用场景：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

三、TCP业务逻辑实现

业务目标： 编写TCP版本的字典客户端和字典服务器：
业务实现逻辑： 和上面的 UDP业务逻辑实现一样，这里就不再赘述。
业务实现：

代码如下：

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class TcpDirServer extends TcpEchoServer{
    private Map<String,String> hash = null;
    public TcpDirServer(int port) throws IOException {
        super(port);
        hash = new HashMap<>();
        hash.put("hello","你好");
        hash.put("cat","小猫");
        hash.put("dog","小狗");
    }
    @Override
    public String process(String request) {
        return hash.getOrDefault(request,"该单词查询不到");
    }

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