Java NIO实例-DatagramChannel实现UDP协议传输

最新推荐文章于 2024-09-21 19:33:42 发布
最新推荐文章于 2024-09-21 19:33:42 发布
阅读量3.7w 收藏 12
点赞数 2
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foart/article/details/47608475
版权

自己的学习笔记（日后发现问题会修正）

在网上找到一些关于udp协议，学习后写了一个实例用于学习之用。


根据别人的经验，总结了以下几点内容：

TCP与UDP效率比较：

    TCP协议适用于对效率要求相对低，但对准确性要求相对高的场景下，或者是有一种连接概念的场景下；而UDP协议适用于对效率要求相对高，对准确性要求相对低的场景。

TCP与UDP应用场景：

    TCP可以用于网络数据库，分布式高精度计算系统的数据传输；UDP可以用于服务系统内部之间的数据传输，因为数据可能比较多，内部系统局域网内的丢包错包率又很低，即便丢包，顶多是操作无效，这种情况下，UDP经常被使用。


网上收集的资料：

TCP字节流与UDP数据报：http://network.51cto.com/art/201310/413326.htm

TCP和UDP的区别（转）：http://www.cnblogs.com/bizhu/archive/2012/05/12/2497493.html

java nio对OP_WRITE的处理解决网速慢的连接：http://blog.sina.com.cn/s/blog_783ede0301013g5n.html

测试工具：

使用clumsy工具，可以模拟网络丢包、网络延迟等恶劣环境

下载地址：http://download.csdn.net/detail/foart/8999423


服务端

package cn;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author 
 * @date 2015-8-7 上午11:36:25
 */
import java.nio.channels.*;
import java.nio.charset.*;
import java.net.*;
import java.io.*;
import java.util.*;
import java.nio.*;

public class DatagramChannelServerDemo {
	// UDP协议服务端
	private int port = 9975;
	DatagramChannel channel;
	private Charset charset = Charset.forName("UTF-8");
	private Selector selector = null;

	public DatagramChannelServerDemo() throws IOException {
		try {
			selector = Selector.open();
			channel = DatagramChannel.open();
		} catch (Exception e) {
			selector = null;
			channel = null;
			System.out.println("超时");			
		}
		System.out.println("服务器启动");
	}

	/* 编码过程 */
	public ByteBuffer encode(String str) {
		return charset.encode(str);
	}

	/* 解码过程 */
	public String decode(ByteBuffer bb) {
		return charset.decode(bb).toString();
	}

	/* 服务器服务方法 */
	public void service() throws IOException {
		if(channel==null || selector==null) return;
		channel.configureBlocking(false);
		channel.socket().bind(new InetSocketAddress(port));
		// channel.write(ByteBuffer.wrap(new String("aaaa").getBytes()));
		channel.register(selector, SelectionKey.OP_READ);
		/** 外循环，已经发生了SelectionKey数目 */
		while (selector.select() > 0) {
			System.out.println("有新channel加入");
			/* 得到已经被捕获了的SelectionKey的集合 */
			Iterator iterator = selector.selectedKeys().iterator();
			while (iterator.hasNext()) {
				SelectionKey key = null;
				try {
					key = (SelectionKey) iterator.next();
					iterator.remove();

					if (key.isReadable()) {
						reveice(key);
					}
					if (key.isWritable()) {
						// send(key);
					}
				} catch (IOException e) {
					e.printStackTrace();
					try {
						if (key != null) {
							key.cancel();
							key.channel().close();
						}
					} catch (ClosedChannelException cex) {
						e.printStackTrace();
					}
				}
			}
			/* 内循环完 */
		}
		/* 外循环完 */
	}

	/*
	 * 接收 用receive()读IO
	 * 作为服务端一般不需要调用connect()，如果未调用<span style="font-family: Arial, Helvetica, sans-serif;">connect()时调</span><span style="font-family: Arial, Helvetica, sans-serif;">用read()\write()读写，会报java.nio.channels</span>
	 * .NotYetConnectedException 只有调用connect()之后,才能使用read和write.
	 */
	synchronized public void reveice(SelectionKey key) throws IOException {
		if (key == null)
			return;
		// ***用channel.receive()获取客户端消息***//
		// ：接收时需要考虑字节长度
		DatagramChannel sc = (DatagramChannel) key.channel();
		String content = "";
		// create buffer with capacity of 48 bytes
		ByteBuffer buf = ByteBuffer.allocate(1024);// java里一个(utf-8)中文3字节,gbk中文占2个字节
		buf.clear();
		SocketAddress address = sc.receive(buf); // read into buffer. 返回客户端的地址信息
		String clientAddress = address.toString().replace("/", "").split(":")[0];
		String clientPost = address.toString().replace("/", "").split(":")[1];

		buf.flip(); // make buffer ready for read
		while (buf.hasRemaining()) {
			buf.get(new byte[buf.limit()]);// read 1 byte at a time
			content += new String(buf.array());
		}
		buf.clear(); // make buffer ready for writing
		System.out.println("接收：" + content.trim());
		// 第一次发；udp采用数据报模式，发送多少次，接收多少次
		ByteBuffer buf2 = ByteBuffer.allocate(65507);
		buf2.clear();
		buf2
				.put("消息推送内容 abc..UDP是一个非连接的协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端UDP是一个非连接的协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端UDP是一个非连接的协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端@Q"
						.getBytes());
		buf2.flip();
		channel.send(buf2, new InetSocketAddress(clientAddress,Integer.parseInt(clientPost))); // 将消息回送给客户端

		// 第二次发
		ByteBuffer buf3 = ByteBuffer.allocate(65507);
		buf3.clear();
		buf3.put("任务完成".getBytes());
		buf3.flip();
		channel.send(buf3, new InetSocketAddress(clientAddress, Integer.parseInt(clientPost))); // 将消息回送给客户端
	}

	int y = 0;

	public void send(SelectionKey key) {
		if (key == null)
			return;
		// ByteBuffer buff = (ByteBuffer) key.attachment();
		DatagramChannel sc = (DatagramChannel) key.channel();
		try {
			sc.write(ByteBuffer.wrap(new String("aaaa").getBytes()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		System.out.println("send2() " + (++y));
	}

	/* 发送文件 */
	public void sendFile(SelectionKey key) {
		if (key == null)
			return;
		ByteBuffer buff = (ByteBuffer) key.attachment();
		SocketChannel sc = (SocketChannel) key.channel();
		String data = decode(buff);
		if (data.indexOf("get") == -1)
			return;
		String subStr = data.substring(data.indexOf(" "), data.length());
		System.out.println("截取之后的字符串是 " + subStr);
		FileInputStream fileInput = null;
		try {
			fileInput = new FileInputStream(subStr);
			FileChannel fileChannel = fileInput.getChannel();
			fileChannel.transferTo(0, fileChannel.size(), sc);
			fileChannel.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fileInput.close();
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws IOException {
		new DatagramChannelServerDemo().service();
	}
}


客户端

package cn;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author 
 * @date 2015-8-7 上午11:36:25
 */
import java.nio.channels.*;
import java.nio.charset.*;
import java.net.*;
import java.io.*;
import java.util.*;
import java.nio.*;

public class DatagramChannelClientDemo {
	// UDP协议客户端
	private String serverIp = "127.0.0.1";
	private int port = 9975;
	// private ServerSocketChannel serverSocketChannel;
	DatagramChannel channel;
	private Charset charset = Charset.forName("UTF-8");
	private Selector selector = null;

	public DatagramChannelClientDemo() throws IOException {		
		try {
			selector = Selector.open();
			channel = DatagramChannel.open();
		} catch (Exception e) {
			selector = null;
			channel = null;
			System.out.println("超时");			
		}
		System.out.println("客户器启动");
	}

	/* 编码过程 */
	public ByteBuffer encode(String str) {
		return charset.encode(str);
	}

	/* 解码过程 */
	public String decode(ByteBuffer bb) {
		return charset.decode(bb).toString();
	}

	/* 服务器服务方法 */
	public void service() throws IOException {
		if(channel==null || selector==null) return;
		channel.configureBlocking(false);
		channel.connect(new InetSocketAddress(serverIp, port));// 连接服务端
		channel.write(ByteBuffer.wrap(new String("客户端请求获取消息").getBytes()));
		channel.register(selector, SelectionKey.OP_READ);
		/** 外循环，已经发生了SelectionKey数目 */
		while (selector.select() > 0) {
			/* 得到已经被捕获了的SelectionKey的集合 */
			Iterator iterator = selector.selectedKeys().iterator();
			while (iterator.hasNext()) {
				SelectionKey key = null;
				try {
					key = (SelectionKey) iterator.next();
					iterator.remove();
					if (key.isReadable()) {
						reveice(key);
					}
					if (key.isWritable()) {
						// send(key);
					}
				} catch (IOException e) {
					e.printStackTrace();
					try {
						if (key != null) {
							key.cancel();
							key.channel().close();
						}
					} catch (ClosedChannelException cex) {
						e.printStackTrace();
					}
				}
			}
			/* 内循环完 */
		}
		/* 外循环完 */
	}

//	/* 
//	 * 接收	用read()读IO
//	 *  */
//	synchronized public void reveice2(SelectionKey key) throws IOException {
//		if (key == null)
//			return;
//		// ***用channel.read()获取消息***//
//		// ：接收时需要考虑字节长度
//		DatagramChannel sc = (DatagramChannel) key.channel();
//		String content = "";
//		// create buffer with capacity of 48 bytes
//		ByteBuffer buf = ByteBuffer.allocate(3);// java里一个(utf-8)中文3字节,gbk中文占2个字节
//		int bytesRead = sc.read(buf); //read into buffer.
//		
//		while (bytesRead >0) {
//		  buf.flip();  //make buffer ready for read
//		  while(buf.hasRemaining()){				      
//			  buf.get(new byte[buf.limit()]); // read 1 byte at a time	
//		      content += new String(buf.array());
//		  }
//		  buf.clear(); //make buffer ready for writing		
//		  bytesRead = sc.read(buf);	
//		}				
//		System.out.println("接收：" + content);				
//	}

	/* 接收 */
	synchronized public void reveice(SelectionKey key) throws IOException {
		String threadName = Thread.currentThread().getName();
		if (key == null)
			return;
		try {
			// ***用channel.receive()获取消息***//
			// ：接收时需要考虑字节长度
			DatagramChannel sc = (DatagramChannel) key.channel();
			String content = "";
			//第一次接；udp采用数据报模式，发送多少次，接收多少次
			ByteBuffer buf = ByteBuffer.allocate(65507);// java里一个(utf-8)中文3字节,gbk中文占2个字节
			buf.clear();
			SocketAddress address = sc.receive(buf); // read into buffer.
			String clientAddress = address.toString().replace("/", "").split(":")[0];
			String clientPost = address.toString().replace("/", "").split(":")[1];
			System.out.println(threadName + "\t" + address.toString());
			buf.flip(); // make buffer ready for read
			while (buf.hasRemaining()) {
				buf.get(new byte[buf.limit()]);// read 1 byte at a time
				byte[] tmp = buf.array();
				content += new String(tmp);
			}
			buf.clear(); // make buffer ready for writing次
			System.out.println(threadName + "接收：" + content.trim());
			//第二次接
			content = "";
			ByteBuffer buf2 = ByteBuffer.allocate(65507);// java里一个(utf-8)中文3字节,gbk中文占2个字节
			buf2.clear();	
			SocketAddress address2 = sc.receive(buf2); // read into buffer.
			buf2.flip(); // make buffer ready for read
			while (buf2.hasRemaining()) {
				buf2.get(new byte[buf2.limit()]);// read 1 byte at a time
				byte[] tmp = buf2.array();
				content += new String(tmp);
			}
			buf2.clear(); // make buffer ready for writing次
			System.out.println(threadName + "接收2：" + content.trim());
			
		} catch (PortUnreachableException ex) {
			System.out.println(threadName + "服务端端口未找到!");
		}
		send(2);		
	}

	boolean flag = false;

	public void send(int i) {
		if (flag)
			return;
		try {
			// channel.write(ByteBuffer.wrap(new String("客户端请求获取消息(第"+i+"次)").getBytes()));
			// channel.register(selector, SelectionKey.OP_READ );
			ByteBuffer buf2 = ByteBuffer.allocate(48);
			buf2.clear();
			buf2.put(("客户端请求获取消息(第" + i + "次)").getBytes());
			buf2.flip();
			channel.write(buf2);
			channel.register(selector, SelectionKey.OP_READ );
//			int bytesSent = channel.send(buf2, new InetSocketAddress(serverIp,port)); // 将消息回送给服务端
		} catch (IOException e) {
			e.printStackTrace();
		}
		flag = true;
	}

	int y = 0;

	public void send(SelectionKey key) {
		if (key == null)
			return;
		// ByteBuffer buff = (ByteBuffer) key.attachment();
		DatagramChannel sc = (DatagramChannel) key.channel();
		try {
			sc.write(ByteBuffer.wrap(new String("aaaa").getBytes()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		System.out.println("send2() " + (++y));
	}

	/* 发送文件 */
	public void sendFile(SelectionKey key) {
		if (key == null)
			return;
		ByteBuffer buff = (ByteBuffer) key.attachment();
		SocketChannel sc = (SocketChannel) key.channel();
		String data = decode(buff);
		if (data.indexOf("get") == -1)
			return;
		String subStr = data.substring(data.indexOf(" "), data.length());
		System.out.println("截取之后的字符串是 " + subStr);
		FileInputStream fileInput = null;
		try {
			fileInput = new FileInputStream(subStr);
			FileChannel fileChannel = fileInput.getChannel();
			fileChannel.transferTo(0, fileChannel.size(), sc);
			fileChannel.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fileInput.close();
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws IOException {
		new Thread(new Runnable() {			
			public void run() {
				try {
					new DatagramChannelClientDemo().service();
				} catch (IOException e) {					
					e.printStackTrace();
				}
			}
		}).start();
		
//		new Thread(new Runnable() {			
//			public void run() {
//				try {
//					new DatagramChannelClientDemo().service();
//				} catch (IOException e) {					
//					e.printStackTrace();
//				}
//			}
//		}).start();
		
	}
}




cg_program
关注
专栏目录
Java NIO：DatagramChannel（UDP包通道）
保暖透气大裤衩LeoLee的博客
08-07 658
概述 Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入，它发送和接收的是数据包。 UDP 简单的来讲，UDP协议和TCP协议不同在于，TCP是可靠的连接协议，需要通过“三次握手”来建立连接，TCP提供的是面向连接的、可靠的数据流传输，可避免数据传输错误，面向连接的协议在任何数据传输前就建立好了点到点的连接。而UDP协议提供高效率的服务，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数
Java NIO 学习(五)--DataGramChannel
智公博客的专栏
07-15 3418
本节讲解的是DataGramChannel，类是与java 网络编程的DatagramSocket类；使用UDP进行网络传输，UDP是无连接，面向数据包的协议，对传输的数据不保证安全与完整；
【NIO】DatagramChannel
yhl_jxy的博客
02-19 3281
前言 Github：https://github.com/yihonglei/java-all Project：java-nio 一 DatagramChannel概述 Java NIO中的DatagramChannel定义在java.nio.channels包中，是一个能收发UDP包的通道。 因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。 二...
计算机网络（八） —— Udp协议
最新发布
aaqq800520的博客
09-21 1281
应用层每一个网络进程都会绑定一个端口，服务器是绑定固定报头，客户端是绑定随机报头，所以UDP就是通过报头当中的“16为目的端口号”来找到对应的进程的，该操作是通过哈希的映射完成的。应用层往下就是传输层，也是属于操作系统的，所以也由操作系统管理，所以Udp是存在与内核中的，是操作系统的网络协议栈自带的，所以也就是说，Udp所有的功能由操作系统完成。我们前面用的各种sock API，都是系统提供的，我们可以通过这些接口搭建上层应用，比如http就是基于Tcp的，因为http就是再Tcp套接字基础上搭建的。
Java NIO系列教程（十） Java NIO DatagramChannel
weixin_34318326的博客
07-11 249
2019独角兽企业重金招聘Python工程师标准>>> ...
Java NIO Java NIO DatagramChannel
sysocc的博客
06-17 228
Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。打开 DatagramChannel下面是 DatagramChannel 的打开方式： 这个例子打开的 DatagramChannel可以在UDP端口9999上接收数据包。接收数据通过receive()方法从DatagramChannel接收数据，如： receive()方法会将接收到的数据包内容复制到指定的Buffer. 如果Buf
NIO部分:DatagramChannel实例
深入一点
04-01 171
package com.test.socket; import java.net.DatagramSocket; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.DatagramChannel; ...
Java NIO（十二） DatagramChannel
weixin_34292959的博客
01-28 97
Java NIO DatagramChannel是可以发送和接收UDP数据包的通道。 由于UDP是无连接的网络协议，所以不能像从其他通道那样默认读取和写入DatagramChannel。 而是发送和接收数据包。 Opening a DatagramChannel 这里是你如何打开一个DatagramChann...
Java Socket编程实例（五）- NIO UDP实践
09-02
Java Socket编程中的NIO（非阻塞I/O）在UDP通信中的应用主要涉及到高效的数据传输和并发处理。本文将深入探讨如何使用NIO与UDP结合，实现一个简单的回显服务器，即UDPEchoSelectorProtocol。 首先，我们来看一下`...
Java NIO中Channel的UDP与DatagramChannel应用
在Java NIO中，Channel是数据传输的通道，可以理解为连接到输入或输出源的“管道”。它负责IO操作的读取和写入，并且能够通过Buffer对象进行数据的传输。不同类型的Channel可以连接到不同类型的输入和输出源，例如...
Java-NIO详解
m0_38033199的博客
11-23 1488
NIO （Non-blocking lO，非阻塞IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO，传统的IO的read和write只能阻塞执行，线程在读写IO期间不能干其他事情
DatagramChannelImpl.rar_java nio
09-23
`DatagramChannel`是Java NIO中的一个重要组件，主要用于处理UDP（User Datagram Protocol）数据包的发送和接收。`DatagramChannelImpl`则是`DatagramChannel`的默认实现类，它实现了相关的底层操作。 `...
Java Nio UDP 消息发送
IT、游罠的专栏
02-26 1218
package ch3; import java.io.IOException; import java.net.DatagramSocket; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.DatagramChannel; import java.nio.chann
Java NIO DatagramChannel编程示例
08-01 621
Java NIO中的DatagramChannel是一个能收发UDP包的通道。 操作步骤： １.打开ＤatagramChannel 2.接受/发送数据 package com.expgiga.NIO; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; i
Java数据报编程之组播
keepeye的专栏
08-25 1879
在信息时代，网络技术应用已经很普通。其中很多应用都依赖于从一个主机向多个主机或者从多个主机向多个主机发送同一信息的能力，在Internet上分发的数目可能达数十万台，这些都需要更高的带宽，并且大大超出了单播的能力。一种能最大限度地利用现有带宽的重要技术是IP组播。1．IP组播技术的概念 IP组播技术，是一种允许一台或多台主机（组播源）发送单一数据包到多台主机（一次的，同时的）的TCP/IP网络技术
java基于NIO的UDP通信
寂寞的博客
07-12 1548
基于java的NIO（DatagramChannel）实现UDP通信的客户端和服务端。 UDPServer import lombok.extern.slf4j.Slf4j; import java.io.IOException; import java.net.InetSocketAddress; import java.net.SocketAddress; import java.nio.ByteBuffer; import java.nio.channels.DatagramChannel; imp
java-NIO-DatagramChannel（UDP）
weixin_30846599的博客
01-20 171
Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。 打开 DatagramChannel 下面是 DatagramChannel 的打开方式： DatagramChannel channel = DatagramChannel.open(); channel....
Java UDP ReceiveThenReply
autumn20080101的专栏
09-29 386
/*      定义一个应用程序，用于接受udp协议传输的数据并处理  1.定义udpsocket服务  2.定义一个数据包类，用于存放接受到的数据包(字节数据)。并使用该类处理数据  3.通过socket服务的receive方法接受的数据出入已定义的数据包类中  4.使用数据包类功能处理数据  5.关闭资源  */   import java.net.DatagramPacket
Java 网络编程UDP协议之发送数据和接收数据的详解
路宇的博客
11-26 7070
UDP协议： 用户数据报协议(User Datagram Protocol) UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一个台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。由于使用UDP协议消耗资源少，通信效率高，所以通常都会用于音频，视频和普通数据的传输。 例如视频会议通常会采用UDP协议，因为这种情况偶尔丢一两个数据包，也不会对接收结果产生太大影响，但是在使用UDP协议
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值