网络编程概述
作者：~小明学编程
文章专栏：JavaEE
格言：热爱编程的，终将被编程所厚爱。
目录
网络编程嵌套字
UDP
DatagramSocket API
DatagramPacket API
InetSocketAddress API
基于UDP实现服务端
代码：
分析：
基于UDP实现客户端
代码
分析
TCP
ServerSocket API
Socket API
基于TCP实现服务端
代码：
分析
基于TCP实现客户端
代码
分析
Bug与改进
实现简单的翻译功能
网络编程嵌套字
所谓的网络编程嵌套字就是操作系统给应用程序提供的一组API接口（socket API），主要的作用就是连接我们的应用层和传输层的一组桥梁。
传输层的核心协议有两种，TCP UDP，socket API 也有对应的两组。由于 TCP 和 UDP 协议，差别很大，所以这两组 API 差别也挺大。
TCP的特点(使用传输层的TCP协议)：
1.有连接。
2.可靠传输。
3.面向字节流。
4.双全工。
UDP的特点(使用传输层的UDP协议)：
1.无连接。
2.不可靠传输。
3.面向数据流。
4.双全工。
有无连接：有无连接就是我们在发送数据的时候对方可以选择是否接受，如果不经过对方的同意就能就能传输数据就是无连接，如果得需要对方的确认才能传输数据的话就是有连接。
是否可靠传输：是否可靠传输就是我们在传输数据的时候传送的一方是否知道我们的数据接受放有没有收到，如果能知道是否收到那就是可靠传输，如果不知道那就是不可靠传输。
面向数据/字节流：面向字节流就是以字节为单位进行传输（非常类似于 文件操作 中的字节流，面向数据流就是传输的时候以数据报为单位进行传输，传输的数据必须是单个数据包的整数倍。
单/双全工：单全工的意思就是我们的传输时单向的只能一方传输给另外的一方，而双全共的意思是双方可以互相的传输数据。
下面我们就基于UDP和TCP分别来实现用户端和客户端。
UDP
在我们实现客户端或者服务端之前我们要先了解几个API。
DatagramSocket API
DatagramSocket 是UDP Socket，用于发送和接收UDP数据报，其中DatagramSocket也就是对应我们操作系统的一个socket文件我们new了一个对象然后操作对象也就相当于操作该文件了。
DatagramSocket 构造方法：
| 方法签名 | 方法说明 |
| DatagramSocket() | 创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口 （一般用于客户端） |
| DatagramSocket(int port) |
创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用 于服务端） |
DatagramSocket 方法：
| 方法签名 | 方法说明 |
| void receive(DatagramPacket p) |
从此套接字接收数据报（如果没有接收到数据报，该方法会阻 塞等待） |
| void send(DatagramPacket p) |
从此套接字发送数据报包（不会阻塞等待，直接发送） |
| void close() | 关闭此数据报套接字 |
DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报。
DatagramPacket 构造方法：
| 方法签名 | 方法说明 |
| DatagramPacket(byte[] buf, int length) |
构造一个DatagramPacket以用来接收数据报，接收的数据保存在 字节数组（第一个参数buf）中，接收指定长度（第二个参数 length） |
| DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) |
构造一个DatagramPacket以用来发送数据报，发送的数据为字节 数组（第一个参数buf）中，从0到指定长度（第二个参数 length）。address指定目的主机的IP和端口号 |
DatagramPacket 方法：
| 方法签名 | 方法说明 |
| InetAddress getAddress() |
从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取 接收端主机IP地址 |
| int getPort() | 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获 取接收端主机端口号 |
| byte[] getData() | 获取数据报中的数据 |
构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创
建。
InetSocketAddress API
InetSocketAddress （ SocketAddress 的子类 ）构造方法：
| 方法签名 | 方法说明 |
| InetSocketAddress(InetAddress addr, int port) | 创建一个Socket地址，包含IP地址和端口号 |
基于UDP实现服务端
代码：
//1.源ip：服务器程序本机的ip
//2.源端口：服务器绑定的端口
//3.目的ip:包含在收到的数据报中(客户端的ip)
//4.目的端口：包含在收到的数据报中(客户端的端口)
//5.协议类型：UDP
public class UdpEchoServer {
//进行网络编程首先就是要准备好我们的 socket 的实例，这是进行网络编程的前提。
private DatagramSocket datagramSocket = null;
public UdpEchoServer(int port) throws SocketException {
datagramSocket = new DatagramSocket(port);
}
//启动服务器
public void start() throws IOException {
System.out.println("服务器已经启动!");
while (true) {
//1.读取客户端发来的请求
DatagramPacket requestPacket = new DatagramPacket(new byte[1024],1024);
datagramSocket.receive(requestPacket);//为了接受数据，将先前准备好的requestPacket放入，然后向里面写入数据
//把DatagramPacket解析成一个String
String request = new String(requestPacket.getData(),0,requestPacket.getLength(),"UTF-8");
//2.根据请求计算响应
String response = process(request);
//3.把响应写到客户端
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
response.getBytes().length,requestPacket.getSocketAddress());
datagramSocket.send(responsePacket);
System.out.println("[客户IP:"+responsePacket.getAddress()+" 客户端口:"+responsePacket.getPort()
+" 请求:"+request+"响应:"+response+"]");
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
udpEchoServer.start();
}
}分析：
UdpEchoServer构造方法：
private DatagramSocket datagramSocket = null;
public UdpEchoServer(int port) throws SocketException {
datagramSocket = new DatagramSocket(port);
}首先我们要new一个DatagramSocket的对象，这是我们进行网络编程的大前提。
这里值得我们关注的有两点，第一点是构造方法里面的参数，第二点是异常问题。
1.作为我们的服务器肯定是需要绑定一个端口号的这样才能知道我们的数据要传输到哪个位置，其中我们这里的port就是我们想要指定的端口号。
2.在我们绑定端口号的时候可能会抛出异常，抛出异常的原因可能有两种
1）端口号已经被占用了，我们知道一个端口号只能被一个进程所绑定。
2）一个进程所能打开的文件是有限制的，如果当前进程已经打开过很多个文件的话可能导致不能正常打开socket文件了。
start()方法：
1.首先我们需要读取客户端发来的请求，我们需要一个数据报也就是 DatagramPacket 来存放请求的内容，然后用receive接受就可以了。
2.接着我们需要把数据报里面的内容解析成一个String类型的字符串，这里主要就是用到String的构造方法，还有就是从已经接受完数据的DatagramPacket对象里面提取信息。
3.根据请求计算响应，这里我们的响应就是简单的回文。
public String process(String request) {
return request;
}4.将处理好的字符串打包发送回客户端，这里要指定我们发送的IP地址和端口号，所以要从先前的数据报里面拿到IP地址和端口号。
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
response.getBytes().length,requestPacket.getSocketAddress());基于UDP实现客户端
代码
//1.源ip：本机IP
//2.源端口：系统分配的端口
//3.目的ip:服务器的ip
//4.目的端口：服务器的端口
//5.协议类型：UDP
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIP;
private int serverPort;
public UdpEchoClient(String IP,int port) throws SocketException {
serverIP = IP;
serverPort = port;
socket = new DatagramSocket();
}
public void start() throws IOException {
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.print("->");
//1.读取相应的字符串
String request = scanner.next();
//2.把相应的字符串构造成一个UDP的请求
//其中请求中包括字符串和服务器的IP以及端口号
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
InetAddress.getByName(serverIP),serverPort);
socket.send(requestPacket);
//3.从服务器读取数据并解析
DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(),0,responsePacket.getLength(),"UTF-8");
//4.将数据打印
System.out.println(response);
}
}
public static void main(String[] args) throws IOException {
UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1",9090);
udpEchoClient.start();
}
}分析
构造方法：
private DatagramSocket socket = null;
private String serverIP;
private int serverPort;
public UdpEchoClient(String IP,int port) throws SocketException {
serverIP = IP;
serverPort = port;
socket = new DatagramSocket();
}1.构造方法里面的IP和port是后面发送给服务端要用的，而DatagramSocket可以指定端口号也可以默认系统随机分配一个端口号，这里推荐随机分配，因为我们不知道哪些端口号会被占用。
2.这里同上面的服务端一样也有可能会抛出异常。
start()方法：
1.首先我们通过键盘输入一个字符串。
2.将字符串构造成一个UDP的请求并且给打包起来，其中要加入我们服务端的IP和端口号。
3.准备一个数据报然后从服务端那里接受返回的数据。
4.提取该数据报里面的内容并且打印出来。
TCP
ServerSocket API
ServerSocket 是创建TCP服务端Socket的API。
ServerSocket 构造方法：
| 方法签名 | 方法说明 |
| ServerSocket(int port) | 创建一个服务端流套接字Socket，并绑定到指定端口 |
ServerSocket 方法：
| 方法签 名 |
方法说明 |
| Socket accept() |
开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket 对象，并基于该Socket建立与客户端的连接，否则阻塞等待 |
| void close() |
关闭此套接字 |
Socket API
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket 构造方法：
| 方法签名 | 方法说明 |
| Socket(String host, int port) |
创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的 进程建立连接 |
Socket 方法：
| 方法签名 | 方法说明 |
| InetAddress getInetAddress() | 返回套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |
基于TCP实现服务端
代码：
public class TcpEchoServer {
private ServerSocket serverSocket;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器已启动");
while (true) {
//因为TCP是有连接的所以我们首先要建立连接
//然后返回一个Socket的对象我们接下来操作这个对象就行了
Socket clientSocket = serverSocket.accept();
processConnection(clientSocket);
}
}
private void processConnection(Socket clientSocket) {
System.out.println("["+clientSocket.getInetAddress().toString()+" "+clientSocket.getPort()+"用户已建立连接]");
//接下来处理相应和请求
try(InputStream inputStream = clientSocket.getInputStream()) {
try(OutputStream outputStream = clientSocket.getOutputStream()) {
//循环处理每个请求
Scanner scanner = new Scanner(inputStream);
while(true) {
//1. 读取请求
if (!scanner.hasNext()) {
System.out.println("["+clientSocket.getInetAddress().toString()+" "+clientSocket.getPort()+
"用户已断开连接]");
break;
}
String request = scanner.next();
//2.根据请求计算响应
String response = process(request);
//3.把响应返回给客户端
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
//刷新缓存区，让客户端第一时间得到响应结果
printWriter.flush();
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(8087);
server.start();
}
}
分析
1.首先就是我们的构造方法这里我们要给ServerSocket的对象绑定一个端口号。
2.我们接收到一个Socket类型的对象接下来我们操作这个对象就可以了。
3.来到processConnection方法里面，我们创建一个输入流一个输出流分别对客户端的数据进行读取或者写入。
4.获取到目标字符串，然后进行处理。
5.把响应再写回到客户端。
基于TCP实现客户端
代码
public class TcpEchoClient {
private Socket socket;
public TcpEchoClient(String socketIP,int socketPort) throws IOException {
//这里的参数代表的是尝试与指定的服务IP建立连接
socket = new Socket(socketIP,socketPort);
}
public void start() {
System.out.println("客户端已连接服务器");
Scanner scanner = new Scanner(System.in);
try(InputStream inputStream = socket.getInputStream()) {
try(OutputStream outputStream = socket.getOutputStream()) {
while (true) {
//1.从控制台上读取字符串
String request = scanner.next();
//2.根据读取的字符串构造请求发送至服务端
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
printWriter.flush();
//3.从服务端读取响应并且解析
Scanner scanner1 = new Scanner(inputStream);
String response = scanner1.next();
System.out.println("res:"+response);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient socket = new TcpEchoClient("127.0.0.1",8087);
socket.start();
}
}分析
1.首先是我们构造方法里面的Socket,这里指代的是我们想要和指定的服务器建立连接而不是要绑定端口号。
2.在start()方法里面我们也要开启输入和输出流来与客户端进行交流。
3.从客户端上读取到指定的字符串。
4.将字符串发送给服务端。
5.从服务端接受响应并且对其解析打印。
Bug与改进
上面我们实现的服务端会有一个问题那就是只能允许一个客户端去访问这是怎么回事呢？
在我们的客户端的代码中我们处理请求的时候会进入这个方法里面但是这个方法里面是一个循环，这个循环只有在当前的客户端断开我们这个方法才能执行完毕，所以我们就没机会再去接受其它的请求了，要想解决这个问题我们创建一个线程单独处理请求就可以了。
public void start() throws IOException {
System.out.println("服务器已启动");
while (true) {
//因为TCP是有连接的所以我们首先要建立连接
//然后返回一个Socket的对象我们接下来操作这个对象就行了
Socket clientSocket = serverSocket.accept();
Thread thread = new Thread(()->{
processConnection(clientSocket);
});
thread.start();
}
}实现简单的翻译功能
public class TcpDictServer extends TcpEchoServer{
HashMap dict = new HashMap<>();
public TcpDictServer(int port) throws IOException {
super(port);
dict.put("dog","小狗");
dict.put("apple","苹果");
dict.put("ikun","爱坤");
dict.put("jntm","只因你太美");
}
@Override
public String process(String request) {
return dict.getOrDefault(request,"该词暂未收录");
}
public static void main(String[] args) throws IOException {
TcpDictServer server = new TcpDictServer(8087);
server.start();
}
} 我们继承前面的主要的代码然后重写一个process的方法，其中引入hashMap来记录我们收录的单词。
