网络编程

为什么需要网络编程？

现在网络普及程序越来越高，网络上保存着我们日常生活中需要的各种资源，使用程序通过网络来获取这些资源的过程就需要网络编程来实现。

什么是网络编程？

网络编程，指网络上的主机，通过不同的进程以程序的方式实现网络通信(网络数据传输）。

注意也可以是同一个主机的不同进程，比如，MySQL的服务端也客户端，在开发环境一般都是在同一台主机上运行的两个不同的程序。

怎么进行网络编程？

针对网络编程，操作系统提供了用于网络编程的技术，称为Socket套接字，是系统提供的专门用来实现网络编程的一套API。Java对每种操作系统做了进一步的封装。应用程序在应用层，操作系统工作在传输层，Socket套接字就是传输层对应用层提供的API支持。传输层中最知名的协议就是TCP和 UDP。

客户端和服务器

客户端：服务的使用方。请求一般是客户端主动发起，表示目的。

服务器：服务的提供方。响应一般是服务器根据客户端的请求计算出来的结果。

Socket套接字

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。

流套接字TCP

使用传输层TCP协议
TCP，即Transmission Control Protocol (传输控制协议) ，传输层协议。
TCP协议的特点:
1.有连接
2.可靠传输
3.面向字节流
4.全双工(有接收缓冲区，也有发送缓冲区)
5.大小不限
传输数据是基于IO流，没有边界多次发送，多次接收。

数据报套接字UDP

使用传输层UDP协议
UDP，即User Datagram Protocol (用户数据报协议)，传输层协议。
UDP协议的特点：
1无连接
2.不可靠传输
3.面向数据报
4.全双式(有接收缓冲区，也有发送缓冲区)
5.大小受限，一次最多传输64K
传输数据是一个整体一个整体，不能分开发送。

对比TCP与UDP

1.有无连接:TCP相当于打电话,接听方必须要接通电话双方才能通信。UDP相当于发短信，对方有没有开机都不重要。
2.可靠传输: 打电话时必须要经过拨号，接听后才可以通话，发短信发出去就不管了。如果数据包在传输的过程中丢了，TCP会有重传机制，UDP没有。
3.面向字节流和面向数据报: 打电话说一个字对方就可以听到一个字，发短信发一条条的信息对接收到才可以阅读。
4.全双工(有接收缓冲区，也有发送缓冲区): 可以打电话也可以接电话，可以发短信也可以收短信。
5.大小是否受限:电话打完了说好了我挂了啊，时间不受限，短信的大小有限制比如150个字。

UDP编程

DatagramSocket

DatagramSocket API：DatagramSocket 是UDP Socket，用于发送和接收UDP数据报。

构造方法:

方法	说明
DatagramSocket()	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口(一般用于客户端，客户端的端口一般是系统随机分配的）
DatagramSocket(int port)	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口(一般用于服务端）

普通方法：

方法	说明
void receive(DatagramPacket p)	从此套接字接收数据报(如果没有接收到数据报，该方法会阻塞待)
void send(DatagramPacket p)	从此套接字接收数据报(不会阻塞等待，直接发送)
void close()	关闭此数据报套接字

Socket的本质也是文件，之前介绍了狭义上的文件是硬盘上的文件，广义上的文件是计算机上的各种硬盘设备。
Socket对应到网卡这个硬件设备，操作系统把网卡也当做一个文件来管理。
通过网卡发数据就是写文件， 通过网卡接收数据就是读文件。

DatagramPacket

DatagramPacket是UDP Socket发送和接收的数据报，存放消息的具体内容。

构造方法:

方法	说明
DatagramPacket(bytel] buf, int length)	构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组(第一个参数buf)中，接收指定长度(第二个参数length)
DatagramPacket(bytel] buf，int offset, int length，SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组(第一个参数buf)中，从0到指定长度(第二个参数length)。address指定目的主机的IP和端口号。

普通方法：

方法	说明
lnetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址;或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号;或从发送的数据报中，获取接收端主机端口号
bytell getData()	获取数据报中的数据

构造UDP发送的数据报时，需要传入 SocketAddress，该对象可以使用InetSocketAddress来创建。

实现

实现一个简单的UDP回显服务器与客户端(发送什么就接收什么)。

服务端：

public class UDPEchoServer {// 定义一个用于服务器端的DatagramSocketprivate DatagramSocket server;/*** 构造方法，完成服务器的初始化* @param port 端口号*/public UDPEchoServer (int port) throws Exception {if (port > 65535 || port < 1024) {throw new Exception("端口号必须在1024 ~ 65535之间");}// 初始化服务器端的UDP服务this.server = new DatagramSocket(port);}/*** 对外提供服务*/public void start () throws IOException {System.out.println("服务器已启动....");// 循环接收用户的请求while (true) {// 1. 创建一个用于接收请求数据的DatagramPacketDatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);// 2. 接收请求, 把真实的内容填充到requestPacketserver.receive(requestPacket);// 3. 从requestPacket获取数据String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");// 4. 根据请求获取响应String response = processor (request);// 5. 把响应封装到DatagramPacketDatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),response.getBytes().length, requestPacket.getSocketAddress());// 6. 发送数据server.send(responsePacket);// 7. 打印日志System.out.printf("[%s:%d] request: %s, response: %s.\n", requestPacket.getAddress().toString(),requestPacket.getPort(), request, response);}}public String processor(String request) {return request;}public static void main(String[] args) throws Exception {// 初始化服务器UDPEchoServer server = new UDPEchoServer(9999);// 启动服务server.start();}
}

词典服务端：

public class UDPDicServer extends UDPEchoServer {private Map<String, String> map = new HashMap<>();/*** 构造方法，完成服务器的初始化** @param port 端口号*/public UDPDicServer(int port) throws Exception {super(port);map.put("dog", "小狗");map.put("cat", "小猫");map.put("pig", "小猪");map.put("tiger", "大老虎");map.put("veryGood", "牛P");}@Overridepublic String processor(String request) {return map.getOrDefault(request, "查无此词");}public static void main(String[] args) throws Exception {UDPDicServer server = new UDPDicServer(9999);server.start();}
}

客户端：

public class UDPEchoClient {// 定义一个用于客户端的DatagramSocketprivate DatagramSocket client;// 定义服务器的IP地址private String serverIp;// 定义服务器的端口号private int port;private SocketAddress address;/*** 构造方法,指定服务器的Ip地址和端口号** @param serverIp 服务器IP* @param port 端口号*/public UDPEchoClient (String serverIp, int port) throws SocketException {this.client = new DatagramSocket();this.serverIp = serverIp;this.port = port;this.address = new InetSocketAddress(serverIp, port);}public void start () throws IOException {System.out.println("客户端已启动.");// 循环接收用户的输入Scanner scanner = new Scanner(System.in);while (true) {System.out.println("->");// 接收用户输入String request = scanner.next();// 1. 把请求内容包装成DatagramPacketDatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8),request.getBytes().length, address);// 2. 发送数据client.send(requestPacket);// 3. 接收响应DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);// 4. 在receive方法中填充响应数据client.receive(responsePacket);// 5. 解析响应数据String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");// 6. 打印日志System.out.printf("request: %s, response: %s.\n", request, response);}}public static void main(String[] args) throws IOException {UDPEchoClient client = new UDPEchoClient("127.0.0.1", 9999);// 启动服务client.start();}
}

服务端与客户端的执行关系：

服务端	服务端
构造Socket对象，启动Socket服务
socket.receive()进入接收状态，阻塞等待请求到来	启动客户端
	指定服务器IP和端口，构造packet，socket.sent()发送请求
receive得到数据，线程唤醒，开始处理	等待服务端响应socket.receive()，进入阻塞，等待服务器响应。
响应处理结果socket.sent()	receive接收响应，线程唤醒
进入下一次循环，继续在receive阻塞等待请求	展示结果

阻塞等待：

TCP编程

ServerSocket

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

构造方法

方法	说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口。操作系统中端口号会和进程绑定。

普通方法

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

Socket

socket 是客户端Socket，或服务端中接收到客户端建立连接 (accept方法)的请求后，返回的服务端Socket。不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。

构造方法

方法	方法
Socket(String host, intport)	创建一个客户端流套接字Socket，并与对应IP的主机和对应端口的进程建立连接

普通方法

方法	说明
lnetAddress getlnetAddress()	返回套接字所连接的地址
InputStream getlnputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

InputStream输入流，从网卡缓冲区读取数据；OutputStream输出流，把数据写到网卡缓冲区，相当于发数据。

实现

实现一个简单的TCP聊天服务器与客户端。

服务端：

public class TCPEchoServer {// 声明一个用于服务端的Socket对象private ServerSocket server;/*** 通过指定端口号实例化服务** @param port 端口号* @throws IOException*/public TCPEchoServer(int port) throws IOException {if (port < 1025 || port > 65535) {throw new RuntimeException("端口号要在 1025 ~ 65535之间.");}// 实例化ServerSocket并指定端口号this.server = new ServerSocket(port);}public void start() throws IOException {System.out.println("服务器启动成功...");// 循环接收客户端的连接while (true) {Socket clientSocket = server.accept();// 处理Socket中的数据processConnections(clientSocket);}}// 处理数据private void processConnections(Socket clientSocket) throws IOException {// 打印日志String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),clientSocket.getPort());System.out.println(clientInfo);// 处理数据之前要获取一下输入输出流try (InputStream inputStream = clientSocket.getInputStream();OutputStream outputStream = clientSocket.getOutputStream()) {// 循环处理用户的请求while (true) {// 通过Scanner读取用户请求中的数据Scanner requestScanner = new Scanner(inputStream);if (!requestScanner.hasNextLine()) {// 日志clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),clientSocket.getPort());System.out.println(clientInfo);break;}// 获取真实的用户请求数据String request = requestScanner.nextLine();// 根据请求计算响应String response = process(request);// 把响应写回客户端PrintWriter printWriter = new PrintWriter(outputStream);// 写入输出流printWriter.println(response);// 强制刷新缓冲区printWriter.flush();// 打印日志clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",clientSocket.getInetAddress(), clientSocket.getPort(), request, response);System.out.println(clientInfo);}} catch (IOException e) {e.printStackTrace();} finally {clientSocket.close();}}private String process(String request) {System.out.println("收到新消息："  + request);Scanner scanner = new Scanner(System.in);String response = scanner.nextLine();return response;}public static void main(String[] args) throws IOException {TCPEchoServer server = new TCPEchoServer(9999);server.start();}
}

客户端：

public class TCPEchoClient {// 定义一个用于客户端的Socket对象private Socket clientSocket;/*** 初始化客户端的Socket** @param serverIp 服务器IP地址* @param serverPort 服务器的端口号* @throws IOException*/public TCPEchoClient (String serverIp, int serverPort) throws IOException {this.clientSocket = new Socket(serverIp, serverPort);}public void start () throws IOException {System.out.println("客户端已启动...");// 获取Socket中的输入输出流try (InputStream inputStream = clientSocket.getInputStream();OutputStream outputStream = clientSocket.getOutputStream()) {// 循环处理用户的输入while (true) {System.out.println("->");// 接收用户的输入内容Scanner requestScanner = new Scanner(System.in);String request = requestScanner.nextLine();// 发送用户的请求PrintWriter printWriter = new PrintWriter(outputStream);printWriter.println(request);// 强制刷新缓冲区printWriter.flush();// 接收服务器的响应Scanner responseScanner = new Scanner(inputStream);// 获取响应数据String response = responseScanner.nextLine();// 打印响应内容System.out.println("接收到服务器的响应：" + response);}} catch (IOException e) {e.printStackTrace();} finally {clientSocket.close();}}public static void main(String[] args) throws IOException {TCPEchoClient client = new TCPEchoClient("127.0.0.1", 9999);client.start();}
}

当打开多个客户端时，发现服务器并不能同时处理多个请求。为了解决这个问题，可以先让客户端1断开连接。为了实现服务器可以处理多个客户端连接，那么可以为每一个客户端连接创建一个新的线程，让请求的处理在单独的子线程中去执行。但是如果说每接收到客户端连接就创建新的线程，当有1万个连接就要创建1万个线程，会消耗非常大的系统资源。所以为了优化这个问题，可以使用线程池的方式。

客户端start()方法优化:

    public void start() throws IOException {System.out.println("服务器启动成功...");// 创建一个线程池ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,new LinkedBlockingQueue<>(10));// 循环接收客户端的连接while (true) {Socket clientSocket = server.accept();// 每接收到一个新连接请求，就创建一个新的子线程
//            Thread thread = new Thread(() -> {
//                // 处理Socket中的数据
//                try {
//                    processConnections(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            // 启动线程
//            thread.start();// 提交任务到线程池中poolExecutor.submit(() -> {try {processConnections(clientSocket);} catch (IOException e) {e.printStackTrace();}});}}

---

继续加油~