网络通信
1.概念：两台设备之间通过网络实现数据传输
2.网络通信：将数据通过网络从一台设备传输到另一台设备
3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信
网络相关概念
1.概念：两台或多台设备通过一定物理设备连接起来构成了网络
2.根据网络的覆盖范围不同，对网络进行分类：
局域网：覆盖范围最小，仅仅覆盖一个教师或一个机房
城域网：覆盖范围较大，可以覆盖一个城市
广域网：覆盖范围最大，可以覆盖全国甚至全球，万维网是广域网的代表
IP地址
1.概念：用于唯一标识网络中的每台计算机
2.查看ip地址：ipconfig
3.ip地址的表示形式：点分十进制 xx.xx.xx.xx
4.每一个十进制数的范围：0255，四个字节32位表示，0255，0255，0255，0~255
5.ip地址的组成=网络地址+主机地址，比如：192.168.16.69
6.IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址，使用128位表示地址，16个字节是IPv4的4倍
7.由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联的障碍
ipv4地址分类
A类：0 7位网络号 24位主机号 0.0.0.0~127.255.255.255
B类：1 0 14位网络号 16位主机号 128.0.0.0~191.255.255.255
C类：1 1 0 21位网络号 8位主机号 192.0.0.0~223.255.255.255
D类：1 1 1 0 28位多播组号 224.0.0.0~239.255.255.255
E类：1 1 1 1 0 27位（留待后用） 240.0.0.0~247.255.255.255
特殊的127.0.0.1表示本机地址
域名
www.baidu.com为了方便记忆，解决记ip的困难
将ip地址映射成域名
端口号
1.概念：用于标识计算机上某个特定的网络程序
2.表现形式：以整数形式，端口范围0~65535【2个字节表示端口 0~2^16-1】
3.0~1024已经被占用比如ssh 22,ftp 21,smtp 25,http 80
4.常见的网络程序端口号：
tomcat:8080
mysql:3306
oracle:1521
sqlserver:1433
网络通信协议
tcp/ip协议中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互连网络的基础，简单地说，就是由网络层的ip协议和传输层的TCP协议组成的
TCP和UDP
TCP协议：传输控制协议
1.使用TCP协议前，须先建立TCP连接，形成传输数据通道
2.传输前，采用三次握手方式，是可靠的
3.TCP协议进行通信的两个应用进程：客户端和服务端
4.在连接中可进行大数据量的传输
5.传输完毕，需释放已建立的连接，效率低
UDP协议：用户数据协议
1.将数据、源、目的封装成数据包，不需要建立连接
2.每个数据报的大小限制在64K内，不适合传输大量数据
3.因无需连接，故是不可靠的
4.发送数据结束时无需释放资源（因为不是面向连接的），速度快
InetAddress类
1.获取本机InetAddress对象getLocalHost
2.根据指定主机名/域名获取ip地址对象getByName
3.获取InetAddress对象的主机名getHostName
4.获取InetAddress对象的地址getHostAddress
// 1.获取本机的InetAddress对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);// // LAPTOP-5IKVUUKJ/192.168.41.1
// 2.根据指定主机名，获取InetAddress对象
InetAddress host1 = InetAddress.getByName("LAPTOP-5IKVUUKJ");
System.out.println("host1=" + host1);// LAPTOP-5IKVUUKJ/192.168.41.1
// 3.根据域名返回InetAddress对象，比如www.baidu.com
InetAddress host2 = InetAddress.getByName("www.baidu.com");
System.out.println("host2="+host2);// www.baidu.com/39.156.66.14
// 4.通过InetAddress对象获取对应的地址
String hostAddress = host2.getHostAddress();
System.out.println("host2对应的ip="+hostAddress);// 39.156.66.14
// 5.通过InetAddress对象获取对应的主机名/域名
String hostName = host2.getHostName();
System.out.println("host2对应的主机名/域名"+hostName);// www.baidu.com
Socket
1.套接字Socket开发网络应用程序被广泛采用，以至于成为事实上的标准
2.通信的两端都要有Socket,是两台机器间通信的端点
3.网络通信其实就是Socket间的通信
4.Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输
5.一般主动发起通信的应用程序属于客户端，等待通信请求的为服务端
TCP网络通信编程
单向通信：字节流
服务端：
// 在本机的9999端口监听，等待连接
// 要求本机没有其他服务在监听9999
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接...");
// 当没有客户端连接9999端口时，程序会阻塞，等待连接
// 如果有客户端连接，则会返回Socket对象，程序继续
// 这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
Socket socket = serverSocket.accept();
System.out.println("服务端socket=" + socket.getClass());
// 通过socket.getInputStream()读取客户端写入到数据通道的数据,显示
InputStream inputStream = socket.getInputStream();
// IO读取
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf))!= -1){
System.out.println(new String(buf,0,readLen));
}
// 关闭流和socket
inputStream.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出...");
客户端：
// 连接服务端(ip、端口)
// 连接本机的9999端口，如果连接成功，返回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端socket返回=" + socket.getClass());
// 连接上后，生成Socket,通过socket.getOutputStream()得到和socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
// 通过输出流，写入数据到数据通道
outputStream.write("hello server".getBytes());
outputStream.close();
socket.close();
System.out.println("客户端退出...");
双向通信：字节流
服务端：
设置输出流结束标记
socket.shutdownOutput();
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接...");
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf))!= -1){
System.out.println(new String(buf,0,readLen));
}
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello client".getBytes());
// 设置输出流结束标记
socket.shutdownOutput();
outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();
客户端：
设置输出流结束标记
socket.shutdownOutput();
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello server".getBytes());
// 设置输出流结束标记
socket.shutdownOutput();
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf))!= -1){
System.out.println(new String(buf,0,readLen));
}
inputStream.close();
outputStream.close();
socket.close();
双向通信：字符流
设置字符输出流结束标记
write.newLine()
字符输入流需要使用readLine()
使用字符输入字符流需要手动刷新bufferedWriter.flush()
服务端：
ServerSocket serverSocket = new ServerSocket(9998);
System.out.println("服务端，在9999端口监听，等待连接...");
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
// 输入字符流需要使用对应的readLine()
String s = bufferedReader.readLine();
System.out.println(s);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello client 字符流");
bufferedWriter.newLine();
bufferedWriter.flush();
bufferedWriter.close();
bufferedReader.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出...");
客户端：
Socket socket = new Socket(InetAddress.getLocalHost(), 9998);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello server 字符流");
// 设置输出字符流的结束标记
bufferedWriter.newLine();
// 使用输出字符流需要手动刷新
bufferedWriter.flush();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
bufferedReader.close();
bufferedWriter.close();
socket.close();
System.out.println("客户端退出...");
TCP上传文件
编写的工具类：把文件的内容读入到byte[]和把读取内容写到磁盘上
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;
}
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){
builder.append(line+"\r\n");
}
return builder.toString();
}
}
服务器：
// 在本机的8888端口监听
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务端，在8888端口监听，等待连接...");
// 等待连接
Socket socket = serverSocket.accept();
// 读取客户端发送的数据
// 通过Socket得到输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
// 将得到bytes数组，写入到指定的路径，就得到一个文件了
String destFilePath = "src/data/哀酱2.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();
客户端：
// 客户端连接服务器8888，得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
// 创建读取磁盘文件的输入流
String filepath = "E:\\我的图片\\哀酱.jpg";
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();
netstat指令
1.netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
2.netstat -an | more 可以分页查看 按空格翻页
(1)Listening表示某个端口在监听
(2)如果有一个外部程序(客户端)连接到该端口，外部地址就会显示一条连接信息
(3)可以输入ctrl+c退出指令
0.0.0.0:xxx和127.0.0.1:xxx表示本机ip
4.netstat -anb | more 查看哪一个程序侦听的端口
补充
当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口时TCP/IP来分配的，是不确定的，也是随机的
UDP网络通信编程
1.类DatagramSocket和DatagramPacket[数据包/数据报]实现了基于UDP协议网络程序
2.UDP数据报通过数据报套接字DatagramSocket发送和接受，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
3.DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
4.UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
(1)没有明确的服务端和客户端，演变成数据的发送端和接收端
(2)接收数据和发送数据是通过DatagramSocket对象完成
(3)将数据封装到DatagramPacket对象/装包
(4)当接收到DatagramPacket对象，需要进行拆包，取出数据
(5)DatagramSocket可以指定在哪个端口接收数据
UDP网络通信编程基本流程
1.核心的两个类/对象DatagramSocket与DatagramPacket
2.建立发送端，接收端（没有服务端和客户端概念）
3.发送数据前，建立数据包/报DatagramPacket对象
4.调用DatagramSocket的发送、接收方法
5.关闭DatagramSocket
接收端：
// 创建一个DatagramSocket对象，准备在9999接收数据
DatagramSocket socket = new DatagramSocket(9999);
// 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64k
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
// 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
// 当有数据包发送到本机的9999端口时，就会接收到数据
// 如果没有数据包发送到本机的9999端口时，就会阻塞等待
System.out.println("接收端A 等待接收数据...");
socket.receive(packet);
// 可以把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.43.221"), 9998);
socket.send(packet);
// 关闭资源
socket.close();
System.out.println("A端退出...");
发送端：
// 创建DatagramSocket对象，准备在9998端口接收数据
DatagramSocket socket = new DatagramSocket(9998);
// 将需要发送的数据，封装到DatagramPacket对象
byte[] data = "hello 明天吃火锅~".getBytes();
// 封装的DatagramPacket对象包括：data内容字节数组，data.length,主机(ip),端口
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 9999);
socket.send(packet);
//====================接收从A端回复的信息
// 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64k
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
// 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
// 当有数据包发送到本机的9998端口时，就会接收到数据
// 如果没有数据包发送到本机的9998端口时，就会阻塞等待
socket.receive(packet);
// 可以把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端退出...");
客户端发出问题，服务端回答问题
服务端：
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();
String answer = "";
if ("name".equals(s)){
answer = "我是xxx";
} else if ("hobby".equals(s)){
answer = "看动漫";
} else {
answer = "我听不懂呀";
}
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write(answer);
bufferedWriter.newLine();
bufferedWriter.flush();
bufferedWriter.close();
bufferedReader.close();
socket.close();
serverSocket.close();
客户端：
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题");
String question = scanner.next();
bufferedWriter.write(question);
bufferedWriter.newLine();
bufferedWriter.flush();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
bufferedReader.close();
bufferedWriter.close();
socket.close();
发送端发送问题，接收端回答问题
发送端：
// 创建一个DatagramSocket对象，准备在8888接收数据
DatagramSocket socket = new DatagramSocket(8889);
// 将需要发送的数据，封装到DatagramPacket对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题");
String question = scanner.next();
byte[] data = question.getBytes();
// 封装的DatagramPacket对象包括：data内容字节数组,data.length,主机(ip),端口
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 8888);
socket.send(packet);
//=============接收从A端回复的信息
// 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64K
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
// 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
// 如果没有数据包发送到本机的8889，就会阻塞等待
socket.receive(packet);
// 可以把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端退出...");
接收端：
// 创建一个DatagramSocket对象，准备在8888接收数据
DatagramSocket socket = new DatagramSocket(8888);
System.out.println("接收端，在8888端口监听，等待连接...");
// 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64K
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
// 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
// 如果没有数据包发送到本机的8888，就会阻塞等待
socket.receive(packet);
// 可以将packet进行拆包，取出数据，并显示
int length = packet.getLength();// 实际接收到的数据字节长度
byte[] data = packet.getData();// 接收到的数据
String s = new String(data, 0, length);
System.out.println(s);
// 判断接收到的信息是什么
String answer = "";
if ("四大名著是哪些".equals(s)){
answer = "四大名著 <<红楼梦>> <<西游记>> <<水浒传>> <<三国演义>>";
} else {
answer = "what";
}
//==============回复信息给B端
// 将需要发送的数据，封装到DatagramPacket对象
// 封装的DatagramPacket对象包括：data内容字节数组,data.length,主机(ip),端口
data = answer.getBytes();
packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 8889);
socket.send(packet);// 发送
// 关闭资源
socket.close();
System.out.println("A端退出...");
TCP下载文件
服务端：
// 监听9999端口
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接...");
// 等待客户端连接
Socket socket = serverSocket.accept();
// 读取客户端发送要下载的文件名
InputStream inputStream = socket.getInputStream();
byte[] b = new byte[1024];
int len = 0;
String downLoadFileName = "";
while ((len = inputStream.read(b))!= -1){
downLoadFileName += new String(b,0,len);
}
System.out.println("客户端希望下载的文件名=" + downLoadFileName);
// 如果客户下载的是高山流水，我们就返回该文件，否则一律返回无名.mp3
String resFileName = "";
if ("高山流水".equals(downLoadFileName)){
resFileName = "src\\高山流水.mp3";
} else {
resFileName = "src\\无名.mp3";
}
// 创建一个输入流，读取文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(resFileName));
// 使用工具类StreamUtils，读取文件到一个字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
// 得到Socket关联的输出流
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
// 写入到数据通道，返回给客户端
bos.write(bytes);
// 设置结束标记
socket.shutdownOutput();
// 关闭相关资源
bos.close();
bis.close();
inputStream.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出...");
客户端：
// 接收用户输入，指定下载文件名
Scanner scanner = new Scanner(System.in);
System.out.println("请输入下载文件名");
String downloadFile = scanner.next();
// 客户端连接服务器，准备发送
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
// 获取和Socket关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write(downloadFile.getBytes());
// 设置结束标记
socket.shutdownOutput();
// 读取服务端返回的文件(字节数据)
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
// 得到一个输出流，准备将bytes写入到磁盘文件
// 如果你下载的是高山流水 => 下载的就是高山流水.mp3
// 如果你在的是xxx => 下载的就是无名.mp3 =>文件名是xxx.mp3
byte[] bytes = StreamUtils.streamToByteArray(bis);
String filepath = "e:\\" + downloadFile + ".mp3";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filepath));
bos.write(bytes);
// 关闭相关资源
bos.close();
bis.close();
outputStream.close();
socket.close();
System.out.println("客户端下载完毕，正确退出...");
扫一扫
510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
