今日任务
网络编程基础
IP地址、端口、通信协议
网络编程相关类
TCP编程模型 重点
了解UDP编程 了解
1.网络编程基础
1.1.计算机网络概念
所谓计算机网络,就是把分布在不同区域的计算机与专门的外部设备用通信线路相互连接成一个规模大,而且功能强的网络系统,从而使得计算机之间可以相互传递信息,共享数据、软件等资源。

1.2.网络编程的目的
所谓网络编程,指的就是在同一个网络中不同机器之间的通信。
直接或间接地通过网络协议与其它计算机进行通讯。
1.3.网络编程中有两个主要的问题
如何准确地定位网络上一台或多台主机 要通信的目标机器
找到主机后如何可靠高效地进行数据传输。 如何通信
2.计算机之间通信需要的条件
2.1.网络通讯协议(了解 面试会问)
通过计算机网络可以使多台计算机实现连接,位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则,这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中,这些连接和通信的规则被称为网络通信协议,它对数据的传输格式、传输速率、传输步骤等做了统一规定,通信双方必须同时遵守才能完成数据交换。
如何实现网络中的主机互相通信:
通信双方地址
一定的规则(有两套参考模型)
OSI参考模型:模型过于理想化,未能在因特网上进行广泛推广。
TCP/IP参考模型(或TCP/IP协议):事实上的国际标准。
上图中,TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层,每层分别负责不同的通信功能,接下来针对这四层进行详细地讲解。
链路层:链路层是用于定义物理传输通道,通常是对某些网络连接设备的驱动协议,例如针对光纤、网线提供的驱动。
网络层:网络层是整个TCP/IP协议的核心,它主要用于将传输的数据进行分组,将分组数据发送到目标计算机或者网络。 路由器 交换机
传输层:主要使网络程序进行通信,在进行网络通信时,可以采用TCP协议,也可以采用UDP协议。
应用层:主要负责应用程序的协议,例如HTTP协议(网站开发)、FTP协议(文件传输)等。SMTP协议(邮件发送协议)
2.2 IP地址和端口号
IP相当于一个人的身份证,IP可以唯一的标识一台主机!
要想使网络中的计算机能够进行通信,必须为每台计算机指定一个标识号,通过这个标识号来指定接受数据的计算机或者发送数据的计算机。
xxx.xxx.xxx.xxx
在TCP/IP协议中,这个标识号就是IP地址,它可以唯一标识一台计算机,目前,IP地址广泛使用的版本是IPv4,它是由4个字节大小的二进制数来表示
如:00001010000000000000000000000001。由于二进制形式表示的IP地址非常不便记忆和处理,因此通常会将IP地址写成十进制的形式,每个字节用一个十进制数字(0-255)表示,数字间用符号“.”分开,如 “192.168.1.100”。

http://119.29.248.68/
一般不容易记忆所以 需要DNS做域名解析,实际使用中都是使用域名来标识IP地址!
域名需要注册,注册需要花钱!
http://www.itxiongmao.com 全球唯一的 已经注册过就不能再注册过!
随着计算机网络规模的不断扩大,对IP地址的需求也越来越多,IPV4这种用4个字节表示的IP地址面临枯竭,因此IPv6 便应运而生了,IPv6使用16个字节表示IP地址,它所拥有的地址容量约是IPv4的8×1028倍,达到2128个(算上全零的),这样就解决了网络地址资源数量不够的问题。
通过IP地址可以连接到指定计算机,但如果想访问目标计算机中的某个应用程序,还需要指定端口号。在计算机中,不同的应用程序是通过端口号区分的。端口号是用两个字节(16位的二进制数)表示的,它的取值范围是0~65535,其中,0~1023之间的端口号用于一些知名的网络服务和应用,用户的普通应用程序需要使用1024以上的端口号,从而避免端口号被另外一个应用或服务所占用。
接下来通过一个图例来描述IP地址和端口号的作用,如下图所示。
从上图中可以清楚地看到,位于网络中一台计算机可以通过IP地址去访问另一台计算机,并通过端口号访问目标计算机中的某个应用程序。
2.2.1.IP 地址:InetAddress
- 唯一的标识 Internet 上的计算机
- 本地回环地址(hostAddress):
127.0.0.1(本机地址,当前你正在使用的这台主机)
主机名(hostName):localhost(127.0.0.1)
2.2.2.端口号
端口号:标识正在计算机上运行的进程(程序)
-
不同的进程有不同的端口号,标识计算机上的不同程序!
-
被规定为一个 16 位的整数
0~65535。其中,0~1023被预先定义的服务通信占用(如http占用端口80,Tomcat占用端口8080,MySql占用端口3306,Oracle占用端口1521等)。除非我们需要访问这些特定服务,否则,就应该使用 1024~65535 这些端口中的某一个进行通信,以免发生端口冲突。、 -
端口分类:
公认端口:0~1023
注册端口:1025~49151
动态或私有端口:1024~65535

端口号与IP地址的组合得出一个网络套接字:Socket。
2.2.3.InetAddress类
了解了IP地址的作用,我们看学习下JDK中提供了一个InetAdderss类,该类用于封装一个IP地址,并提供了一系列与IP地址相关的方法,下表中列出了InetAddress类的一些常用方法。
InetAddress类没有提供公共的构造器,而是提供了如下两个静态方法来获取InetAddress实例。

上图中,列举了InetAddress的四个常用方法。其中,前两个方法用于获得该类的实例对象,第一个方法用于获得表示指定主机的InetAddress对象,第二个方法用于获得表示本地的InetAddress对象。通过InetAddress对象便可获取指定主机名,IP地址等,接下来通过一个案例来演示InetAddress的常用方法,如下所示。
public class InetAddressDemo {
public static void main(String[] args) {
try {
InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
System.out.println("inetAddress="+inetAddress);
//获取inetAddress对应的域名:
System.out.println(inetAddress.getHostName());
//获取inetAddress对英国的IP地址
System.out.println(inetAddress.getHostAddress());
//获取本机的域名和ID地址
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
3.UDP与TCP协议(面试题)
在介绍TCP/IP结构时,提到传输层的两个重要的高级协议,分别是UDP和TCP,其中
UDP是User Datagram Protocol的简称,称为用户数据报协议,
TCP是Transmission Control Protocol的简称,称为传输控制协议。定义了数据传输的方式!
3.1.UDP协议
UDP是无连接通信协议,即在数据传输时,数据的发送端和接收端不建立逻辑连接。简单来说,当一台计算机向另外一台计算机发送数据时,发送端不会确认接收端是否存在,就会发出数据,同样接收端在收到数据时,也不会向发送端反馈是否收到数据。
由于使用UDP协议消耗资源小,通信效率高,所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议,因为这种情况即使偶尔丢失一两个数据包,也不会对接收结果产生太大影响。
但是在使用UDP协议传送数据时,由于UDP的面向无连接性,不能保证数据的完整性,因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。

3.2.TCP协议(重点)
TCP协议是面向连接的通信协议,即在传输数据前先在发送端和接收端建立逻辑连接,然后再传输数据,它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端,由客户端向服务端发出连接请求,每次连接的创建都需要经过“三次握手”。第一次握手,客户端向服务器端发出连接请求,等待服务器确认,第二次握手,服务器端向客户端回送一个响应,通知客户端收到了连接请求,第三次握手,客户端再次向服务器端发送确认信息,确认连接。整个交互过程如下图所示。
由于TCP协议的面向连接特性,它可以保证传输数据的安全性,所以是一个被广泛采用的协议,例如在下载文件时,如果数据接收不完整,将会导致文件数据丢失而不能被打开,因此,下载文件时必须采用TCP协议。
3.3 小结
-
TCP协议:
使用TCP协议前,须先建立TCP连接,形成传输数据通道
传输前,采用“三次握手”方式,是可靠的
TCP协议进行通信的两个应用进程:客户端、服务端
在连接中可进行大数据量的传输
传输完毕,需释放已建立的连接,效率低 -
UDP协议:
将数据、源、目的封装成数据包,不需要建立连接
每个数据报的大小限制在64K内
因无需连接,故是不可靠的
发送数据结束时无需释放资源,速度快 容易丢失数据
4.TCP通信
TCP能实现两台计算机之间的通信,通信的两端都需要创建socket对象。
TCP通信是严格区分客户端与服务器端的,在通信时,必须先由客户端去连接服务器端才能实现通信,服务器端不可以主动连接客户端,并且服务器端程序需要事先启动,等待客户端的连接。
在JDK中提供了两个类用于实现TCP程序,一个是ServerSocket类,用于表示服务器端,一个是Socket类,用于表示客户端。
通信时,首先创建代表服务器端的ServerSocket对象,该对象相当于开启一个服务,并等待客户端的连接,然后创建代表客户端的Socket对象向服务器端发出连接请求,服务器端响应请求,两者建立连接开始通信。
4.1.ServerSocket
在开发TCP程序时,首先需要创建服务器端程序。JDK的java.net包中提供了一个ServerSocket类,该类的实例对象可以实现一个服务器段的程序。

使用该构造方法在创建ServerSocket对象时,就可以将其绑定到一个指定的端口号上(参数port就是端口号)。
接下来学习一下ServerSocket的常用方法,如表所示。

ServerSocket对象负责监听某台计算机的某个端口号,在创建ServerSocket对象后,需要继续调用该对象的accept()方法,接收来自客户端的请求。当执行了accept()方法之后,服务器端程序会发生阻塞,直到客户端发出连接请求,accept()方法才会返回一个Scoket对象用于和客户端实现通信,程序才能继续向下执行。
4.2.Socket
讲解了ServerSocket对象可以实现服务端程序,但只实现服务器端程序还不能完成通信,此时还需要一个客户端程序与之交互,为此JDK提供了一个Socket类,用于实现TCP客户端程序。
使用该构造方法在创建Socket对象时,会根据参数去连接在指定地址和端口上运行的服务器程序,其中参数host接收的是一个字符串类型的IP地址。

该方法在使用上与第二个构造方法类似,参数address用于接收一个InetAddress类型的对象,该对象用于封装一个IP地址。
接下来学习一下Socket的常用方法,如表所示。

在Socket类的常用方法中,getInputStream()和getOutStream()方法分别用于获取输入流和输出流。当客户端和服务端建立连`接后,数据是以IO流的形式进行交互的,从而实现通信。
接下来通过一张图来描述服务器端和客户端的数据传输,如下图所示。

4.3.案例1:简单的TCP网络程序

了解ServerSocket、Socket类的基本用法,为了让大家更好地掌握这两个类的使用,接下来通过一个TCP通信的案例来进一步学习。
- 服务端
服务器程序的工作过程包含以下四个基本的步骤:
1.调用 ServerSocket(int port) :创建一个服务器端套接字,并绑定到指定端口上。用于监听客户端的请求。
2.调用accept():监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字对象。
3.调用该Socket类对象的 getOutputStream() 和 getInputStream ():获取输出流和输入流,开始网络数据的发送和接收。
4.关闭ServerSocket和Socket对象:客户端访问结束,关闭通信套接字。
/**
* TCP服务端 1,创建服务器ServerSocket对象(指定服务器端口号)
* 2,开启服务器了,等待客户端的连接,当客户端连接后,可以获取到连接服务器的客户端Socket对象
* 3,给获取或者给客户端反馈信息
* 4,关闭流资源
* @author bruceliu
*/
public class TCP_ServerDemo1 {
public static void main(String[] args) throws Exception {
// 1.创建服务器ServerSocket对象(指定服务器端口号)
ServerSocket serverSocket = new ServerSocket(9999);
// 2.开启服务器了,等待客户端的连接,当客户端连接后,可以获取到连接服务器的客户端Socket对象
// 注意:在未连接成功之前,将一直处于阻塞状态
Socket socket = serverSocket.accept();
System.out.println("连接成功");
// 3.获取网络到内存的一个输入流
InputStream input = socket.getInputStream();
// 4.读取数据
byte[] arr = new byte[1024];
int len = input.read(arr);
String message = new String(arr, 0, len);
// 5.组织信息
String ipString = socket.getInetAddress().getHostAddress();
System.out.println(ipString + ": 说:" + message);
//关闭流
input.close();
socket.close();
serverSocket.close();
}
}
- 客户端
客户端Socket的工作过程包含以下四个基本的步骤:
1.创建Socket:根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应,则建立客户端到服务器的通信线路。若连接失败,会出现异常。
2.打开连接到 Socket 的输入/出流: 使用 getInputStream()方法获得输入流,使用 getOutputStream()方法获得输出流,进行数据传输
3.按照一定的协议对 Socket 进行读/写操作:通过输入流读取服务器放入线路的信息,通过输出流将信息写入线程。
4. 关闭 Socket:断开客户端到服务器的连接,释放线路。
/**
*
* TCP 客户端 1,创建客户端Socket对象,(指定要连接的服务器地址与端口号)
* 2,获取或者发送 给 服务器端的信息
* 3,关闭流资源
*
* @author bruceliu
*
*/
public class TCP_ClientDemo1 {
public static void main(String[] args) throws Exception {
// 1,创建客户端Socket对象,(指定要连接的服务器地址与端口号)
Socket socket = new Socket("127.0.0.1", 9999);
// 2,获取服务器端的反馈回来的信息
OutputStream output = socket.getOutputStream();
// 3.写入
output.write("hello你好吗?".getBytes());
output.flush();
//4.关闭流
output.close();
socket.close();
}
}
4.4.案例2:客户端发送消息,服务端回复消息
- 客户端
/**
* 客户端
* @author bruceliu
*/
public class TCP_ClientDemo2 {
public static void main(String[] args) {
// 1.面向连接:三次握手 创建一个Socket的对象,就相当于完成了三次握手,建立了一个安全的连接
Socket socket = null;
try {
socket = new Socket("127.0.0.1", 7777);
// 2.将需要发送的数据写入到网络中
OutputStream output = socket.getOutputStream();
// 3.写入
output.write("hello你好吗?".getBytes());
output.flush();
// 4.收取服务端发送来的消息
InputStream input = socket.getInputStream();
byte[] arr = new byte[1024];
int len = input.read(arr);
String message = new String(arr, 0, len);
System.out.println("来自服务端的回复:" + message);
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 服务端
/**
* 服务端
* @author bruceliu
*/
public class TCP_ServerDemo2 {
public static void main(String[] args) {
//1.实例化一个ServerSocket的对象
ServerSocket serverSocket=null;
try {
serverSocket = new ServerSocket(7777);
//2.监听,获取连接到的客户端
System.out.println("等待客户端的连接...");
//注意:在未连接成功之前,将一直处于阻塞状态
Socket socket = serverSocket.accept();
System.out.println("连接成功");
//3.获取网络到内存的一个输入流
InputStream input = socket.getInputStream();
//4.读取数据
byte[] arr = new byte[1024];
int len = input.read(arr);
String message = new String(arr, 0, len);
//5.组织信息
String ipString = socket.getInetAddress().getHostAddress();
int port = socket.getPort();
System.out.println(ipString +"说:" + message);
//6.服务端给客户端回复消息
OutputStream output = socket.getOutputStream();
output.write("你也好,好久不见了".getBytes());
output.flush();
} catch (IOException e) {
e.printStackTrace();
} finally{
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.5.小结
Java语言的基于套接字编程分为服务端编程和客户端编程,其通信模型如图所示:

4.6.案例3:客户端上传文件到服务端【以图片为例】
目前大多数服务器都会提供文件上传的功能,由于文件上传需要数据的安全性和完整性,很明显需要使用TCP协议来实现。接下来通过一个案例来实现图片上传的功能。如下图所示。原图:XXX.jpg
- 客户端
/**
* 文件上传客户端
* @author bruceliu
*/
public class TCP_ClientDemo3 {
public static void main(String[] args) {
//1.创建Socket对象
Socket socket=null;
try {
socket=new Socket("127.0.0.1",8888);
//2.输入流和输出流
//输入流:用来读取客户端磁盘上的图片文件
BufferedInputStream input = new BufferedInputStream(new FileInputStream(new File("D:/1.jpg")));
//输出流:将图片写入到网络中
BufferedOutputStream output = new BufferedOutputStream(socket.getOutputStream());
byte[] arr=new byte[1024];
int len=0;
while((len=input.read(arr))!=-1){
output.write(arr,0,len);
output.flush();
}
System.out.println("上传完毕!");
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 服务端
public class TCP_ServerDemo3 {
public static void main(String[] args) {
// 1,实例化一个ServerSocket对象
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(8888);
// 2.等待客户端的连接
System.out.println("等待连接...");
Socket socket = serverSocket.accept();
System.out.println("连接成功");
// 输入流:读取网络中的数据
BufferedInputStream input = new BufferedInputStream(socket.getInputStream());
// 输出流:将读取到的数据写入到服务端的磁盘
BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(new File("F:/上传.jpg")));
// 4.读取和写入
byte[] arr = new byte[1024];
int len = 0;
while ((len = input.read(arr)) != -1) {
output.write(arr, 0, len);
output.flush();
}
System.out.println("服务端:上传文件成功");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.7 案例4:多个客户端和一个服务端通信【多线程版本】
- 服务端
/**
* 服务端
*
* @author bruceliu
*/
public class TCP_ServerDemo4 {
public static void main(String[] args) {
// 1.创建服务端对象
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(9999);
System.out.println("服务端开始启动!");
// 2.通过循环,为不同的客户端进行性服务,创建线程
while (true) {
Socket socket = serverSocket.accept();
System.out.println("有客户端连接成功!");
ServerThread thread=new ServerThread(socket);
thread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerThread extends Thread {
private Socket socket;
public ServerThread(Socket socket) {
super();
this.socket = socket;
}
@Override
public void run() {
try {
OutputStream outputStream = socket.getOutputStream();
InputStream inputStream = socket.getInputStream();
// 3.从控制台获取数据
Scanner scanner = new Scanner(System.in);
// 4.进行循环的发送或接受消息
while (true) {
byte[] arr = new byte[1024];
int len = inputStream.read(arr);
String message = new String(arr, 0, len);
System.out.println("来自客户端的消息:"+message);
//回复服务器消息
System.out.println("服务器说:");
String message1 = scanner.nextLine();
outputStream.write(message1.getBytes());
outputStream.flush();
//约定
if(message.equals("886")||message.equals("bye")){
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 客户端
public class TCP_ClientDemo4 {
public static void main(String[] args) {
//1.构建Socket对象
Socket socket=null;
try {
socket=new Socket("127.0.0.1",9999);
//2.获取网络的输入流和输出流
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();
//3.从控制台获取数据
Scanner scanner=new Scanner(System.in);
//4.循环的发送和接受消息
while(true){
System.out.println("客户端对服务端说:");
String message = scanner.nextLine();
//4.1进行发送
outputStream.write(message.getBytes());
outputStream.flush();
//4.2 获取服务端的消息
byte[] arr=new byte[1024];
int len = inputStream.read(arr);
String reply=new String(arr,0,len);
System.out.println("收到服务器端的反馈:"+reply);
//4.3 约定
if(reply.equals("886") || reply.equals("bye")){
break;
}
}
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5.UDP通信
5.1. DatagramPacket
前面介绍了UDP是一种面向无连接的协议,因此,在通信时发送端和接收端不用建立连接。UDP通信的过程就像是货运公司在两个码头间发送货物一样。在码头发送和接收货物时都需要使用集装箱来装载货物,UDP通信也是一样,发送和接收的数据也需要使用“集装箱”进行打包,为此JDK中提供了一个DatagramPacket类,该类的实例对象就相当于一个集装箱,用于封装UDP通信中发送或者接收的数据。
想要创建一个DatagramPacket对象,首先需要了解一下它的构造方法。在创建发送端和接收端的DatagramPacket对象时,使用的构造方法有所不同,接收端的构造方法只需要接收一个字节数组来存放接收到的数据,而发送端的构造方法不但要接收存放了发送数据的字节数组,还需要指定发送端IP地址和端口号。
接下来根据API文档的内容,对DatagramPacket的构造方法进行逐一详细地讲解。

使用该构造方法在创建DatagramPacket对象时,指定了封装数据的字节数组和数据的大小,没有指定IP地址和端口号。很明显,这样的对象只能用于接收端,不能用于发送端。因为发送端一定要明确指出数据的目的地(ip地址和端口号),而接收端不需要明确知道数据的来源,只需要接收到数据即可。
使用该构造方法在创建DatagramPacket对象时,不仅指定了封装数据的字节数组和数据的大小,还指定了数据包的目标IP地址(addr)和端口号(port)。该对象通常用于发送端,因为在发送数据时必须指定接收端的IP地址和端口号,就好像发送货物的集装箱上面必须标明接收人的地址一样。
上面我们讲解了DatagramPacket的构造方法,接下来对DatagramPacket类中的常用方法进行详细地讲解,如下表所示。

5.2. DatagramSocket
DatagramPacket数据包的作用就如同是“集装箱”,可以将发送端或者接收端的数据封装起来。然而运输货物只有“集装箱”是不够的,还需要有码头。在程序中需要实现通信只有DatagramPacket数据包也同样不行,为此JDK中提供的一个DatagramSocket类。DatagramSocket类的作用就类似于码头,使用这个类的实例对象就可以发送和接收DatagramPacket数据包,发送数据的过程如下图所示。

在创建发送端和接收端的DatagramSocket对象时,使用的构造方法也有所不同,下面对DatagramSocket类中常用的构造方法进行讲解。

该构造方法用于创建发送端的DatagramSocket对象,在创建DatagramSocket对象时,并没有指定端口号,此时,系统会分配一个没有被其它网络程序所使用的端口号。

该构造方法既可用于创建接收端的DatagramSocket对象,又可以创建发送端的DatagramSocket对象,在创建接收端的DatagramSocket对象时,必须要指定一个端口号,这样就可以监听指定的端口。
上面我们讲解了DatagramSocket的构造方法,接下来对DatagramSocket类中的常用方法进行详细地讲解。

5.3.案例5:简单的UDP网络程序
- 发送端
/*
* 发送端
* 1,创建DatagramSocket对象
* 2,创建DatagramPacket对象,并封装数据
* 3,发送数据
* 4,释放流资源
*/
public class Sender {
public static void main(String[] args) throws Exception {
//1.创建DatagramSocket对象
DatagramSocket sendSockt=new DatagramSocket();
//2.创建DatagramPacket对象,并封装数据
byte[] buffer = "你好啊,UDP!!!".getBytes();
DatagramPacket dp=new DatagramPacket(buffer, buffer.length, InetAddress.getByName("127.0.0.1"), 12306);
//3.发送数据
sendSockt.send(dp);
//4.释放流资源
sendSockt.close();
System.out.println("发送完毕...");
}
}
- 接收端
/*
* UDP接收端
* 1,创建DatagramSocket对象
* 2,创建DatagramPacket对象
* 3,接收数据存储到DatagramPacket对象中
* 4,获取DatagramPacket对象的内容
* 5,释放流资源
*/
public class Recevier {
public static void main(String[] args) throws Exception {
//1.创建DatagramSocket,,并指定端口号
DatagramSocket receiveSocket=new DatagramSocket(12306);
System.out.println("接收者启动...");
//2.创建DatagramPacket对象, 创建一个空的仓库
byte[] buffer=new byte[1024];
DatagramPacket dp=new DatagramPacket(buffer, 1024);
//3.接收数据存储到DatagramPacket对象中
receiveSocket.receive(dp);
//4.获取DatagramPacket对象中的内容
//发送人:
InetAddress inetAddress = dp.getAddress();
//获取IP地址
String ip = inetAddress.getHostAddress();
//获取接收到的数据
byte[] data = dp.getData();
//获取数据的大小
int length = dp.getLength();
//显示接收到的数据
String dataStr = new String(data,0,length);
System.out.println("IP地址:"+ip+ ":数据是"+ dataStr);
//5,释放流资源
receiveSocket.close();
}
}
5.4案例6:给飞秋群发消息
/*
每个网络程序都有自己所处理的特定格式数据,如果接收到的数据不符合指定的格式,那么就会被当成垃圾数据丢弃。
飞Q接收的数据格式:
version:time :sender : ip: flag:content ;
版本号 时间 发送人 :IP: 发送的标识符(32): 真正的内容;
在udp协议中,有一个IP地址称作为广播地址,广播地址就是主机号为255地址。
给广播IP地址发送消息的时候,在同一个网络段的机器都可以接收 到信息。
192.168.6.255
*/
//使用udp协议给飞Q发送消息。
public class SendFeiQ {
public static void main(String[] args) throws Exception {
// 建立UDP的服务
DatagramSocket socket = new DatagramSocket();
// 准备数据,,把数据封装到数据包中
String data = getData("feiQ你好!");
DatagramPacket packet = new DatagramPacket(data.getBytes(), data.getBytes().length, InetAddress.getByName("192.168.6.255"), 2425);
//发送数据
socket.send(packet);
//关闭资源
socket.close();
}
// 把数据拼接成指定格式的数据
public static String getData(String content) {
StringBuilder sb = new StringBuilder();
sb.append("1.0:");
sb.append(System.currentTimeMillis() + ":");
sb.append("小王:");
//String hostAddress = InetAddress.getLocalHost().getHostAddress();
sb.append("192.168.6.1:");
sb.append("32:");
sb.append(content);
return sb.toString();
}
}
5.5案例7:使用UDP实现群聊程序
- 群聊发送端
/*
* 群聊的发送端
*/
public class ChatSender extends Thread{
@Override
public void run() {
try {
//1.建立UDP服务
DatagramSocket socket=new DatagramSocket();
//2.准备要封装的数据
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
String line=null;
DatagramPacket packet=null;
while((line=reader.readLine())!=null){
packet=new DatagramPacket(line.getBytes(),line.getBytes().length,InetAddress.getByName("192.168.6.255"),9090);
//把数据发送出去
socket.send(packet);
}
//关闭资源
socket.close();
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 群聊接收端
/**
* 群聊接收端
* @author bruceliu
*/
public class ChatReceiver extends Thread {
@Override
public void run() {
try {
//建立UDP服务,监听一个端口
DatagramSocket socket=new DatagramSocket(9090);
byte[] buf=new byte[1024];
DatagramPacket packet=new DatagramPacket(buf, buf.length);
boolean flag=true;
while(flag){
socket.receive(packet);
String ip = packet.getAddress().getHostAddress();
String message=new String(buf,0,packet.getLength());
System.out.println(message);
}
//关闭资源
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 启动群聊
public class TestChat {
public static void main(String[] args) {
ChatSender sender=new ChatSender();
sender.start();
ChatReceiver receiver=new ChatReceiver();
receiver.start();
}
}
6.作业
多个客户端和一个服务端通信【多线程版本】
实现群聊程序
实现把一个视频从一个PC机器传送到另外一个PC机器
7.面试题
简述网络编程需要的条件
简述UDP和TCP之间的区别
1万+



被折叠的 条评论
为什么被折叠?



