1、 网络的相关概念
1.1、 网络通信
概念两台设备之间通过网络实现数据传输
网络通信将数据通过网络从一台设备传输到另外一台设备
java.net包下提供了一系列的类和接口,供程序员使用,完成网络通信
1.2、网络
概念两台或多台设备之间通过一定物理设备连接起来构成网络
1.3、ip地址
概念用来表示网络中的唯一一台计算机
2、 InetAddress 类
2.1、相关方法
(1)getLocalHost() 获取本机InteAddress对象
(2)getByName()根据指定主机名/域名获取ip地址对象
(3)getHostName() 获取InetAddress对象的主机名
(4)getHostAddress()获取InetAddress对象的地址
package com.francis.api;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* @author Francis
* @create 2022-03-05 6:06
*/
public class InetAddress_ {
public static void main(String[] args) throws UnknownHostException {
//获取本机 InetAddress 对象 getLocalHost
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);
//根据指定主机名/域名获取 ip 地址对象 getByName
InetAddress host2 = InetAddress.getByName("Francis");
System.out.println(host2);
InetAddress host3 = InetAddress.getByName("www.baidu.com");
System.out.println(host3);
//获取 InetAddress 对象的主机名 getHostName
String host3Name = host3.getHostName();
System.out.println(host3Name);
//获取InetAddress 对象的地址 getHostAddress
String host3Address = host3.getHostAddress();
System.out.println(host3Address);
}
}
3、Socket
3.1、基本介绍
(1)套接字(Socket)开发网络应用程序被广泛应用,以至于称为事实上的标准
(2)通信的两端都要有Socket,是两台机器通信的断点
(3)Socket允许把网络连接当成一个流,数据在两个Socket间通过IO传输
(4)一般主动发起通信的一端称为客户端,等待通信请求的一端称为服务端
4、TCP 网络通信编程
4.1、基本介绍
(1)基于客户端-服务端的网络通信
(2)底层使用的是TCP/IP协议
(3)基于TCP的socket编程
4.2、应用案例 1(使用字节流)
(1) 编写一个服务端、一个客户端
(2)服务器在9999端口监听
(3)客户端连接到服务器,发送“hello server”,然后退出
(4)服务端接受到客户端发送的消息,输出并退出
package com.francis.socket;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Francis
* @create 2022-03-05 6:47
*/
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端在9999端口监听,等待连接");
//当没有客户端连接9999端口时,程序会阻塞,等待连接
//如果有客户端连接则会返回一个socket对象
Socket socket = serverSocket.accept();
System.out.println("服务端 socket=" + socket.getClass());
InputStream inputStream = socket.getInputStream();
byte[] buff = new byte[1024];
int readLen = 0;
String content = "";
while ((readLen = inputStream.read(buff)) != -1) {
System.out.println(new String(buff, 0, readLen));
content += new String(buff, 0, readLen);
}
System.out.println(content);
inputStream.close();
socket.close();
serverSocket.close();
}
}
package com.francis.socket;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* @author Francis
* @create 2022-03-05 6:47
*/
public class Client {
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket 返回="+socket.getClass());
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello server".getBytes());
outputStream.close();
socket.close();
}
}
4.3、应用案例 2(使用字节流)
(1)编写一个服务端、一个客户端
(2)服务器在9999端口监听
(3)客户端连接到服务器,发送“hello server”,并接收服务器发回的“hello client”,然后退出
(4)服务端接受到客户端发送的消息,输出,并向客户端发送“hello client” ,然后退出
package com.francis.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Francis
* @create 2022-03-05 8:17
*/
public class SocketTCP02Server {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器端正在监听9999端口");
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
byte[] buff = new byte[1024];
int readLen = 0;
while((readLen = inputStream.read(buff))!=-1){
System.out.println(new String(buff,0,readLen));
}
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello client".getBytes());
// 设置结束标记,这里如果socket断开了,也可以取到结束标记的作用
socket.shutdownOutput();
outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
package com.francis.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* @author Francis
* @create 2022-03-05 8:17
*/
public class SocketTCP02Client {
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getLoopbackAddress(), 9999);
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello server" .getBytes());
// 设置结束标记
socket.shutdownOutput();
InputStream inputStream = socket.getInputStream();
byte[] buff = new byte[1024];
int readLen = 0;
while((readLen = inputStream.read(buff))!=-1){
System.out.println(new String(buff,0,readLen));
}
inputStream.close();
outputStream.close();
socket.close();
}
}
4.4、 应用案例 3(使用字符流)
(1)编写一个服务端、一个客户端
(2)服务器在9999端口监听
(3)客户端连接到服务器,发送“hello server 字符流”,并接收服务器发回的“hello client”,然后退出
(4)服务端接受到客户端发送的消息,输出,并向客户端发送“hello client 字符流” ,然后退出
package com.francis.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Francis
* @create 2022-03-05 9:24
*/
public class SocketTCP03Server {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端,在 9999 端口监听,等待连接..");
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello client 字符流");
//插入一个换行符,表示写入的内容结束, 注意,要求对方使用 readLine()!!!!
bufferedWriter.newLine();
// 如果使用的字符流,需要手动刷新,否则数据不会写入数据通道
bufferedWriter.flush();
bufferedWriter.close();
bufferedReader.close();
socket.close();
serverSocket.close();
}
}
package com.francis.socket;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* @author Francis
* @create 2022-03-05 9:24
*/
public class SocketTCP03Client {
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket 返回="+socket.getClass());
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello server 字符流");
//插入结束标识,注意,newLine要求对方使用readLine的方式读取
bufferedWriter.newLine();
//刷新缓存通道
bufferedWriter.flush();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
inputStream.close();
outputStream.close();
socket.close();
}
}
4.5、复制图片
(1)编写一个服务端和客户端
(2)服务端监听8888端口
(3)服务器端接收到客户端发送的图片,保存到src下,发送“收到图片”再退出
package com.francis.socket.upload_picture;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* @author Francis
* @create 2022-03-05 10:13
*/
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//客户端连接服务端 8888,得到 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//创建读取磁盘文件的输入流
String filePath = "f:\\1.jpg";
//String filePath="e:\\abc.mp4";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//bytes 就是 filePath 对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//通过 socket 获取到输出流, 将 bytes 数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);//将文件对应的字节数组的内容,写入到数据通道
bis.close();
// 设置写入数据的结束标记
socket.shutdownOutput();
//=====接收从服务端回复的消息=====
InputStream inputStream = socket.getInputStream(); //使用 StreamUtils
// 的方法,直接将 inputStream 读取到的内容 转成字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//关闭相关的流
inputStream.close();
bos.close();
socket.close();
}
}
package com.francis.socket.upload_picture;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Francis
* @create 2022-03-05 10:13
*/
public class TCPFileUploadServer {
public static void main(String[] args) throws Exception {
//1. 服务端在本机监听 8888 端口
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务端在 8888 端口监听....");
//2. 等待连接
Socket socket = serverSocket.accept();
//3. 读取客户端发送的数据
// 通过 Socket 得到输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到 bytes 数组,写入到指定的路径,就得到一个文件了
String destFilePath = "f:\\111.jpg";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.close();
// 向客户端回复 "收到图片"
// 通过 socket 获取到输出流(字符)
BufferedWriter writer =
new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
writer.write("收到图片");
writer.flush();//把内容刷新到数据通道 socket.shutdownOutput();//设置写入结束标记
//关闭其他资源
writer.close();
bis.close();
socket.close();
serverSocket.close();
}
}
package com.francis.socket.upload_picture;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.io.*;
/**
* @author Francis
* @create 2022-03-05 10:14
*/
public class StreamUtils {
public static byte[] streamToByteArray(InputStream is) throws IOException, Exception {
ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
byte[] b = new byte[1024];
int len;
while ((len = is.read(b)) != -1) {
bos.write(b, 0, len);
}
byte[] array = bos.toByteArray();
bos.close();
return array;
}
/*功能:将InputStream 转换成 String
* @param is
* @return
* @throwsException
*/
public static String streamToString(InputStream is) throws IOException, 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.6、netstat指令
(1)netstat -an可以查看当前主机的网络情况,包括端口监听情况和网络连接情况
(2)netstat -an | more 可以分页显示
5、UDP 网络通信编程
5.1、基本介绍
(1)类DatagramSocket和DatagramPacket实现了基于UDP网络协议程序
(2)UDP数据报通过数据报套接字DatagramSocket发送和接收,系统不保证数据报一定能够安全的送达目的地,也不确定什么时候可以送达
(3)DatagramPacket对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的ip地址和端口号
(4)UDP协议中每个数据报都给出了完整的地址信息,因此无需建立发送方和接接收方的连接
5.2、基本流程
5.3、UDP应用案例
package com.francis.socket.upload_picture.udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* 接收端
* @author Francis
* @create 2022-03-05 15:19
*/
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//1. 创建一个DatagramSocket 对象,准备在 9999 接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2. 构建一个DatagramPacket 对象,准备接收数据
// UDP 协议的数据包最大 64k
byte[] buf = new byte[64*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.5.1"), 9998);
//发送
socket.send(packet);
//5. 关闭资源
socket.close();
System.out.println("A 端退出...");
}
}
package com.francis.socket.upload_picture.udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* 发送端
*
* @author Francis
* @create 2022-03-05 15:19
*/
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.5.1"), 9999);
socket.send(packet);
//3. === 接收从 A 端回复的信息
// (1) 构建一个 DatagramPacket 对象,准备接收数据
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 端退出");
}
}