【JavaEE精炼宝库】 网络编程套接字——UDP业务逻辑 | 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 普通方法：

2.1.2 socket：

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

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

• socket 构造方法：

• socket 普通方法：

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优化：

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

• 多线程优化：

由于修改的只是 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();
        }

    }

• 线程池优化：

采用线程池的优势有：

代码如下：

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发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：

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

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

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

三、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();
    }
}

结语：
其实写博客不仅仅是为了教大家，同时这也有利于我巩固知识点，和做一个学习的总结，由于作者水平有限，对文章有任何问题还请指出，非常感谢。如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。