一.什么是网络编程
网络编程,指网络上的主机,通过不同的进程,以编程的方式实现网络通信(或称为网络数据传输)。
二.为什么要实现网络编程
我们通过网络编程可以在网络中获取资源,实质是通过网络,获取到我们所需要的资源。
三.如何进行网络编程
针对网络编程,操作系统提供了一套专门实现网络编程的API,称为Socket套接字
我们的程序在应用层,操作系统工作在传输层,socket套接字就是传输层提供给应用层的API,传输层中最知名的协议就是TCP和UDP。
四.Socket关键字
Socket关键字针对传输协议分为三类:
①TCP传输协议②UDP传输协议③原始套接字
Tcp传输协议和UDP传输协议的区别:
![](https://i-blog.csdnimg.cn/blog_migrate/1d6a1c5cd25eb58e0ba25d7e028e96e5.png)
有连接:相当于打电话,得先接通,才能交互数据
无连接:相当于发微信,不需要接通,直接就能发数据
可靠传输:传输过程中,发送方道知接收方有没有收到数据
不可靠传输:传输过程中,发送方不知道接收方有没有收到数据
面向字节流:以字节为单位进行传输
面向数据报:以数据报为单位进行传输(一个数据报都会明确大小)一次发送/接收必须是一个完整的数据报
全双工:一条链路,双向通信
半双工:一条链路,单向通信
大小限制:打电话可长可短,但是发短信有字数限制。
4.1UDP中的API
主要涉及两个类DatagramSocket(针对服务器上启动的网络服务,对应到服务器上用来接收用户请求的进程)和DatagramPacket(针对通信报文)
在网络编程中收发数据的过程主要是通过网卡来实现的,接收数据是对网卡的读取,发送数据时对网卡的写入。
构造方法:
![](https://i-blog.csdnimg.cn/blog_migrate/99b2fad82dcfc9b662d252fda3b5bbce.png)
![](https://i-blog.csdnimg.cn/blog_migrate/7b35a42a2bfd9ca700ba6e0992f63dde.png)
收发和关闭方法:
![](https://i-blog.csdnimg.cn/blog_migrate/0ed1ed0dd5ed10c6812454cc69e1414a.png)
![](https://i-blog.csdnimg.cn/blog_migrate/13abf6c7471fad91df32692ba8372736.png)
![](https://i-blog.csdnimg.cn/blog_migrate/768e2fc3dad30cee211c2462d69163a0.png)
notes:receive()方法会在没有客服端访问时进入阻塞状态,send()方法则是直接发送
测试要求:
根据请求返回响应:响应数据与请求数据一致
服务端代码:
import java.io.IOException;
import java.net.BindException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
/**
* @author tongchen
* @create 2023-02-17 23:30
*/
public class UDPEchoServer {
//创建socket变量
private DatagramSocket socket;
//通过构造方法指定端口号
public UDPEchoServer(int port) throws SocketException {
//检查端口号的合法性
if(port<0||port>65535){
throw new BindException("端口建议在合法范围内");
}
//创建socket
this.socket=new DatagramSocket(port);
}
//启动服务
public void start() throws IOException {
//标识运行
System.out.println("服务端开始启用.......");
while(true){
//使用datagrampacket进行数据的接收
DatagramPacket datagramPacket = new DatagramPacket(new byte[1024], 1024);
//使用socket接收数据
socket.receive(datagramPacket);
//解析接收到的数据
String request=new String(datagramPacket.getData(), 0, datagramPacket.getData().length, "utf-8");
//根据数据获取响应数据
String response=pocess(request);
//对响应数据进行封装
DatagramPacket responsePacket=new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),
response.getBytes().length,datagramPacket.getSocketAddress());
//发送响应数据
socket.send(responsePacket);
System.out.printf("[%s:%d] request = %s, response = %s\n", datagramPacket.getAddress().toString(),
datagramPacket.getPort(), request, response);
}
}
private String pocess(String request) {
return request;
}
public static void main(String[] args) throws IOException {
//创建端口号
UDPEchoServer udpEchoServer = new UDPEchoServer(9090);
udpEchoServer.start();
}
}
客户端代码:
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* @author tongchen
* @create 2023-02-18 11:00
*/
public class UDPchoClient {
//定义服务器的地址和端口号
private String address;
private int port;
private DatagramSocket socket;
//初始化端口号和目标地址
public UDPchoClient(String address, int port) throws SocketException {
this.address = address;
this.port = port;
this.socket=new DatagramSocket();
}
//启动程序
public void start() throws IOException {
System.out.println("客户端启动......");
//输入请求数据
while(true){
System.out.println("请输入请求数据");
Scanner scanner=new Scanner(System.in);
String request=scanner.nextLine();
//与服务端建立连接
InetSocketAddress inetSocketAddress = new InetSocketAddress(address, port);
//进行数据的封装
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8), request.getBytes().length, inetSocketAddress);
//发送数据
socket.send(requestPacket);
//创建接收packet
DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
//接收数据
socket.receive(responsePacket);
//解析数据
String response=new String(responsePacket.getData(), 0, responsePacket.getLength(), "utf-8");
//打印解析到的数据
System.out.printf("request=%s,response=%s\n",request,response);
}
}
public static void main(String[] args) throws IOException {
//创建客户端
UDPchoClient udPchoClient = new UDPchoClient("127.0.0.1", 9090);
//启动客户端
udPchoClient.start();
测试结果分析
![](https://i-blog.csdnimg.cn/blog_migrate/91b12ab62d930921af0f5783d6d06e63.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b4844fa607a5f7c91d4a2f699a406599.png)
测试要求2:请求英文单词,返回其中文翻译
服务端:
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
/**
* @author tongchen
* @create 2023-02-18 11:36
*/
public class UDPdicServer {
//创建字典
private HashMap<String,String>dic;
//创建socket
private DatagramSocket socket;
//通过构造方法进行对所需内容的初始化
public UDPdicServer(int port) throws SocketException {
//创建新的hashmap
this.dic=new HashMap<>();
dic.put("tiger", "老虎");
dic.put("cat", "小猫");
dic.put("dog", "小狗");
dic.put("pig", "小猪");
//创建新的socket
socket=new DatagramSocket(port);
}
//创建启动方法
public void start() throws IOException {
System.out.println("服务端启动.......");
//创建循环
while(true){
//创建接收请求的packet
DatagramPacket requestPacket=new DatagramPacket(new byte[1024],1024);
//接收数据
socket.receive(requestPacket);
//对数据进行解析
String request=new String(requestPacket.getData(), 0, requestPacket.getLength(), "utf-8");
//根据请求获取响应
String response=pocess(request);
//封装数据
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8), response.getBytes().length, requestPacket.getSocketAddress());
//发送数据
socket.send(responsePacket);
//打印结果
System.out.printf("[%s:%d] request = %s, response = %s\n", requestPacket.getAddress().toString(),
requestPacket.getPort(), request, response);
}
}
private String pocess(String request) {
return dic.getOrDefault(request, "查无此词");
}
public static void main(String[] args) throws IOException {
//创建服务端
UDPdicServer udPdicServer = new UDPdicServer(9091);
udPdicServer.start();
}
}
用户端:
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* @author tongchen
* @create 2023-02-18 11:00
*/
public class UDPchoClient {
//定义服务器的地址和端口号
private String address;
private int port;
private DatagramSocket socket;
//初始化端口号和目标地址
public UDPchoClient(String address, int port) throws SocketException {
this.address = address;
this.port = port;
this.socket=new DatagramSocket();
}
//启动程序
public void start() throws IOException {
System.out.println("客户端启动......");
//输入请求数据
while(true){
System.out.println("请输入请求数据");
Scanner scanner=new Scanner(System.in);
String request=scanner.nextLine();
//与服务端建立连接
InetSocketAddress inetSocketAddress = new InetSocketAddress(address, port);
//进行数据的封装
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8), request.getBytes().length, inetSocketAddress);
//发送数据
socket.send(requestPacket);
//创建接收packet
DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
//接收数据
socket.receive(responsePacket);
//解析数据
String response=new String(responsePacket.getData(), 0, responsePacket.getLength(), "utf-8");
//打印解析到的数据
System.out.printf("request=%s,response=%s\n",request,response);
}
}
public static void main(String[] args) throws IOException {
//创建客户端
UDPchoClient udPchoClient = new UDPchoClient("127.0.0.1", 9091);
//启动客户端
udPchoClient.start();
}
}
结果分析:
![](https://i-blog.csdnimg.cn/blog_migrate/e2ccb499d7c6db5c5e686f94ca54e305.png)
![](https://i-blog.csdnimg.cn/blog_migrate/e8d579a2da1b350e234985c11369a112.png)
4.2实现TCP协议的类
ServerSocket API
ServerSocket 是创建TCP服务端Socket的API。
ServerSocket 构造方法:
![](https://i-blog.csdnimg.cn/blog_migrate/57f88e45e8d23f6c9d9e59aa09d9df2a.png)
![](https://i-blog.csdnimg.cn/blog_migrate/0263c3261400b86939920839924687a1.png)
Socket API
Socket 是客户端Socket,或服务端中接收到客户端建立连接(accept方法)的请求后,返回的服务端
Socket。
不管是客户端还是服务端Socket,都是双方建立连接以后,保存的对端信息,及用来与对方收发数据
的。
Socket 构造方法:
![](https://i-blog.csdnimg.cn/blog_migrate/45679e275d6e14136f71afda87018cc9.png)
![](https://i-blog.csdnimg.cn/blog_migrate/83140c09e796460b12354cdf23bd9244.png)
我们通过实例对TCP协议进行讲解:客户端向服务端发送数据,服务端返回同样的数据
服务端:
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
/**
* @author tongchen
* @create 2023-02-20 10:50
*/
public class TcpEchoService {
//通过创建构造方法指定端口号获取socket连接
private ServerSocket socket;
public TcpEchoService(int port) throws IOException {
//判断端口的有效性
if(port<1025||port>65535){
throw new BindException("端口建议在1025和65535之间.......");
}
//通过指定端口号创建socket服务
this.socket=new ServerSocket(port);
}
//获取客户端连接
public void start() throws IOException {
System.out.println("服务端端获取连接成功......");
//不断循环接收用户的请求
while(true){
//获取与客户端的连接
Socket clientSocket = socket.accept();
//处理用户请求
pocessRequset(clientSocket);
}
}
private void pocessRequset(Socket clientSocket) throws IOException {
//打印客户端信息
System.out.printf("%s|%d,客服端连接成功......",clientSocket.getInetAddress().toString(),clientSocket.getPort());
//通过clientSocket中获取输入和输出数据
try(InputStream inputStream=clientSocket.getInputStream(); OutputStream outputStream=clientSocket.getOutputStream()){
//循环从输入中获取数据
while (true){
Scanner scan=new Scanner(inputStream);
//判断是否存在
if(!scan.hasNextLine()){
System.out.printf("%s|%d,客服端退出成功......",clientSocket.getInetAddress().toString(),clientSocket.getPort());
break;
}
//获取数据并获得返回数据
String request=scan.nextLine();
String response=pocess(request);
//发送数据
PrintWriter printWriter = new PrintWriter(outputStream);
//注意输入输出格式的一致性(用户和客户端)
printWriter.println(response);
//强制刷新缓存区
printWriter.flush();
//打印信息
System.out.printf("[%s:%d] request = %s, response = %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭资源
clientSocket.close();
}
}
private String pocess(String request) {
return request;
}
//初始化服务器
public static void main(String[] args) throws IOException {
TcpEchoService tcpEchoService = new TcpEchoService(9090);
tcpEchoService.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;
/**
* @author tongchen
* @create 2023-02-20 11:17
*/
public class TcpEchoClient {
//创建socket
private Socket socket;
//构造方法创建socket
public TcpEchoClient(String address,int port) throws IOException {
this.socket=new Socket(address, port);
}
//连接
public void start(){
System.out.printf("客户端启动成功....");
try(InputStream inputStream=socket.getInputStream(); OutputStream outputStream=socket.getOutputStream()){
//循环输入
while(true){
System.out.println("->");
Scanner scan=new Scanner (System.in);
String request=scan.nextLine();
//验证request的有效性
if(request==null||request.equals("")){
System.out.println("输入的请求不能为空");
continue;
}
//将request输入到socket
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
//强制刷新
printWriter.flush();
//在socket中获取请求
Scanner scanner = new Scanner(inputStream);
String response = scanner.nextLine();
System.out.printf("request = %s, response = %s\n", request, response);
}
}catch (Exception e){
e.printStackTrace();
}finally {
}
//循环输入
}
//验证‘=
public static void main(String[] args) throws IOException {
TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1", 9090);
tcpEchoClient.start();
}
}
一个客户端时可以正常运行,建立两个客户端时却出现了下面的情况:
![](https://i-blog.csdnimg.cn/blog_migrate/1d8f4a98552aeb4c45f799e248be55d4.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4eda77f62308e8c4addd36996218bfb5.png)
我们去分析情况,是因为只有一个线程,客户端没有退出,服务端卡在第二个while循环中出不来
![](https://i-blog.csdnimg.cn/blog_migrate/f91ef52fd672a5ea2bcac65c24b45b59.png)
![](https://i-blog.csdnimg.cn/blog_migrate/13428eb131217fef8b66b6c51e7bdf83.png)
解决措施也很简单,开启多线程即可,为了线程频繁的开启和销毁所消耗的系统资源,我们使用线程池进行优化:
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author tongchen
* @create 2023-02-20 12:18
*/
public class ThreadPoolTest {
//通过创建构造方法指定端口号获取socket连接
private ServerSocket socket;
public ThreadPoolTest(int port) throws IOException {
//判断端口的有效性
if(port<1025||port>65535){
throw new BindException("端口建议在1025和65535之间.......");
}
//通过指定端口号创建socket服务
this.socket=new ServerSocket(port);
}
//获取客户端连接
public void start() throws IOException {
System.out.println("服务端端获取连接成功......");
//不断循环接收用户的请求
//创建线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10));
while(true){
//获取与客户端的连接
Socket clientSocket = socket.accept();
threadPoolExecutor.submit(()->{
try {
//处理用户请求
pocessRequset(clientSocket);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
private void pocessRequset(Socket clientSocket) throws IOException {
//打印客户端信息
System.out.printf("%s|%d,客服端连接成功......",clientSocket.getInetAddress().toString(),clientSocket.getPort());
//通过clientSocket中获取输入和输出数据
try(InputStream inputStream=clientSocket.getInputStream(); OutputStream outputStream=clientSocket.getOutputStream()){
//循环从输入中获取数据
while (true){
Scanner scan=new Scanner(inputStream);
//判断是否存在
if(!scan.hasNextLine()){
System.out.printf("%s|%d,客服端退出成功......",clientSocket.getInetAddress().toString(),clientSocket.getPort());
break;
}
//获取数据并获得返回数据
String request=scan.nextLine();
String response=pocess(request);
//发送数据
PrintWriter printWriter = new PrintWriter(outputStream);
//注意输入输出格式的一致性(用户和客户端)
printWriter.println(response);
//强制刷新缓存区
printWriter.flush();
//打印信息
System.out.printf("[%s:%d] request = %s, response = %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭资源
clientSocket.close();
}
}
private String pocess(String request) {
return request;
}
//初始化服务器
public static void main(String[] args) throws IOException {
ThreadPoolTest tcpEchoService = new ThreadPoolTest(9090);
tcpEchoService.start();
}
}
第二个任务:实现简单对话:
import javax.sound.sampled.Port;
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.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author tongchen
* @create 2023-02-20 15:01
*/
public class TcpMsgServer {
//创建socket
private ServerSocket socket;
public TcpMsgServer(int port) throws IOException {
this.socket=new ServerSocket(port);
}
//开启工作
public void start() throws IOException {
System.out.println("用户端开启成功......");
//循环接收用户请求
//创建线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10));
while(true){
//接收用户请求
Socket clientSocket = socket.accept();
//处理用户请求(使用多线程)
threadPoolExecutor.submit(()->{
try {
pocessRequset(clientSocket) ;
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
private void pocessRequset(Socket clientSocket) throws IOException {
System.out.printf("%s|%d,客服端连接成功......\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
//获取两个流
try(InputStream inputStream=clientSocket.getInputStream(); OutputStream outputStream=clientSocket.getOutputStream()){
//多次获取用户请求
while(true){
//获取用户输入
Scanner scan=new Scanner(inputStream);
if(!scan.hasNext()){
System.out.printf("%s|%d,客服端退出成功......",clientSocket.getInetAddress().toString(),clientSocket.getPort());
break;
}
String request= scan.nextLine();
//根据请求获取响应
String response=pocess(request);
//通过print发回
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
//打印效果
printWriter.flush();
System.out.printf("[%s:%d] request = %s, response = %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}catch (Exception e){
e.printStackTrace();
}finally {
clientSocket.close();
}
}
private String pocess(String request) {
System.out.println("请求为"+request);
System.out.println("请输入你的响应->");
Scanner scanner=new Scanner(System.in);
String response=scanner.nextLine();
return response;
}
//开启
public static void main(String[] args) throws IOException {
TcpMsgServer msgServer = new TcpMsgServer(9090);
msgServer.start();
}
}