目录
网络编程
1.socket套接字
2.udp数据报套接字编程
DatagramSocket API
DatagramPacket API
Java基于UDP实现客户端-服务器代码实例
3.tcp流套接字编程
ServerSocket API
Socket API
TCP中的长短连接
Java基于TCP客户端-服务器代码实例
网络编程
1.socket套接字
Socket
套接字,是由系统提供用于网络通信的技术,是基于
TCP/IP
协议的网络通信的基本操作单元。基于Socket
套接字的网络程序开发就是网络编程。
Socket套接字可以基于传输层协议划分为三类:
- 流套接字:使用传输层TCP协议,基于字节流进行传输,对于字节流来说,可以简单的理解为,传输数据是基于IO流,流式数据的特征就是在IO流没有关闭的情况下,是无边界的数据,可以多次发送,也可以分开多次接收。
- 数据报套接字:使用传输层UDP协议,基于数据报进行传输,对于数据报来说,可以简单的理解为,传输数据是一块一块的,发送一块数据假如100个字节,必须一次发送,接收也必须一次接收100个字节,而不能分100次,每次接收1个字节。
- 原始套接字:原始套接字用于自定义传输层协议,用于读写内核没有处理的IP协议数据。
套接字(Socket)编程主要基于客户端-服务器模式之间的数据传递:
使用Socket编程时我们一般需要注意以下四点:
- 客户端和服务端:开发时,经常是基于一个主机开启两个进程作为客户端和服务端,但真实的场景,一般都是不同主机。
- 注意目的IP和目的端口号,标识了一次数据传输时要发送数据的终点主机和进程
- Socket编程我们是使用流套接字和数据报套接字,基于传输层的TCP或UDP协议,但应用层协议,也需要考虑。
- 关于端口被占用的问题:如果占用端口的进程A不需要运行,就可以关闭A后,再启动需要绑定该端口的进程B,如果需要运行A进程,则可以修改进程B的绑定端口,换为其他没有使用的端口。
Java实现了基于UDP和TCP两种模式的通信模型,下面我将对这两种模式相关的实现类进行讲解和演示。
2.udp数据报套接字编程
DatagramSocket API
DatagramSocket
是
UDP Socket
,用于发送和接收
UDP
数据报。
构造方法如下:
方法签名
|
方法说明
|
---|---|
DatagramSocket()
|
创建一个
UDP
数据报套接字的
Socket
,绑定到本机任意一个随机端口(一般用于客户端)
|
DatagramSocket(int port)
|
创建一个
UDP
数据报套接字的
Socket
,绑定到本机指定的端口(一般用于服务端)
|
常用方法如下:
方法签名
|
方法说明
|
---|---|
void receive(DatagramPacket p)
|
从此套接字接收数据报(如果没有接收到数据报,该方法会阻塞等待)
|
void send(DatagramPacket p)
|
从此套接字发送数据报包(不会阻塞等待,直接发送)
|
void close()
|
关闭此数据报套接字
|
DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报。
构造方法如下:
方法签名
| 方法说明 |
---|---|
DatagramPacket(byte[] buf, int length)
|
构造一个
DatagramPacket
以用来接收数据报,接收的数据保存在字节数组(第一个参数buf
)中,接收指定长度(第二个参数length)
|
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)
|
构造一个
DatagramPacket
以用来发送数据报,发送的数据为字节数组(第一个参数buf
)中,从
0
到指定长度(第二个参数length)。
address
指定目的主机的
IP
和端口号
|
常用方法如下:
方法签名
|
方法说明
|
---|---|
InetAddress getAddress()
|
从接收的数据报中,获取发送端主机
IP
地址;或从发送的数据报中,获取接收端主机IP
地址
|
int getPort()
|
从接收的数据报中,获取发送端主机的端口号;或从发送的数据报中,获取接收端主机端口号
|
byte[] getData()
|
获取数据报中的数据
|
构造
UDP
发送的数据报时,需要传入
SocketAddress
,该对象可以使用
InetSocketAddress
来创建。
Java基于UDP实现客户端-服务器代码实例
服务端代码:
import java.io.File;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
public class UdpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
//本地文件目录要展示的根路径
private static final String BASE_PATH = "E:/TMP";
public static void main(String[] args) throws IOException {
// 1.创建服务端DatagramSocket,指定端口,可以发送及接收UDP数据报
DatagramSocket socket = new DatagramSocket(PORT);
//不停的接收客户端udp数据报
while (true){
// 2.创建数据报,用于接收客户端发送的数据
byte[] requestData = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最
多64k(包含UDP首部8byte)
DatagramPacket requestPacket = new DatagramPacket(requestData,
requestData.length);
System.out.println("------------------------------------------------
---");
System.out.println("等待接收UDP数据报...");
// 3.等待接收客户端发送的UDP数据报,该方法在接收到数据报之前会一直阻塞,接收到数
据报以后,DatagramPacket对象,包含数据(bytes)和客户端ip、端口号
socket.receive(requestPacket);
System.out.printf("客户端IP:%s%n",
requestPacket.getAddress().getHostAddress());
System.out.printf("客户端端口号:%s%n", requestPacket.getPort());
// 7.接收到的数据作为请求,根据请求数据执行业务,并返回响应
for (int i = 0; i < requestData.length; i++) {
byte b = requestData[i];
if(b == '\3') {
// 7-1.读取请求的数据:读取到约定好的结束符(\3),取结束符之前的内容
String request = new String(requestData, 0, i);
// 7-2.根据请求处理业务:本地目录根路径+请求路径,作为要展示的目录,列
出下一级子文件
//请求的文件列表目录
System.out.printf("客户端请求的文件列表路径为:%s%n", BASE_PATH +
request);
File dir = new File(BASE_PATH + request);
//获取下一级子文件,子文件夹
File[] children = dir.listFiles();
// 7-3.构造要返回的响应内容:每个文件及目录名称为一行
StringBuilder response = new StringBuilder();
if(children != null){
for (File child : children) {
response.append(child.getName()+"\n");
}
}
//响应也要约定结束符
response.append("\3");
byte[] responseData =
response.toString().getBytes(StandardCharsets.UTF_8);
// 7-4.构造返回响应的数据报DatagramPacket,注意接收的客户端数据报包
含IP和端口号,要设置到响应的数据报中
DatagramPacket responsePacket = new
DatagramPacket(responseData, responseData.length,
requestPacket.getSocketAddress());
// 7-5.发送返回响应的数据报
socket.send(responsePacket);
break;
}
}
}
}
}
客户端代码:
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class UdpClient {
// 服务端socket地址,包含域名或IP,及端口号
private static final SocketAddress ADDRESS = new
InetSocketAddress("localhost", 8888);
public static void main(String[] args) throws IOException {
// 4.创建客户端DatagramSocket,开启随机端口就行,可以发送及接收UDP数据报
DatagramSocket socket = new DatagramSocket();
// 5-1.准备要发送的数据:这里调整为键盘输入作为发送的内容
Scanner scanner = new Scanner(System.in);
while(true){
System.out.println("------------------------------------------------
---");
System.out.println("请输入要展示的目录:");
// 5-2.每输入新行(回车),就作为UDP发送的数据报,为了接收端获取有效的内容(去除
空字符串),约定\3为结束
String request = scanner.nextLine() + "\3";
byte[] requestData = request.getBytes(StandardCharsets.UTF_8);
// 5-3.组装要发送的UDP数据报,包含数据,及发送的服务端信息(服务器IP+端口号)
DatagramPacket requestPacket = new DatagramPacket(requestData,
requestData.length, ADDRESS);
// 6.发送UDP数据报
socket.send(requestPacket);
// 8.接收服务端响应的数据报,并根据响应内容决定下个步骤(我们这里简单的打印即可)
// 8-1.创建数据报,用于接收服务端返回(发送)的响应
byte[] responseData = new byte[1024];
DatagramPacket responsePacket = new DatagramPacket(responseData,
responseData.length);
// 8-2.接收响应数据报
socket.receive(responsePacket);
System.out.println("该目录下的文件列表为:");
// byte[]下次解析的起始位置
int next = 0;
for (int i = 0; i < responseData.length; i++) {
byte b = responseData[i];
if(b == '\3')//结束符退出
break;
if(b == '\n'){//换行符时进行解析
//起始位置到换行符前一个索引位置为要解析的内容
String fileName = new String(responseData, next, i-next);
System.out.println(fileName);
//下次解析从换行符后一个索引开始
next = i+1;
}
}
}
}
}
3.tcp流套接字编程
ServerSocket API
ServerSocket 是创建TCP服务端Socket的API.
构造方法如下:
方法签名 | 方法说明 |
---|---|
ServerSocket(int port)
|
创建一个服务端流套接字
Socket
,并绑定到指定端口
|
常用方法如下:
方法签名 | 方法说明 |
Socket accept()
|
开始监听指定端口(创建时绑定的端口),有客户端连接后,返回一个服务端
Socket对象,并基于该Socket
建立与客户端的连接,否则阻塞等待
|
void close()
|
关闭此套接字
|
Socket API
Socket
是客户端
Socket
,或服务端中接收到客户端建立连接(
accept
方法)的请求后,返回的服务端Socket。
不管是客户端还是服务端
Socket
,都是双方建立连接以后,保存的对端信息,及用来与对方收发数据的。
构造方法:
方法签名
|
方法说明
|
---|---|
Socket(String host, int port)
|
创建一个客户端流套接字
Socket
,并与对应
IP
的主机上,对应端口的进程建立连接
|
常用方法如下:
方法签名 | 方法说明 |
---|---|
InetAddress getInetAddress()
|
返回套接字所连接的地址
|
InputStream getInputStream()
|
返回此套接字的输入流
|
OutputStream getOutputStream()
|
返回此套接字的输出流
|
TCP中的长短连接
TCP
发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接:
短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说,短连接只能一次收发数据。
长连接:不关闭连接,一直保持连接状态,双方不停的收发数据,即是长连接。也就是说,长连接可以多次收发数据。
对比以上长短连接,两者区别如下:
- 建立连接、关闭连接的耗时:短连接每次请求、响应都需要建立连接,关闭连接;而长连接只需要第一次建立连接,之后的请求、响应都可以直接传输。相对来说建立连接,关闭连接也是要耗时的,长连接效率更高。
- 主动发送请求不同:短连接一般是客户端主动向服务端发送请求;而长连接可以是客户端主动发送请求,也可以是服务端主动发。
- 两者的使用场景有不同:短连接适用于客户端请求频率不高的场景,如浏览网页等。长连接适用于客户端与服务端通信频繁的场景,如聊天室,实时游戏等。
基于 BIO (同步阻塞 IO )的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说,这样的消耗是不能承受的。实际应用时,服务端一般是基于NIO (即同步非阻塞 IO )来实现长连接,性能可以极大的提升。
Java基于TCP客户端-服务器代码实例
服务端代码如下:
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
public static void main(String[] args) throws IOException {
// 1.创建一个服务端ServerSocket,用于收发TCP报文
ServerSocket server = new ServerSocket(PORT);
// 不停的等待客户端连接
while(true) {
System.out.println("------------------------------------------------
---");
System.out.println("等待客户端建立TCP连接...");
// 2.等待客户端连接,注意该方法为阻塞方法
Socket client = server.accept();
System.out.printf("客户端IP:%s%n",
client.getInetAddress().getHostAddress());
System.out.printf("客户端端口号:%s%n", client.getPort());
// 5.接收客户端的数据,需要从客户端Socket中的输入流获取
System.out.println("接收到客户端请求:");
InputStream is = client.getInputStream();
// 为了方便获取字符串内容,可以将以上字节流包装为字符流
BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
String line;
// 一直读取到流结束:TCP是基于流的数据传输,一定要客户端关闭Socket输出流才表示服
务端接收IO输入流结束
while ((line = br.readLine()) != null) {
System.out.println(line);
}
// 6.双方关闭连接:服务端是关闭客户端socket连接
client.close();
}
}
}
客户端代码如下:
import java.io.*;
import java.net.Socket;
public class TcpClient {
//服务端IP或域名
private static final String SERVER_HOST = "localhost";
//服务端Socket进程的端口号
private static final int SERVER_PORT = 8888;
public static void main(String[] args) throws IOException {
// 3.创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的进程建立连接
Socket client = new Socket(SERVER_HOST, SERVER_PORT);
// 4.发送TCP数据,是通过socket中的输出流进行发送
OutputStream os = client.getOutputStream();
// 为了方便输出字符串作为发送的内容,可以将以上字节流包装为字符流
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
// 4-1.发送数据:
pw.println("hello world!");
// 4-2.有缓冲区的IO操作,真正传输数据,需要刷新缓冲区
pw.flush();
// 7.双方关闭连接:客户端关闭socket连接
client.close();
}
}
以上客户端与服务端建立的为短连接,每次客户端发送了
TCP
报文,及服务端接收了
TCP
报文后,双方都会关闭连接。