网络编程
1. 简介
- 网络：两台或多台设备通过一定物理设备连接起来构成了网络
- 网络通信：两台设备之间通过网络实现数据传输
- ip地址：用于唯一标识网络中的每台计算机
- 查看ip地址：ipconfig
- ip地址组成：网络地址+主机地址
- IPv4和IPv6
- IPv4表示：4个字节(32位)0~255
- IPv6表示：16个字节(128位)
a. 域名：将ip地址映射成域名
b. 端口号：用于标识计算机上某个特定的网络程序065535，01024已被占用，smtp 25,http 80
TCP协议：
- 三次握手
- 可靠，速度慢
UDP协议(用户数据协议)：
- 大小限制64k
- 速度快
2. InetAddress类
常用方法：
getLocalHost()返回本地主机。getByName()在给定主机名的情况下确定主机的 IP 地址。getHostAddress()返回 IP 地址字符串（以文本表现形式）。getHostName()获取此 IP 地址的主机名。
package com.xxx;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class API_ {
public static void main(String[] args) throws UnknownHostException {
//返回本机的主机名/ip地址
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);//DESKTOP-T5RI7XC/192.168.22.127
//根据指定主机名，获取InetAddress对象
InetAddress inetAddress = InetAddress.getByName("DESKTOP-T5RI7TC");
System.out.println(inetAddress);//DESKTOP-T5RI7XC/192.168.22.127
//根据域名返回InetAdddress对象
InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
System.out.println(inetAddress1);//www.baidu.com/182.61.200.6
//根据InetAddress对象,获取对应的地址
String hostAddress = inetAddress.getHostAddress();
System.out.println(hostAddress);//192.168.22.127
//根据InetAddress对象，获取对应的主机名/域名
String hostName = inetAddress1.getHostName();
System.out.println(hostName);//www.baidu.com
}
}
3. Socket套接字
简介：
Socket网络应用程序被广泛使用，成为事实上的标准。
通信的两端都要有Socket，网络通信其实就是Socket通信。
客户端：发起通信的应用程序
服务端：等待通信请求
package com.xxx;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketTcpServer {
public static void main(String[] args) throws IOException {
//思路
//1.在本机的9999端口监听， 等待连接
//如果本机有其他服务已经在监听9999，那么会失败
ServerSocket serverSocket = new ServerSocket (9999);
System.out.println("服务端在9999端口监听");
//2. 当没有客户端连接9999端口时，程序会阻塞，等待连接
//如果有客户端连接，则会返回Socket对象，程序继续往下执行
Socket socket = serverSocket.accept();
System.out.println("服务端socket=" + socket.getClass());
//3.通过socket.getInputStream() 读取客户端写入到数据通道的数据，显示
InputStream inputStream = socket.getInputStream();
// //4.通过IO流读取，字节流
// byte[] buffer = new byte[1024];
// int readLen = -1;
// while ((readLen = inputStream.read(buffer)) != -1) {
// System.out.println(new String(buffer,0,readLen));
// }
//通过IO读取，字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
//5.获取socket相关的输出流
OutputStream outputStream = socket.getOutputStream();
// outputStream.write("Hello Client".getBytes());
//使用字符输出流回复信息
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("Hello Client 字符流");
bufferedWriter.newLine();//插入一个换行符，表示回复内容结束
bufferedWriter.flush();
System.out.println();
//6.关闭流和socket
// outputStream.close();
bufferedWriter.close();//关闭外层流就行
// inputStream.close();
bufferedReader.close();//关闭外层流就行
socket.close();
serverSocket.close();//服务socket也要关闭
}
}
package com.xxx;
import sun.reflect.generics.scope.Scope;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
class SocketTcpClient {
public static void main(String[] args) throws IOException {
//思路
//1.连接服务器(ip，端口号)
//连接本机的9999端口，连接成功时返回socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端：" + socket.getClass());
//2.连接上后，生成Socket，通过getOutputStream得到和socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道
// outputStream.write("Hello".getBytes());
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("Hello Server 字符流");
bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束。作用相当于设置结束标记，但是要求对方也要用readLine
bufferedWriter.flush();//使用字符流，需要手动刷新，否则数据不会写入到数据通道
// //设置结束标记
// socket.shutdownOutput();
//4.关闭流对象和socket
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
//5.关闭流和socket
// inputStream.close();
bufferedReader.close();//关闭外层流就行
// outputStream.close();
bufferedWriter.close();//关闭外层流就行
socket.close();
System.out.println("客户端退出。。。");
}
}
3.1 案例：
上传文件
package com.xxx;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author 王则钰 Wyzel
* @date 2022/10/30 12:39
* @Description
*/
public class TcpFileUploadServer {
public static void main(String[] args) throws Exception {
//1.服务端在本机监听7777端口
ServerSocket serverSocket = new ServerSocket(7777);
System.out.println("服务器在7777端口监听。。。");
//2.等待客户端连接
Socket socket = serverSocket.accept();
//8.读取客户端发送的数据
//通过Socket得到输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//9.将得到的bytes数组，写入到指定路径，得到一个文件
String destFilePath = "src\\copy7.png";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.close();
//11.向客户端回复收到
//通过Socket获取输出流
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bufferedWriter.write("服务端回复：收到图片");
bufferedWriter.flush();//把内容刷新到数据通道
socket.shutdownOutput();//设置写入结束标记
//10.关流
bufferedWriter.close();
bis.close();
socket.close();
serverSocket.close();
}
}
package com.xxx;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class TcpFileUploadClient {
public static void main(String[] args) throws Exception {
//3.客户端连接服务器，得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(),7777);
//4.创建读取磁盘文件的输入流
String filePath = "D:\\a\\b\\7.png";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//5.调用StreamUtils
//bytes就filPath是对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//6.通过socket获取输出流，把bytes数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);//将文件对应的字节数组内容，写入到数据通道
bis.close();
socket.shutdownOutput();//写入数据的结束标记
//12.接收从服务端回复的消息
InputStream inputStream = socket.getInputStream();
//使用StreamUtils的方法，将inputStream读取到的内容转为字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//7.关流
bos.close();
socket.close();
}
}
package com.xxx;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
public class StreamUtils {
/**
* 功能：将输入流转换成 byte[],即可以把文件的内容读取到byte[]
* @param is
* @return
* @throws Exception
*/
public static byte[] streamToByteArray(InputStream is) throws Exception {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
//创建输出流对象
byte[] b = new byte[1024];//字节数组
int len;
while ((len = is.read(b)) != -1) {//循环读取
bos.write(b, 0, len);//吧读取到的数据，写入bos
}
byte[] array = bos.toByteArray();//把bos转换成字节数组
bos.close();
return array;
}
/**
* 功能：将 InputStream 转换成 String
* @param is
* @return
* @throws Exception
*/
public static String streamToString(InputStream is) throws Exception {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {//当读取到 null 时，就表示结束
builder.append(line + "\r\n");
}
return builder.toString();
}
}
4. TCP网络通信编程
netstat指令
- 在dos控制台输入命令：netstat -an可以查看当前主机网络情况，包括端口监听情况和网络连接情况
- netstat - an | more 可以分页显示
- Listening表示某个端口在监听
*客户端Socket连接成功后会有一个随机的端口号
5. UDP网络通信编程
- 类DatagramSocket和DatagramPacket[数据包/数据报]实现了基于UDP协议网络程序
- 数据包套接字DatagramSocket发送和接收，系统不保证能否送到目的地，也不能确定何时送达
- 数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
- UDP无需建立发送方和接收方的连接
UDP基本流程
- DatagramSocket和DatagramPacket
- 建立发送端，接收端
- 建立数据报DatagramPacket对象
- 调用DatagramSocket的发送、接收方法
- 关闭DatagramSocket
package com.xxx;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpReceiverA {
public static void main(String[] args) throws IOException, IOException {
//1. 创建一个 DatagramSocket 对象，准备在 9999 接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2. 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解 UDP 协议时，老师说过一个数据包最大 64k
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
//3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet 对象
//提示: 当有数据包发送到 本机的 9999 端口时，就会接收到数据
// 如果没有数据包发送到 本机的 9999 端口, 就会阻塞等待.
System.out.println("接收端 A 等待接收数据..");
socket.receive(packet);
//4. 可以把 packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
byte[] data = packet.getData();//接收到数据
String s = new String(data, 0, length);
System.out.println(s);
//===回复信息给 B 端
// 将需要发送的数据，封装到 DatagramPacket 对象
data = "好的, 明天见".getBytes();
// 说明: 封装的 DatagramPacket 对象 data 内容字节数组 , data.length , 主机(IP) , 端口
packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.117"), 9998);
socket.send(packet);//发送
// 5. 关闭资源
socket.close();
System.out.println("A 端退出...");
}
}
package com.xxx;
import java.io.IOException;
import java.net.*;
@SuppressWarnings({"all"})
public class UdpSenderB {
public static void main(String[] args) throws IOException {
//1.创建 DatagramSocket 对象，准备在 9998 端口 接收数据
DatagramSocket socket = new DatagramSocket(9998);
//2. 将需要发送的数据，封装到 DatagramPacket 对象
byte[] data = "hello 明天吃火锅~".getBytes(); //
// 说明: 封装的 DatagramPacket 对象 data 内容字节数组 , data.length , 主机(IP) , 端口
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.117"), 9999);
socket.send(packet);
//3.=== 接收从 A 端回复的信息
// (1) 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解 UDP 协议时，老师说过一个数据包最大 64k
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2) 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet 对象
// 提示: 当有数据包发送到 本机的 9998 端口时，就会接收到数据
// 如果没有数据包发送到 本机的 9998 端口, 就会阻塞等待.
socket.receive(packet);
//(3) 可以把 packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();// 接收到数据
String s = new String(data, 0, length);
System.out.println(s);
//关闭资源
socket.close();
System.out.println("B 端退出");
}
}
浙公网安备 33010602011771号