网络编程
程序员主要操作应用层和传输层来实现网络编程
也就是自己写一个程序，让这个程序可以使用网络来通信
这个程序属于应用层，实现通讯就需要获取到传输层提供的服务
这就需要使用传输层提供的api
UDP：无连接，不可靠传输，面向数据报，全双工
TCP:有连接，可靠传输，面向字节流，全双工
连接（Connection）
这里的连接是个抽象的概念
比如两个人领证了才算结婚，这时候就相当于把两个人连接起来了，但是这个连接不是拿绳子拴着，是通过过结婚证那个小本本来把两个人连接起来的（一对一）
客户端和服务器之间，使用这个小本本（内存）保存对应的端口号的信息，双方都保存了这个信息，此时“连接”就出现了
这里最大的区别在于，一个客户可以连接多个服务器，一个服务器也可以多对应多个客户（多对多）（比如一个人可以去多个餐馆买今天的晚饭，一个餐馆也可以接待多个客人）
可靠传输
可靠传输不是说的是 A给B发的消息百分百能到，而是
A尽可能的把消息传给B，并且在传输失败的时候，A能感知到，或者在传输成功的时候，也能知道自己传输成功了
有舍才有得，既然TCP是可靠传输，那么它的传输效率就降低了
有人会问了，既然TCP是可靠传输，UDP是不可靠的，那么TCP是不是比UDP安全呢？
当然不是！！！可靠不等于安全！！！
“网络安全”指的是你传输的数据是否容易被黑客截获，以及如果截获后是否会泄露一些重要信息
面向字节流和面向数据报
TCP是面向字节流，它的字节流和文件操作类似，都是“流”式的（由于这里传输的单位是字节，所以称为字节流）
跟水流一样，假如通过tcp读写100字节的数据，可以一次读写100字节，也可以一次读写50字节，分两次，还可以一次读写10字节，分10次
UDP是面向数据报，UDP读写的基本单位，是一个UDP数据报，这个数据报包含了一系列的数据和属性
全双工和半双工
全双工，一个通道，可以双向通信
半双工，一个通道，只能单向通信
网线就是全双工呢，一根网线包含八根铜缆，44一组，一组里面有的负责这个方向，有的负责那个方向
网络编程基础
为什么需要网络编程？
用户在浏览器中，打开在线视频网站，如优酷看视频，实质是通过网络，获取到网络上的一个视频资源。
与本地打开视频文件类似，只是视频文件这个资源的来源是网络。相比本地资源来说，网络提供了更为丰富的网络资源
所谓的网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。
什么是网络编程？
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，
也属于网络编程。特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
进程A：编程来获取网络资源
进程B：编程来提供网络资源
网络编程中的基本概念
发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
请求和响应
一般来说，获取一个网络资源，涉及到两次网络数据传输：
第一次：请求数据的发送
第二次：响应数据的发送。
好比在快餐店点一份炒饭：
先要发起请求：点一份炒饭，有快餐店提供的对应响应：提供一份炒饭
服务端和客户端
服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。
好比在银行办事：
银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）
常见的客户端服务端模型
最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
- 客户端先发送请求到服务端
- 服务端根据请求数据，执行相应的业务处理
- 服务端返回响应：发送业务处理结果
- 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）
Socket套接字
概念
Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程
分类
Socket套接字主要针对传输层协议划分为如下三类
流套接字：使用传输层TCP协议TCP，即Transmission Control Protocol（传输控制协议），传输层协议
数据报套接字：使用传输层UDP协议UDP，即User Datagram Protocol（用户数据报协议），传输层协议
原始套接字：原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。
UDP数据报套接字编程
DatagramSocket API
这个类是一个Socket对象
操作系统使用文件这样的概念来管理一些软硬件资源，同样的操作系统也是用文件的方式来管理网卡的，表示网卡这类的文件称为Socket文件。（假如你把键盘插入到电脑上，操作系统也认为是一个键盘文件）
java中Socket对象来表示系统的Socket文件，系统的Socket文件来表示网卡，最终还是要落到网卡身上，毕竟进行网络通信，绕不开网卡这样的设备
因此要想进行网络通信，必须要有Socket对象，Socket对象关联Socket文件，Socket文件关联网卡，最终通过网卡来使我们实现网络通讯，来实现发送数据和接收数据
客户端使用系统分配的端口号原因可能是客户端像发送程序2的请求，但是如果你想手动指定一个18号端口，可能这个端口会被程序1占着呢
对于服务器来说，手动设定一个固定窗口，方便其他客户找到
举个例子
我在学校食堂的18号档口开了一家小吃店
18号端口，这个18号端口就相当于服务器的端口号
这时候同学们看到我的传单，来我这里吃饭了， 我给同学们做好了一份饭，他们都会去找一个位置，这个位置就相当于客户端的端口号，而第二次来的时候，这个位置可能就不会再坐了，可能就被别人站着了，这个时候只能再随机坐一个位置，同学们需要根据实际情况，找一个空闲的位置，因此客户端的端口号就不能是固定值
一个客户端的主机，上面运行的程序很多，谁知道你手动指定的端口是不是被别的程序占用了，让系统自动分配一个端口是更明智的选择
而服务器是完全在程序员手里控制的，程序员可以把服务器上的多个程序安排好，让他们使用不同的端口
receive相当于读，send相当于写
DatagramPacket API
这个类表示了一个UDP数据报，代表了系统中设定的UDP数据报的二进制结构
构造UDP发送的数据报时，需要传入SocketAddress ，该对象可以使用 InetSocketAddress 来创建。
回显服务器（echo server）
回显服务器是一个最简单的服务器，也就是客户端发啥，服务器返回啥
服务器代码
// UDP 的 回显服务器.
// 客户端发的请求是啥, 服务器返回的响应就是啥.
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
// UDP 的 回显服务器.
// 客户端发的请求是啥, 服务器返回的响应就是啥.
public class UdpEchoServer
{
private DatagramSocket socket = null;
// 参数是服务器要绑定的端口
public UdpEchoServer(int port) throws SocketException
{
socket = new DatagramSocket(port);
}
// 使用这个方法启动服务器.
public void start() throws IOException
{
System.out.println("服务器启动!");
//一个服务器要给很多客户提供服务
//服务器也不知道客户端啥时候来
//因此服务器只能“时刻准备着”，客户端随时来，服务器就随时提供服务
while (true)
{
// 反复的, 长期的执行针对客户端请求处理的逻辑.
// 一个服务器, 运行过程中, 要做的事情, 主要是三个核心环节.
// 1. 读取请求, 并解析
//构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组中
DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(requestPacket);
//这样的转字符串的前提是, 后续客户端发的数据就是一个文本的字符串.
String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
// 2. 根据请求, 计算出响应
//回显服务器不关心第二步，因为请求是啥，就返回啥响应
//但是商业级别的服务器，主要都是在完成第二步（处理一个请求可能会经历几万行的代码）
String response = process(request);
// 3. 把响应写回给客户端
// 此时需要告知网卡, 要发的内容是啥, 要发给谁.
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
requestPacket.getSocketAddress());
//response.getBytes().length单位是字节，而response.length单位是字符，因此不能用response.length
socket.send(responsePacket);
// 记录日志, 方便观察程序执行效果.
System.out.printf("[%s:%d] req: %s, resp: %s\n", requestPacket.getAddress().toString(), requestPacket.getPort(),
request, response);
}
}
// 根据请求计算响应. 由于是回显程序, 响应内容和请求完全一样.
public String process(String request)
{
return request;
}
public static void main(String[] args) throws IOException
{
UdpEchoServer server = new UdpEchoServer(1800);
server.start();
}
}
客户端代码
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class UdpEchoClient
{
private DatagramSocket socket = null;
private String serverIp;
private int serverPort;
// 服务器的 ip 和 服务器的端口.
public UdpEchoClient(String ip, int port) throws SocketException
{
serverIp = ip;
serverPort = port;
// 这个 new 操作, 就不再指定端口了. 让系统自动分配一个空闲端口.
socket = new DatagramSocket();
}
// 让这个客户端反复的从控制台读取用户输入的内容. 把这个内容构造成 UDP 请求, 发给服务器. 再读取服务器返回的 UDP 响应
// 最终再显示在客户端的屏幕上.
public void start() throws IOException
{
Scanner scanner = new Scanner(System.in);
System.out.println("客户端启动!");
while (true) {
// 1. 从控制台读取用户输入的内容
System.out.print("-> "); // 命令提示符, 提示用户要输入字符串.
String request = scanner.next();
// 2. 构造请求对象, 并发给服务器.
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
InetAddress.getByName(serverIp), serverPort);
socket.send(requestPacket);
// 3. 读取服务器的响应, 并解析出响应内容.
DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
// 4. 显示到屏幕上.
System.out.println(response);
}
}
public static void main(String[] args) throws IOException
{
//发送到127.0.0.1的数据或者从127.0.0.1返回的数据只会在本机进行传输, 而不进行外部网络传输
UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
client.start();
}
}
翻译服务器
import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;
public class UdpDictServer extends UdpEchoServer
{
private Map<String, String> dict = new HashMap<>();
public UdpDictServer(int port) throws SocketException
{
super(port);
dict.put("cat", "小猫");
dict.put("dog", "小狗");
dict.put("fuck", "卧槽");
// 可以在这里继续添加千千万万个单词. 使每个单词都有一个对应的翻译.
}
// 是要复用之前的代码, 但是又要做出调整.
@Override
public String process(String request)
{
// 把请求对应单词的翻译, 给返回回去.
return dict.getOrDefault(request, "该词没有查询到!");
}
public static void main(String[] args) throws IOException
{
UdpDictServer server = new UdpDictServer(9090);
// start 不需要重新再写一遍了. 直接就复用了之前的 start !
server.start();
}
}
TCP流套接字编程
tcp是面向字节流的，是一个字节一个字节进行传输的，一个tcp数据报，就是一个字节数组（byte[]），因此并不像udp一样，需要一个特定的类来代表tcp字节流
ServerSocket API
给服务器用的
ServerSocket 是创建TCP服务端Socket的API。
构造方法
方法
Socket API
服务器和客户端都可以用
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
回调服务器
服务器代码
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;
// 此处不应该创建固定线程数目的线程池.
private ExecutorService service = Executors.newCachedThreadPool();
// 这个操作就会绑定端口号
public TcpEchoServer(int port) throws IOException
{
serverSocket = new ServerSocket(port);
}
// 启动服务器
public void start() throws IOException
{
System.out.println("服务器启动!");
while (true)
{
//执行到accept就已经在操作系统内核中建立好连接了
// 这个写法, 是能自动关闭, 也行. 实现 Closeable 接口就可以这么写.
// 这么写会有其他问题. (结合后面讲第二个问题, 再说这个事)
Socket clientSocket = serverSocket.accept();
// 单个线程, 不太方便完成这里的一边拉客, 一边介绍. 就需要多搞线程. 主线程专门负责拉客. 每次有一个客户端, 都创建一个新的线程去服务
// Thread t = new Thread(() -> {
// processConnection(clientSocket);
// });
// t.start();
// 使用线程池, 来解决上述问题
service.submit(new Runnable()
{
@Override
public void run() {
processConnection(clientSocket);
}
});
}
}
// 通过这个方法来处理一个连接的逻辑.
private void processConnection(Socket clientSocket)
{
System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
// 接下来就可以读取请求, 根据请求计算响应, 返回响应三步走了.
// Socket 对象内部包含了两个字节流对象, 可以把这俩字节流对象获取到, 完成后续的读写工作
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream())
{
// 一次连接中, 可能会涉及到多次请求/响应
while (true)
{
// 1. 读取请求并解析. 为了读取方便, 直接使用 Scanner.
Scanner scanner = new Scanner(inputStream);
if (!scanner.hasNext())
{
// 读取完毕, 客户端下线.
System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
break;
}
// 这个代码暗含一个约定, 客户端发过来的请求, 得是文本数据, 同时, 还得带有空白符作为分割. (比如换行这种)
String request = scanner.next();
// 2. 根据请求计算响应
String response = process(request);
// 3. 把响应写回给客户端. 把 OutputStream 使用 PrinterWriter 包裹一下, 方便进行发数据.
PrintWriter writer = new PrintWriter(outputStream);
// 使用 PrintWriter 的 println 方法, 把响应返回给客户端.
// 此处用 println, 而不是 print 就是为了在结尾加上 \n . 方便客户端读取响应, 使用 scanner.next 读取.
writer.println(response);
// 这里还需要加一个 "刷新缓冲区" 操作.
writer.flush();
// 日志, 打印当前的请求详情.
System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(), clientSocket.getPort(),
request, response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 在 finally 中加上 close 操作, 确保当前 socket 被及时关闭!!
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(9090);
server.start();
}
}
客户端代码
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 {
// 这个 new 操作完成之后, 就完成了 tcp 连接的建立.
socket = new Socket(serverIp, serverPort);
}
public void start() {
System.out.println("客户端启动");
Scanner scannerConsole = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
while (true) {
// 1. 从控制台输入字符串.
System.out.print("-> ");
String request = scannerConsole.next();
// 2. 把请求发送给服务器
PrintWriter printWriter = new PrintWriter(outputStream);
// 使用 println 带上换行. 后续服务器读取请求, 就可以使用 scanner.next 来获取了
printWriter.println(request);
// 不要忘记 flush, 确保数据是真的发送出去了!!
printWriter.flush();
// 3. 从服务器读取响应.
Scanner scannerNetwork = new Scanner(inputStream);
String response = scannerNetwork.next();
// 4. 把响应打印出来
System.out.println(response);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
client.start();
}
}
