文章目录
一、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();
}
}
效果如下：
结语：
其实写博客不仅仅是为了教大家，同时这也有利于我巩固知识点，和做一个学习的总结，由于作者水平有限，对文章有任何问题还请指出，非常感谢。如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。
396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
