11.网络编程的学习总结

11.网络编程
1.什么是网络？网络模型？网络四要素？
网络：
在计算机领域中网络是信息传输，接收，共享的虚拟平台，通过它把各个点，面，体的联系到一起，从而实现这些资源的共享。
1.资源的共享
2.免费
21世纪的知识是不需要存储的，只需要学会检索就可以。

网络模型：
计算机网络是指由通信线路互相连接的许多自主工作的计算机构成的集合体，各个部件之间以何种规则进行通信，就是网络模型研究的问题。
网络模型一般是指OSI七层参考模型和TCP/IP四层参考模型。这两个模型在网络中应用最为广泛。
OSI七层参考模型

应用层\表示层\会话层\传输层\网络层\数据链路层\物理层

TCP/IP四层参考模型


应用层、传输层、IP层【网际层】、网路接口层【网络连入层】

网络四要素：
1.IP地址：
处于网络中的通信设备（电脑、手机、电视等），都会分配一个ip地址。
这些设备在通信之前，首先要通过通信设备的网卡接入到网络中。而这个网卡属于一个硬件，并且所有的网卡在出厂的时候，都有一个固定的网卡地址。并且这个网卡地址(MAC地址)全球唯一。

在命令提示行窗口中输入 ipconfig /all 可以查询ip（mac地址）相关的详细信息
【linux操作系统使用ifconfig可以查询ip（mac地址）相关的详细信息】

所有的网卡都有一个唯一的物理地址，但是这个地址非常的不好记。于是给每个网卡有分了一个逻辑（IP）地址。这个逻辑地址就是ip地址。通信的过程中，就可以根据这个逻辑地址找到处于网络中的这台设备。
IP地址也是对处于网络中的某个通信终端的标识。然后通信的另外一方，就可以根据这个ip地址找到对方，和对方进行通信。
由于IP地址也不容易记忆，因此又给每个ip绑定了一个名称。这个名称被称为（域名）。
https://www.baidu.com/[域名]—DNS服务器【域名解析服务器】----IP地址----网卡物理地址
通信设备只要连接到网络中，网络就会给这个设备分配一个IP地址。要进行网络通信，必须使用的IP地址。
通信设备能够联网，就必须要有网卡，每个网卡有一个物理地址（MAC地址，是唯一的）。
但是每个网卡在出厂的时候，就已经绑定死了一个IP地址，本地回环地址（127.0.0.1）。
网卡----唯一的地址【MAC地址】—不容易记忆----逻辑地址【IP地址】—不容易记忆—为每一个IP地址绑定一个名称—域名

2.域名解析
访问网络的时候，真正是需要通过IP地址访问。但是由于IP地址也不容易记忆。因此又给网络中的每个IP地址起名字，这个名称就叫做域名。
当我们在浏览器等可以访问网络的软件中输入了某个域名之后，需要将这个域名解析（解释）成对应的IP地址。这个过程就叫域名解析。
域名解析分成2步：
1、本地解析：
在我们的操作系统中，有一个hosts文件，当输入域名之后，首先会在hosts文件中找有没有当前的域名对应的IP地址，有就会使用这个IP地址。
C:\Windows\System32\drivers\etc\hosts
2、DNS服务器解析：
如果第一步解析失败了，会到网络中的DNS服务器上进行解析。DNS服务器中会将全球所有的域名和IP设置在其中。如果DNS服务器解析失败，说明当前的域名有问题的。

3.协议
协议：通信双方通信的时候需要遵守的通信的规则。

后期我们会遇到很多协议（高级协议，应用协议：http、ftp、https ）。
目前我们网络编程介绍的协议属于底层协议，所有的高级协议都是基于底层协议。
有ip可以找到网络中的那个设备，设备之间要通信，还要使用相同的通信协议。
我们目前所接触的是一些底层的协议，相对来说比较简单：

4.端口：
我们通过ip可以找到网络中具体那个通信终端的设备。而具体需要访问这个设备中的哪个资源（软件）信息，这时由于设备中运行的资源（软件）肯定很多，这时每个资源（软件）必须再给一个唯一的编号（标识）。通过这个标识才能保证我们可以没有错误的访问到指定ip地址的具体那个资源（软件）上。
端口：是一台设备（电脑、手机登）上某个应用程序的唯一标识。设备中运行的任何一个软件，只要启动，就肯定会有一个唯一的编号与其整个软件绑定。

端口从0开始到65535之间。0到1024之间的端口数字已经分配给本机的操作系统的应用程序占用，因此后期我们书写程序如果需要绑定端口，这时必须大于1024.
例如：九门九车
古代北京内城的九座城门，分别是东直门、朝阳门、西直门、阜成门、德胜门、安定门、崇文门、正阳门、宣武门。
朝阳门门专门是用来走粮车用的。
崇文门又叫哈德门，是专门走酒车的。
正阳门是专门给皇帝走的门。
宣武门走的是囚车。
阜城门专门走的是煤车
西直门走的是水车
德胜门专门是士兵出征走的门。
东直门一般走的就是砖车和木材车。
安定门归来的时候走的门。
《长安十二时辰》
2.InetAddress类？
IP对象
在网络中需要连接到另外一个的设备，然后才能进行通信。而处于网络中的任何一个设备都需要唯一的数字地址标识（IP）。
IP是网络中设备中存在的一类特殊的数据，那么Java针对IP整个特殊的数据，也给出了一个类，这个类保存在java.net包下
java.net
类 InetAddress 此类表示互联网协议 (IP) 地址。
这个封装IP地址的InetAddress类，在创建对象的时候，是需要静态方法来创建对象。
InetAddress类定义：
public class InetAddress implements java.io.Serializable
InetAddress类的构方法
InetAddress() {
}
通过这个构造方法我们认识到InetAddress类的构造方法是一个缺省修饰符修饰的
说明跨出InetAddress类所在的Java.net包就不能使用啦。
所以我们在自己的Java程序中是不能通过new+构造方法的方式创建出InetAddress类对象。
我们就需要使用下面这两个静态方法来得到InetAddress类对象

例如：
package com.click369.test1;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressTest1 {

	public static void main(String[] args) throws Exception {
		/*
		//得到本机的IP地址和主机名
		//1.得到包含有本机IP地址的InetAddress对象
		//static InetAddress	getLocalHost() 返回包含有本机IP地址的InetAddress对象。
		InetAddress benji=InetAddress.getLocalHost();
		//得到本机IP地址
		// String	getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
		String ip=benji.getHostAddress();
		//得到本机主机名
		//String	getHostName() 获取此 IP 地址的主机名。
		String name=benji.getHostName();
		System.out.println(name+"\t"+ip);
		*/
		
		//得到百度服务器的IP地址
		//1.得到包含有百度IP地址的InetAddress对象
		//static InetAddress	getByName(String host) 根据域名得到包含有该域名对应ip地址的InetAddress对象。
		InetAddress baiduip=InetAddress.getByName("www.baidu.com");
		//得到百度IP地址
		// String	getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
		String ip=baiduip.getHostAddress();
		System.out.println("www.baidu.com==="+ip);
		//http://www.baidu.com/
		//http://14.215.177.38/
	}
}

前面我们学习过域名的最后就是IP地址，那么就说明我们在浏览器中通过“http://www.baidu.com/index.html”访问的百度的首页，与我们通过百度的ip地址"http://14.215.177.38:80/index.html"访问的百度的首页应该是一样的
http://www.baidu.com/index.html

http://14.215.177.38/index.html

3.TCP协议？优缺点？基于TCP的通讯程序需要使用的类和常用方法？
TCP：传输控制协议。Transmission Control Protocol 传输控制协议
TCP协议在通信的时候，要求通信的双方先建立起连接（面向有连接的协议）。在建立连接的过程中需要经过三次握手才能完成连接的建立。

第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。
由于TCP协议需要经过三次握手，才能建立连接，因此TCP协议传输数据的时候比较安全，可靠。但是效率较低。
Tcp的优点：传输数据的时候比较安全，可靠。
Tcp的缺点：消耗大，效率较低。

基于TCP协议的通讯程序建立，需要两个端来控制【客户端/服务器端】
1.1客户端
java.net 类 Socket—类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
通过Socket类创建的对象就表示一个客户端对象

1.2服务器端
java.net 类 ServerSocket—此类实现服务器套接字
通过ServerSocket类创建的对象就表示一个服务器端对象
构造方法摘要
ServerSocket(int port) 创建绑定到特定端口的服务器套接字。

客户端的创建步骤：
1.得到客户端需要链接的服务器端的IP地址，得到端口号。
2.使用Socket(InetAddress address, int port) /Socket(String host, int port)创建客户端对象
3.通过创建客户端对象Socket对象调用getInputStream()/getOutputStream()创建收发数据的输入流/输出流对象。
4.使用创建收发数据的输入流/输出流对象,调用read/write方法完成数据的收发。
5.关闭流和客户端对象。
服务器端的创建步骤：
1、指定端口号，与客户端需要链接的服务器端的端口号相同。
2、使用ServerSocket(int port)创建服务器端对象。
3、使用创建服务器端对象调用accept()接收链接到服务器的客户端对象。
4、使用链接到服务器的客户端对象调用getInputStream()/getOutputStream()创建收发数据的输入流/输出流对象。
5、使用创建收发数据的输入流/输出流对象,调用read/write方法完成数据的收发。
6、关闭流和客户端对象与服务器端对象。

例如1:客户端向服务器端发送“hello，你好”，服务器端接收到客户端发来的“hello，你好”

package com.click369.test1;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * 客户端的创建步骤：
1.得到客户端需要链接的服务器端的IP地址，得到端口号。
2.使用Socket(InetAddress address, int port)	/Socket(String host, int port)创建客户端对象
3.通过创建客户端对象Socket对象调用getInputStream()/getOutputStream()创建收发数据的输入流/输出流对象。
4.使用创建收发数据的输入流/输出流对象,调用read/write方法完成数据的收发。
5.关闭流和客户端对象。
 * @author Administrator
 *
 */
public class TcpClient1 {
	public static void main(String[] args)throws Exception {
		//1.得到客户端需要链接的服务器端的IP地址，得到端口号。
		InetAddress serverip=InetAddress.getLocalHost();
		int serverport=3000;
		//2.使用Socket(InetAddress address, int port)创建客户端对象
		Socket  client=new Socket(serverip,serverport);
		//3.通过创建客户端对象Socket对象调用getOutputStream()创建收发数据的输入流/输出流对象。
		OutputStream  out=client.getOutputStream();
		System.out.println("请输入需要发送的数据:");
		BufferedReader  read=new BufferedReader(new InputStreamReader(System.in));
		String info=read.readLine();	
		//4.使用创建收发数据的输出流对象,调用write方法完成数据的发。
		out.write(info.getBytes());
		//5.关闭流和客户端对象。
		out.close();
		client.close();
	}
}

package com.click369.test1;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 服务器端的创建步骤：
1、指定端口号，与客户端需要链接的服务器端的端口号相同。
2、使用ServerSocket(int port)创建服务器端对象。
3、使用创建服务器端对象调用accept()接收链接到服务器的客户端对象。
4、使用链接到服务器的客户端对象调用getInputStream()/getOutputStream()创建收发数据的输入流/输出流对象。
5、使用创建收发数据的输入流/输出流对象,调用read/write方法完成数据的收发。
6、关闭流和客户端对象与服务器端对象。
 * @author Administrator
 *
 */
public class TcpServer1 {
	public static void main(String[] args)throws Exception {
		//1、指定端口号，与客户端需要链接的服务器端的端口号相同。
		int serverport=3000;
		//2、使用ServerSocket(int port)创建服务器端对象。
		ServerSocket  server=new ServerSocket(serverport);
		System.out.println("服务器已经开启等待客户端链接！！！！");
		//3.使用创建服务器端对象调用accept()接收链接到服务器的客户端对象。
		Socket  client=server.accept();
		//4.使用链接到服务器的客户端对象调用getInputStream()创建收发数据的输入流/输出流对象。
		InputStream  in=client.getInputStream();
		//5.使用创建收发数据的输入流对象,调用read方法完成数据的收。
		byte data[]=new byte[100];
		int len=in.read(data);
		String info=new String(data,0,len);
		System.out.println("服务器端接收到来自客户端的消息是=="+info);
		//6.关闭流和客户端对象与服务器端对象。
		in.close();
		client.close();
		server.close();
	}
}

先启动服务器端程序，再运行客户端程序

package com.click369.test2;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author Administrator
 *
 */
public class TcpClient1 {
	public static void main(String[] args)throws Exception {
		//1.得到客户端需要链接的服务器端的IP地址，得到端口号。
		InetAddress serverip=InetAddress.getLocalHost();
		int serverport=3000;
		//2.使用Socket(InetAddress address, int port)创建客户端对象
		Socket  client=new Socket(serverip,serverport);
		//3.通过创建客户端对象Socket对象调用getOutputStream()创建收发数据的输入流/输出流对象。
		OutputStream  out=client.getOutputStream();
		boolean flag=true;
		BufferedReader  read=new BufferedReader(new InputStreamReader(System.in));
		while(flag){
		System.out.println("请输入需要发送的数据:");
		String info=read.readLine();	
		if(info.equals("886")){
			flag=false;
		}
		//4.使用创建收发数据的输出流对象,调用write方法完成数据的发。
		out.write(info.getBytes());
		}
		//5.关闭流和客户端对象。
		out.close();
		client.close();
	}
}

package com.click369.test2;

import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 *
 * @author Administrator
 *
 */
public class TcpServer1 {
	public static void main(String[] args)throws Exception {
		//1、指定端口号，与客户端需要链接的服务器端的端口号相同。
		int serverport=3000;
		//2、使用ServerSocket(int port)创建服务器端对象。
		ServerSocket  server=new ServerSocket(serverport);
		System.out.println("服务器已经开启等待客户端链接！！！！");
		//3.使用创建服务器端对象调用accept()接收链接到服务器的客户端对象。
		Socket  client=server.accept();
		//4.使用链接到服务器的客户端对象调用getInputStream()创建收发数据的输入流/输出流对象。
		InputStream  in=client.getInputStream();
		boolean flag=true;
		byte data[]=new byte[100];
		while(flag){
		//5.使用创建收发数据的输入流对象,调用read方法完成数据的收。
		int len=in.read(data);
		String info=new String(data,0,len);
		if(info.equals("886")){
			flag=false;
		}
		System.out.println("服务器端接收到来自客户端的消息是=="+info);
		}
		//6.关闭流和客户端对象与服务器端对象。
		in.close();
		client.close();
		server.close();
	}
}

上面的实例只能完成客户端只负责发送数据，服务器负责接收数据
例如2:客户端持续向服务器端发送数据并且接收来自服务器返回的数据，服务器端持续接收到客户端发来的数据，并且向客户端发送响应数据。
例如2:客户端持续向服务器端发送数据，服务器端持续接收到客户端发来的数据

package com.click369.test3;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author Administrator
 *
 */
public class TcpClient1 {
	public static void main(String[] args)throws Exception {
		InetAddress serverip=InetAddress.getLocalHost();
		int serverport=3000;
		Socket  client=new Socket(serverip,serverport);
		OutputStream  out=client.getOutputStream();
		InputStream   in=client.getInputStream();
		boolean flag=true;
		BufferedReader  read=new BufferedReader(new InputStreamReader(System.in));
		byte data[]=new byte[100];
		while(flag){
		System.out.println("请输入需要发送的数据:");
		String info=read.readLine();	
		if(info.equals("886")){
			flag=false;
		}
		//4.使用创建收发数据的输出流对象,调用write方法完成数据的发。
		out.write(info.getBytes());
		
		//客户端读取服务器返回的数据
		int len=in.read(data);
		String msg=new String(data,0,len);
		System.out.println("客户端端接收到来自服务器端的消息是=="+msg);
		}
		//5.关闭流和客户端对象。
		in.close();
		out.close();
		client.close();
	}
}

package com.click369.test3;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
 *
 * @author Administrator
 *
 */
public class TcpServer1 {
	public static void main(String[] args)throws Exception {
		int serverport=3000;
		ServerSocket  server=new ServerSocket(serverport);
		System.out.println("服务器已经开启等待客户端链接！！！！");
		Socket  client=server.accept();
		InputStream  in=client.getInputStream();
		OutputStream  out=client.getOutputStream();
		boolean flag=true;
		byte data[]=new byte[100];
		while(flag){
		int len=in.read(data);
		String info=new String(data,0,len);
		if(info.equals("886")){
			flag=false;
		}
		System.out.println("服务器端接收到来自客户端的消息是=="+info);
		//服务器端向客户端发送响应数据
		info="server-"+info;
		out.write(info.getBytes());
		}
		out.close();
		in.close();
		client.close();
		server.close();
	}
}

上面实例只能完后一个服务器服务与一个客户端。
例如2:一台服务器端持续接收到多个客户端发来的数据，并且向多个客户端发送响应数据。客户端持续向服务器端发送数据并且接收来自服务器返回的数据。
【一台服务器服务于多个客户端】此时需要使用多线程技术

package com.click369.test4;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author Administrator
 *
 */
public class TcpClient1 {
	public static void main(String[] args)throws Exception {
		InetAddress serverip=InetAddress.getLocalHost();
		int serverport=3000;
		Socket  client=new Socket(serverip,serverport);
		OutputStream  out=client.getOutputStream();
		InputStream   in=client.getInputStream();
		boolean flag=true;
		BufferedReader  read=new BufferedReader(new InputStreamReader(System.in));
		byte data[]=new byte[100];
		while(flag){
		System.out.println("请输入需要发送的数据:");
		String info=read.readLine();	
		if(info.equals("886")){
			flag=false;
		}
		//4.使用创建收发数据的输出流对象,调用write方法完成数据的发。
		out.write(info.getBytes());
		//客户端读取服务器返回的数据
		int len=in.read(data);
		String msg=new String(data,0,len);
		System.out.println("客户端端接收到来自服务器端的消息是=="+msg);
		}
		//5.关闭流和客户端对象。
		in.close();
		out.close();
		client.close();
	}
}

package com.click369.test4;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
 * 服务器为每一个客户端提供的线程操作类
 * @author Administrator
 *
 */
public class ServerThread extends Thread{
     private Socket  client;
     public ServerThread(Socket  client){
    	 this.client=client;
     }
	
	@Override
	public void run() {
		try{
		InputStream  in=client.getInputStream();
		OutputStream  out=client.getOutputStream();
		boolean flag=true;
		byte data[]=new byte[100];
		while(flag){
		int len=in.read(data);
		String info=new String(data,0,len);
		if(info.equals("886")){
			flag=false;
		}
		System.out.println("服务器端接收到来自客户端的消息是=="+info);
		//服务器端向客户端发送响应数据
		info="server-"+info;
		out.write(info.getBytes());
		}
		out.close();
		in.close();
		client.close();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

package com.click369.test4;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author Administrator
 */
public class TcpServer1 {
	public static void main(String[] args)throws Exception {
		int serverport=3000;
		ServerSocket  server=new ServerSocket(serverport);
		System.out.println("服务器已经开启等待客户端链接！！！！");
		boolean flag=true;
		while(flag){
			Socket  client=server.accept();
			//为链接到服务器的每一个客户端单独开启一天线程
			ServerThread  serverThread=new ServerThread(client);
			serverThread.start();	
		}
		server.close();
	}
}

4.UDP协议？优缺点？基于UDP的通讯程序需要使用的类和常用方法？
UDP：用户数据报协议。UDP 是User Datagram Protocol的简称， 中文名是用户数据报协议。它是面向无连接的协议。发送一方，不用关心接受一方是否在线，能不能接受到数据，接受的数据正确与否。就直接发送数据。如果对方在就可以接受数据，如果对方不在，这时数据就自动的被丢弃。
UDP优点：消耗小，效率较高。
UDP缺点：协议不安全，不可靠，不能传输大数据。

基于UDP协议的通讯程序是部分客户端和服务器端的。
1.负责打包数据的java类
java.net 类 DatagramPacket–此类表示数据报包。
数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。


UDP协议发送数据的步骤：
1.通过DatagramPacket(byte[] buf, int length, InetAddress address, int port)将被发送的数据打包好。
2.通过DatagramSocket()创建一个发送数据包的对象。
3.使用发送数据包的对象调用send(DatagramPacket p)将打包好的数据发出。
4.关闭DatagramSocket。
UDP协议接收数据的步骤：
1.通过DatagramSocket(int port)创建一个接收数据包的对象。
2.通过DatagramPacket(byte[] buf, int length)构造一个空的数据包。
3.使用创建好的接收数据包的对象调用receive(DatagramPacket p)将接收到的数据包保存在空的数据包。
4.通过DatagramPacket提供的【拆包方法】getXXXX方法从接收数据包中取出需要的数据。
5.关闭DatagramSocket
例如：客户端【发送数据一方】发送数据，服务器【接收数据的一方】接收数据。
2.负责收发数据包的java类
java.net 类 DatagramSocket–此类表示用来发送和接收数据报包的套接字

package com.click369.test1;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
UDP协议发送数据的步骤：
1.通过DatagramPacket(byte[] buf, int length, InetAddress address, int port)将被发送的数据打包好。
2.通过DatagramSocket()创建一个发送数据包的对象。
3.使用发送数据包的对象调用send(DatagramPacket p)将打包好的数据发出。
4.关闭DatagramSocket。
 * @author Administrator
 *
 */
public class UdpClient1 {
	public static void main(String[] args) throws Exception{
		System.out.println("请输入需要发送的数据:");
		BufferedReader  read=new BufferedReader(new InputStreamReader(System.in));
		String info=read.readLine();
		byte buf[]=info.getBytes();
		int length=buf.length;
		InetAddress address=InetAddress.getLocalHost();
		int port=3000;
		//1.通过DatagramPacket(byte[] buf, int length, InetAddress address, int port)将被发送的数据打包好。
		DatagramPacket  sendpacket=new DatagramPacket(buf,length,address,port);
		//2.通过DatagramSocket()创建一个发送数据包的对象。
		DatagramSocket client=new DatagramSocket();
		//3.使用发送数据包的对象调用send(DatagramPacket p)将打包好的数据发出。
		client.send(sendpacket);
		//4.关闭DatagramSocket。
		client.close();
	}
}

package com.click369.test1;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * UDP协议接收数据的步骤：
1.通过DatagramSocket(int port)创建一个接收数据包的对象。
2.通过DatagramPacket(byte[] buf, int length)构造一个空的数据包。
3.使用创建好的接收数据包的对象调用receive(DatagramPacket p)将接收到的数据包保存在空的数据包。
4.通过DatagramPacket提供的【拆包方法】getXXXX方法从接收数据包中取出需要的数据。
5.关闭DatagramSocket
 * @author Administrator
 *
 */
public class UdpServer1 {

	public static void main(String[] args)throws Exception{
		//1.通过DatagramSocket(int port)创建一个接收数据包的对象。
		DatagramSocket server=new DatagramSocket(3000);
		byte buf[]=new byte[100];
		int length=buf.length;
        //2.通过DatagramPacket(byte[] buf, int length)构造一个空的数据包。
		DatagramPacket receivepacket=new DatagramPacket(buf,length);
		//3.使用创建好的接收数据包的对象调用receive(DatagramPacket p)将接收到的数据包保存在空的数据包。
		server.receive(receivepacket);
		//4.通过DatagramPacket提供的【拆包方法】getXXXX方法从接收数据包中取出需要的数据。
		byte data[]=receivepacket.getData();
		int datalength=receivepacket.getLength();
		String clientip=receivepacket.getAddress().getHostAddress();
		int clientport=receivepacket.getPort();
		String info=new String(data,0,datalength);
		System.out.println("服务器端从客户端接收的数据是:"+info);
		//5.关闭DatagramSocket
		server.close();
	}
}

例如：客户端【发送数据一方】持续发送数据，服务器【接收数据的一方】持续接收数据。

package com.click369.test1;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
UDP协议发送数据的步骤：
1.通过DatagramPacket(byte[] buf, int length, InetAddress address, int port)将被发送的数据打包好。
2.通过DatagramSocket()创建一个发送数据包的对象。
3.使用发送数据包的对象调用send(DatagramPacket p)将打包好的数据发出。
4.关闭DatagramSocket。
 * @author Administrator
 *
 */
public class UdpClient1 {
	public static void main(String[] args) throws Exception{
		boolean flag=true;
		BufferedReader  read=new BufferedReader(new InputStreamReader(System.in));
		InetAddress address=InetAddress.getLocalHost();
		int port=3000;
		DatagramSocket client=new DatagramSocket();
		while(flag){
		System.out.println("请输入需要发送的数据:");
		String info=read.readLine();
		byte buf[]=info.getBytes();
		int length=buf.length;
		DatagramPacket  sendpacket=new DatagramPacket(buf,length,address,port);
		client.send(sendpacket);
		}
		//4.关闭DatagramSocket。
		client.close();
	}

}

package com.click369.test1;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * UDP协议接收数据的步骤：
1.通过DatagramSocket(int port)创建一个接收数据包的对象。
2.通过DatagramPacket(byte[] buf, int length)构造一个空的数据包。
3.使用创建好的接收数据包的对象调用receive(DatagramPacket p)将接收到的数据包保存在空的数据包。
4.通过DatagramPacket提供的【拆包方法】getXXXX方法从接收数据包中取出需要的数据。
5.关闭DatagramSocket
 * @author Administrator
 *
 */
public class UdpServer1 {

	public static void main(String[] args)throws Exception{
		boolean flag=true;
		DatagramSocket server=new DatagramSocket(3000);
		byte buf[]=new byte[100];
		int length=buf.length;
		DatagramPacket receivepacket=new DatagramPacket(buf,length);
		while(flag){
		//3.使用创建好的接收数据包的对象调用receive(DatagramPacket p)将接收到的数据包保存在空的数据包。
		server.receive(receivepacket);
		//4.通过DatagramPacket提供的【拆包方法】getXXXX方法从接收数据包中取出需要的数据。
		byte data[]=receivepacket.getData();
		int datalength=receivepacket.getLength();
		String clientip=receivepacket.getAddress().getHostAddress();
		int clientport=receivepacket.getPort();
		String info=new String(data,0,datalength);
		System.out.println("服务器端从客户端接收的数据是:"+info);
		}
		//5.关闭DatagramSocket
		server.close();
	}
}

5.URL与URI的区别？
首先我们要弄清楚一件事：URL和URN都是URI的子集。
换言之，URL和URN都是URI，但是URI不一定是URL或者URN。
如果是一个人，我们会想到他的姓名和住址。
URL类似于住址，它告诉你一种寻找目标的方式(在这个例子中，是通过街道地址找到一个人)。要知道，上述定义同时也是一个URI。
相对地，我们可以把一个人的名字看作是URN;因此可以用URN来唯一标识一个实体。由于可能存在同名(姓氏也相同)的情况，所以更准确地说，人名这个例子并不是十分恰当。更为恰当的是书籍的ISBN码和产品在系统内的序列号，尽管没有告诉你用什么方式或者到什么地方去找到目标，但是你有足够的信息来检索到它。引自这篇文章:
所有的URN都遵循如下语法(引号内的短语是必须的)：
< URN > ::= “urn:” < NID > “:” < NSS >
其中NID是命名空间标识符，NSS是标识命名空间的特定字符串。
一个用于理解这三者的例子
我们来看一下上述概念如何应用于与我们息息相关的互联网。
再次引用Wikipedia ，这些引文给出的解释，比上面人员地址的例子更为专业：
关于URL：
URL是URI的一种，不仅标识了Web 资源，还指定了操作或者获取方式，同时指出了主要访问机制和网络位置。
关于URN：
URN是URI的一种，用特定命名空间的名字标识资源。使用URN可以在不知道其网络位置及访问方式的情况下讨论资源。
现在，如果到Web上去看一下，你会找出很多例子，这比其他东西更容易让人困惑。我只展示一个例子，非常简单清楚地告诉你在互联网中URI 、URL和URN之间的不同。
我们一起来看下面这个虚构的例子。这是一个URI：
http://bitpoetry.io/posts/hello.html#intro
我们开始分析
http://
是定义如何访问资源的方式。另外
bitpoetry.io/posts/hello.html
是资源存放的位置，那么，在这个例子中，
#intro
是资源。
URL是URI的一个子集，告诉我们访问网络位置的方式。在我们的例子中，URL应该如下所示：
http://bitpoetry.io/posts/hello.html
URN是URI的子集，包括名字(给定的命名空间内)，但是不包括访问方式，如下所示：
bitpoetry.io/posts/hello.html#intro
就是这样。现在你应该能够辨别出URL和URN之间的不同。
如果你忘记了这篇文章的内容，至少要记住一件事：URI可以被分为URL、URN或两者的组合。如果你一直使用URI这个术语，就不会有错。