019.java_网络编程

最新推荐文章于 2023-02-14 18:15:12 发布

打字员小张

最新推荐文章于 2023-02-14 18:15:12 发布

阅读量210

点赞数

本文链接：https://blog.csdn.net/zzq1824837536/article/details/80143040

版权

TCP/IP（Transmission Control Protocol/Internet Protocol）:传输控制协议/网络协议。主要有TCP和UDP两种协议，代表不同的网络数据传输方式。

TCP（打电话）：面向连接的，字节流无差错的传输协议。数据的发送方和接收方之间必须建立连接。

UDP（User Datagram Protocol）用户数据报协议（发短信）：不可靠的无连接的数据传输协议。数据传输大小限制为64K以内。

Java与网络

InetAddress类用来表示互联网地址，它封装了IP地址和域名相关的操作方法。

该类没有构造方法，都是通过该类的静态方法创建实例对象。

static InetAddress[] getAllByName(String host)	在给定主机名的情况下，根据系统上配置的名称服务返回其IP数组所组成的数组
static InetAddress getByAddress(byte[] addr)	在给定原始IP地址的情况下，返回InetAddress对象
static InetAddress getByAddress(String host,byte[] addr)	根据提供的主机名和IP地址创建InetAddress对象
static InetAddress getByName(String host)	在给定主机名的情况下确定主机的IP地址
static InetAddress getLocalHost()	返回本地主机地址

import java.net.*;
public class InetAddressTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			InetAddress inet1=InetAddress.getByName("www.baidu.com");//通过指定域名创建InetAddress对象
			System.out.println(inet1);
			InetAddress inet2=InetAddress.getByName("172.168.1.0");//通过指定IP创建InetAddress对象
			System.out.println(inet2);
			
			InetAddress inet3=InetAddress.getLocalHost();//获得本机InetAddress对象
			String host=inet3.getHostName();//获取本机名
			String ip=inet3.getHostAddress();//获取ip地址
			System.out.println("本机InetAddress:"+inet3+",host:"+host+",ip:"+ip);
			
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

运行结果：

www.baidu.com/180.97.33.107
/172.168.1.0
本机InetAddress:DESKTOP-UCRN4F3/172.23.55.3,host:DESKTOP-UCRN4F3,ip:172.23.55.3

URL

URL(Uniform Resource Location)统一资源标识符，用于指定构成Web资源的字符串的各个不同部分。

java.net.URL类来代表资源的URL串。

构造方法：

URL（String spec）:根据URL字符串创建URL对象。

URL（URL context,String spec）：通过在指定的上下文中对给定的spec进行解析构建URL对象

常用方法：

public String getProtocol()	获取该URL的协议名
public String getost()	获取该URL的主机名
public String getPort()	获取该URL的端口号；若未设置，返回-1
public String getPath()	获取该URL的路径部分
public String getFile()	获取该URL的文件名
public String getRef()	获取该URL的锚点名，没有就是返回null
public String getQuery()	获取该URL的查询部分
public final InputStream openConnection() throws IOException	返回一个InputStream对象，它表示到URL所引用的远程对象的连接
public final InputStream openStream() throws IOException	打开到此URL的连接并返回一个用于从该连接读入的InputSream。
public final Object getContent() throws IOException	获取此URL的内容

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

public class URLTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		URL url;
		BufferedReader in=null;
		try {
			url=new URL("https://www.cnblogs.com/Sunnor/p/4699338.html");
			System.out.println("协议名："+url.getProtocol());
			System.out.println("主机号："+url.getHost());
			System.out.println("端口号:"+url.getPort());
			System.out.println("路径："+url.getPath());
			System.out.println("文件名:"+url.getFile());
			
	in=new BufferedReader(new InputStreamReader(url.openStream()));//字节输入流→转换流（字节变字符）→缓冲流
			System.out.println("URL信息:");
			for(String line;(line=in.readLine())!=null;){
				System.out.println(line);
			}
			
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

运行结果：

协议名：https
主机号：www.cnblogs.com
端口号:-1
路径：/Sunnor/p/4699338.html
文件名:/Sunnor/p/4699338.html
URL信息:

<!DOCTYPE html>
<html lang="zh-cn">
<head>
<meta charset="utf-8"/>
...

URLConnection类

URLConnection类是一个抽象类（抽象方法：没有方法主体的方法声明，用abstract关键字来声明；包含抽象方法的类为抽象类，抽象类可以有具体属性，构造器和具体方法。抽象类主要用来被继承。如果子类继承抽象类，没有覆盖父类的所有抽象方法，那子类也要声明为抽象类。）,代表应用程序和URL之间的通信链接。此类的实例用于读取和写入URL所引用的资源。

URLConnection允许使用POST、GET或其它HTTP请求方式将请求数据发送到服务器。

使用URLConnection对象的一般步骤如下：

1.创建URL对象

2.通过URL对象的openConnection()方法创建URLConnection对象

3.通过URLConnection对象提供的方法可以设置参数和一般请求属性。

常用的请求属性设置方法：

public void setRequestProperty(String key,String value)	设置指定的请求关键字对应的值
public void setDoInput(boolean doinput)	设置是否使用URL连接进行输入。默认值为true
public void setDoOutput(boolean dooutput)	设置是否使用URL连接进行输出。默认为false，如果设置为true，就可以获取一个字节输出流，用于将数据发给服务器
public void setUseCaches(boolean usecaches)	设置此连接是否使用任何可用的缓存，默认值为true

4.调用URLConnection对象的connect方法连接到远程资源

5.连接服务器后，就是可以查询头部信息了。查询头部信息的常用方法：

public String getHeaderField(String name)	返回指定头字段的值
public Map<String,List<String>>getHeaderFields()	返回头字段不可修改的Map
public String getContentType()	返回content-type头字段的值
public String getContentEncoding	返回content-encoding头字段的值
public int getContentLength()	返回content-length头字段的值
public long getLastModified()	返回last-modified头字段的值

6.获取输入流访问资源数据（getInputStream）/获取输出流写出数据（getOutputStream）。

使用URLConnection类获取Web服务器的数据

public class URLConnectionTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		URL url=null;
		BufferedReader in=null;
		try {
			url=new URL("https://blog.csdn.net/zzq1824837536");//创建URL对象
			URLConnection conn=url.openConnection();//创建连接对象
			conn.connect();//连接到指定资源
			
			//获取响应的头信息Map进行遍历
			Map<String,List<String>> headerMap=conn.getHeaderFields();
			for(Map.Entry<String, List<String>>entry:headerMap.entrySet()){
				String key=entry.getKey();
				List<String>values=entry.getValue();
				StringBuilder sb=new StringBuilder();//大小可变字符串
				int size=(values==null)?0:values.size();
				for(int i=0;i<size;i++){
					if(i>0){
						sb.append(",");//将指定字符串追加到该字符串
					}else{
						sb.append(values.get(i));
					}					
				}
				System.out.println(key+":"+sb.toString());	
			}
			System.out.println("----------");
			//获取输入流，从中读取资源数据
			in=new BufferedReader(new InputStreamReader(conn.getInputStream()));
			for(String line=null;(line=in.readLine())!=null;){
				System.out.println(line);
			}
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

运行结果：

Keep-Alive:timeout=20
Transfer-Encoding:chunked
null:HTTP/1.1 200 OK
Strict-Transport-Security:max-age= 31536000
Server:openresty
Connection:keep-alive
Vary:Accept-Encoding,
Set-Cookie:dc_session_id=10_1524998421731.910500; Expires=Thu, 01 Jan 2025 00:00:00 GMT; Path=/; Domain=.csdn.net;,
Date:Sun, 29 Apr 2018 10:40:21 GMT
Content-Type:text/html; charset=UTF-8
----------
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <link rel="canonical" href="https://blog.csdn.net/zzq1824837536"/> 
    <meta http-equiv="content-type" content="text/html; charset=utf-8">
...

向Web服务器发送表单数据并接收服务器返回的响应数据。

Properties类

Properties类是Hashtable类的子类，也叫属性集。它是一个特殊的映射结构，表现在：

1.键和值都是字符串，所以它不是泛型类，不支持泛型操作。

2.属性集的键值可以保存到一个文件，也可以从一个文件中加载。

setProperty(String key,String value)和getProperty(String key)方法存取元素。

import java.io.*;
import java.net.*;
import java.util.*;

public class HTTPRequestTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Properties props=new Properties();
		props.setProperty("Content-type","application/x-www-from-urlencoded");
		props.setProperty("t", "blog");//请求参数“t=blog”,表示查询博客中的文章
		props.setProperty("q", "java");//请求参数“q=java”,表示要查询包含java关键字的文章
		props.setProperty("page", "2");//请求参数“page=2”，表示查询第二页的内容
		try {
			SendPostRequest(new URL("https://blog.csdn.net/zzq1824837536"),props);
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private static void SendPostRequest(URL url, Properties props) {
		// TODO Auto-generated method stub
		try {
			//post请求的参数名值对放在HTTP正文内，需要使用URL连接进行输出
			HttpURLConnection conn=(HttpURLConnection) url.openConnection();
			conn.setDoOutput(true);
			
			//把请求参数添加到连接对象中。请求参数的形式为“名=值&名2=值2”
			PrintWriter out=new PrintWriter(new OutputStreamWriter(conn.getOutputStream()),true);
			for(Iterator<Object> it=props.keySet().iterator();it.hasNext();){
				String key=(String) it.next();
				String value=props.getProperty(key);
				out.write(key);
				out.write("=");
				out.write(value);
				if(it.hasNext()){
					out.write("&");
				}
			}
			out.close();
			conn.connect();
			
			//获取输入流遍历读取数据
			BufferedReader br=new BufferedReader(new InputStreamReader(conn.getInputStream()));
			for(String line=null;(line=br.readLine())!=null;){
				System.out.println(line);
			}
			br.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

URLEncoder类和 URLDecoder类

URL出现的字符必须是ASCⅡ字符集中的字符（大小写英文字母（a~z,A~Z），数字（0-9），标识符（"."，"-"，"*"，"_"）），其它字符需要编码机制转为字节形式，每个字节用一个包含3个字符的字符串“%xy”表示，其中xy为该字节的两位十六进制表示形式。推荐编码UTF-8。

java.net.URLEncoder类负责字符编码 public static String encode(String s，String enc) throws UnSupportedEncodingException；

java.net.URLDecoder类负责解码成原字符串。 public satatic String decode(String s,String enc)hrows UnSupportedEncodingException

import java.io.*;
import java.net.*;

public class URLEncoderTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer sb=new StringBuffer("http:/www.baidu.com/s?wd=");
		try {
			sb.append(URLEncoder.encode("java技术", "gb2312"));
			sb.append("&pn=70");
			System.out.println("url:"+sb);
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		URLConnection conn=null;
		BufferedReader in=null;
		try {
			conn=new URL(sb.toString()).openConnection();
			in=new BufferedReader(new InputStreamReader(conn.getInputStream(), "gb2312"));
			for(String str=null;(str=in.readLine())!=null;){
				System.out.println(str);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}

}

运行结果：

url:http:/www.baidu.com/s?wd=java%BC%BC%CA%F5&pn=70
...

套接字（Socket）

套接字是一个通信断点，是应用程序用来在网络上发送或接收数据包的对象。

流式套接字：确保数据以正常的顺序无重复地被送达。TCP协议

数据报套接字：不能确保数据送达，也无法确保发送顺序。UDP协议

基于TCP协议的网络编程

java.net提供三个类支持TCP协议的网络编程，InetAddress、Socket、ServerSocket

InetAddress类用来表示互联网地址，它封装了IP地址和域名相关的操作方法。

Socket类叫做客户端套接字，用于执行客户端的TCP操作，通过构造方法获取客户端Socket实例。

Socket构造方法
Socket(String host,int port)	创建一个流套接字并将其连接到指定主机上的指定端口号
Socket(InetAddress address,int port)	创建一个流套接字并将其连接到指定IP上的指定端口号

常用方法
public InetAddress getInetAddress()	获取此套接字连接到的远程IP地址；如果未连接，返回null
public int getPort()	返回此套接字连接到的远程端口；未连接，返回0
public int getLocalPort()	返回此套接字绑定到的本地端口号；若未绑定，返回-1
public InetAddress getLocalAddress()	获取套接字绑定的本地地址；如果尚未绑定套接字，则返回InetAddress.anyLocalAddress()
public InputStream getInputStream()throws IOException	返回此套接字的输入流。如果关闭该输入流，套接字也关闭
public OutputStream getOutputStream()throws IOException	返回此套接字的输出流。如果关闭该输出流，套接字也关闭
public void close()throws IOException	关闭此套接字

ServerSocket类

ServerSocket叫做服务器套接字，每个ServerSocket运行在服务器上特定的端口，监听着这个端口的TCP连接。当客户端Socket试图与服务器端口建立连接时被激活。

构造方法获得服务器端Socket
ServerSocket()	创建非绑定服务器套接字
ServerSocket(int port)	创建绑定到特定端口的服务器套接字
ServerSocket(int port,int backlog)	利用指定backlog创建服务器套接字并将其绑定到指定端口
ServerSocket(int port,int backlog,InetAddress bindAddr)	使用指定的端口、侦听backlog和要绑定到的本地IP创建服务器

常用方法
Socket accept()	监听并接受到此服务器套接字的连接，返回代表连接上的客户端的套接字
void close()	关闭服务器套接字

TCP客户端编程步骤

1.建立网络连接，指定服务器的IP号和端口号。Socket si=new Socket("172.168.2.3","4651")；

2.交换数据。通过Socket对象获取的输出流，取得来自服务器端的数据。OutputStream out=si.getOutputStream;通过Socket对象获取的输入流，将数据传到客户端。InputStream in=si.getInputStream;

3.关闭网络连接。s.close();

TCP服务器端编程步骤

1.监听端口。建立ServerSocket对象，并指定所要使用的端口。ServerSocket ss=new ServerSocket(port#);

2.获得连接。等待直到接收到客户端的连接信息，然后建立连接。Socket s=ss.accept();

3.交换数据。接收客户端发送过来的数据，然后进行逻辑处理，最后将处理结果返回客户端。InputStream in=s.getInpuStream;

OutputStream os=s.getOutputStream;

4.关闭连接。s.close()

import java.io.*;
import java.net.*;
public class TCPClientTest {
//客户端连接服务器后，向服务器发送一串字符
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Socket s1=null;
		try {
			//127.0.0.1是个专用地址，代表本地计算机
			s1=new Socket("127.0.0.1",5432);//创建一个流式套接字并连接到本机的5432端口
			//获取此套接字的输出流并包装成自动刷新的打印流
			PrintWriter out=new PrintWriter(new OutputStreamWriter(s1.getOutputStream()), true);
			String ip=s1.getInetAddress().getHostAddress();//
			int port=s1.getPort();
			out.println("【客户端"+ip+":"+port+"】你好");
			BufferedReader in=new BufferedReader(new InputStreamReader(s1.getInputStream()));
			String str=in.readLine();
			System.out.println(str);
			
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			if(null!=s1){
				try {
					s1.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

import java.io.*;
import java.net.*;
public class TCPServerTest {
//接收客户端连接，并接受客户端发送过来的字符串，把字符串输出到命令行，然后向客户端返回一个响应字符串
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ServerSocket serverSocket=null;
		Socket s=null;
		try {
			serverSocket=new ServerSocket(5432);//创建服务器端套接字
			s=serverSocket.accept();//监听并接收客户端的连接
			//从套接字中获取输入流并包装
			BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
			String str=in.readLine();
			System.out.println(str);
			
			//获取此嵌套字的输出流并包装成自动刷新的打印流
			PrintWriter out=new PrintWriter(new OutputStreamWriter(s.getOutputStream()),true);
			out.println("服务器收到信息");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			if(null!=s){
				try {
					s.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(null!=serverSocket){
				try {
					serverSocket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

实现客户端与服务器通过命令行进行聊天

接收消息的线程：

import java.io.*;
import java.net.*;
public class ReceiveMsgThread implements Runnable{
	private Socket s;
	public ReceiveMsgThread(Socket s){
		this.s=s;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		BufferedReader in=null;
		try {
			in=new BufferedReader(new InputStreamReader(s.getInputStream()));//获取输入流并包装
			while(true){//用死循环等待对方发送数据
				System.out.println(in.readLine());//读取一行字符
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

客户端：

import java.io.*;
import java.net.*;
public class TcpChatClient {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Socket s=null;
		try {
			s=new Socket("127.0.0.1", 5432);//监听并接收客户端的连接
			new Thread(new ReceiveMsgThread(s)).start();//启动专门监听对方发送消息的线程
			PrintWriter out=new PrintWriter(s.getOutputStream(),true);//获取此套接字的输出流并包装成自动刷新的打印流
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//将标准输入流包装成缓冲输入流
			while(true){
				out.println(br.readLine());
			}
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			if(null!=s){
				try {
					s.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

服务器：

import java.io.*;
import java.net.*;
public class TCPChatServer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ServerSocket serverSocket=null;
		Socket s=null;
		try {
			serverSocket=new ServerSocket(5432);//创建服务器端套接字
			s=serverSocket.accept();//监听并接收服务器的连接
			new Thread(new ReceiveMsgThread(s)).start();//启动专门监听客户端发消息的线程
			PrintWriter out=new PrintWriter(new OutputStreamWriter(s.getOutputStream()), true);
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			while(true){
				out.println(br.readLine());
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			if(null!=s){
				try {
					s.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(null!=serverSocket){
				try {
					serverSocket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}

}

基于UDP协议的网络编程

java.net包中提供了DatagramSocket和DatagramPacket类，用于支持UDP协议的网络编程。

DatagramPacket类的实例为UDP终端交换的数据报文的信息。发送信息时，将DatagramPacket实例传给DatagramSocket类的send()方法；接收信息时，先创建一个DatagramPacket实例，然后把实例传给DatagramSocket的receive()方法作为参数。

DatagramPacket构造方法
DatagramPacket(byte[] buf,int length)	构造DatagramPacket，接收长度为length的数据包
DatagramPacket(byte[] buf,int offset,int length)	构造DatagramPacket，接收长度为length的数据，在缓冲区设置了偏移量
DatagramPacket(byte[] buf,int length,InetAddresss address,int port)	构造DatagramPacket数据包，用来将长度为length的包发送到指定主机的指定端口号
DatagramPacket(byte[] buf,int offset,int length,InetAddress address,int port)	构造DatagramPacket数据包，用来将长度为length偏移量为offset的包发送到指定主机的指定端口上

DatagramPacket数据处理方法
public int getOffset()	返回发送或接收的数据存在缓冲区时的偏移量
public byte[] getData()	返回与数据报文相关联的字节数组
public void setData(byte[] buf)	指定一个字节数组作为该数据报文的数据部分

DatagramSocket类用来创建发送和接收数据报包的套接字。

DatagramSocket构造方法
DatagramSocket()	构造数据报套接字并将其绑定到本地主机上的任何可用端口
DatagramSocket(int port)	创建数据报套接字并将其绑定到本地主机上的指定接口

DatagramSocket方法
void send(DatagramPacket dp)throws IOException	发送数据报包
void receive(DatagramPacket dp)throws IOException	接收数据报包

一个DatagramPacket最薄传输65507字节，使用一个65600字节的数据报包总是安全的。

一对一通信方式：单播。

import java.io.IOException;
import java.net.*;
public class UDPSender {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str="通过UDP发送的中文数据";
		byte[]b=str.getBytes();//将字符串存储到字节数组
		DatagramPacket dg=null;
		DatagramSocket socket=null;
		try {
			//创建要发送的数据包：指定发送内容，长度，目的地IP和端口号
			dg=new DatagramPacket(b, b.length, InetAddress.getByName("127.0.0.1"), 6789);
			//创建发送的scoket
			socket=new DatagramSocket(5555);
			socket.send(dg);
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if(null!=socket){
				socket.close();
			}
		}
	}

}

import java.io.IOException;
import java.net.*;
public class UDPReceiver {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		byte[]b=new byte[65600];//用来接收长度为length的数据包
		DatagramPacket dg=null;
		DatagramSocket socket=null;
		dg=new DatagramPacket(b, b.length);
		try {
			socket=new DatagramSocket(6789);
			while(true){//循环接收数据
				socket.receive(dg);
				//使用getData(),getOffset(),getLength()方法访问接收到的数据
				String str=new String(dg.getData(),dg.getOffset(),dg.getLength());//将接收到的字节数组消息转为字符串的构造方法
				System.out.println("收到的信息:"+str);
			}
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if(null!=socket){
				socket.close();
			}
		}
	}

}

一对多的网络服务：广播（Broadcast）和多播（Multicast）

广播：与单播的区别是，广播发送端使用的是广播地址（255.255.255.255）。IPv4的本地广播地址（255.255.255.255）将消息发送在统一广播网络的每个主机。

多播：多播应用程序主要通过MulticastSocket实例通信，它是DatagramSocket的子类。IPv4的多播地址范围为：224.0.0.0~239.255.255.255，把数据报包的对象中的IP地址改为多播地址，把套接字改用MulticastSocket。

import java.io.IOException;
import java.net.*;
public class UDPSender {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str="通过UDP发送的中文数据";
		byte[]b=str.getBytes();//将字符串存储到字节数组
		DatagramPacket dg=null;
		DatagramSocket socket=null;
		try {
			//创建要发送的数据包：指定发送内容，长度，目的地IP和端口号
			dg=new DatagramPacket(b, b.length, InetAddress.getByName("127.0.0.1"), 6799);
			//创建发送的scoket
			socket=new DatagramSocket(5555);
			socket.send(dg);
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if(null!=socket){
				socket.close();
			}
		}
	}

}

import java.io.IOException;
import java.net.*;
public class UDPReceiver {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		byte[]b=new byte[65600];//用来接收长度为length的数据包
		DatagramPacket dg=null;
		DatagramSocket socket=null;
		dg=new DatagramPacket(b, b.length);
		try {
			socket=new DatagramSocket(6799);
			while(true){//循环接收数据
				socket.receive(dg);
				//使用getData(),getOffset(),getLength()方法访问接收到的数据
				String str=new String(dg.getData(),dg.getOffset(),dg.getLength());//将接收到的字节数组消息转为字符串的构造方法
				System.out.println("收到的信息:"+str);
			}
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if(null!=socket){
				socket.close();
			}
		}
	}

}

打字员小张

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
019.java_网络编程

TCP/IP（Transmission Control Protocol/Internet Protocol）:传输控制协议/网络协议。主要有TCP和UDP两种协议，代表不同的网络数据传输方式。TCP（打电话）：面向连接的，字节流无差错的传输协议。数据的发送方和接收方之间必须建立连接。UDP（User Datagram Protocol）用户数据报协议（发短信）：不可靠的无连接的数据传输协议。数据...
复制链接

扫一扫