精华内容
参与话题
问答
  • RTP-UDP文件包里含有Linux下服务器端视频采集代码!!采用RTP实时传输协议,视频采集格式为h264!!
  • [QT] UDP协议演示实例

    千次阅读 2010-06-03 18:17:00
    UDP应用.实例...先看 发送数据的代码header.h#ifndef H_H #define H_H #include class QTimer; class QUdpSocket; class Sender:public QObject{ Q_OBJECT public: Sender(QObject *parent=0); void ...

    UDP应用.实例...

    建立项目

    然后在 pro文件加入

    QT += network 代码

    否则会提示你找不到 QtNetwork类..

     

    先看 发送数据的代码

    header.h

     

    main.cpp

     

     

     

    再看 接受数据的代码

    receiver.h

     

     

    receiver.cpp

     

     

    main.cpp

     

     

     

    效果:'

     

     

     

    展开全文
  • UDP(User Datagram Protocol即用户数据报协议)是一个轻量级的,不可靠的,面向数据报的无连接...另一个用来接收数据报,可以叫做服务器端,它们均应用UDP协议。这样也就构成了所谓的C/S(客户端/服务器)编程模型。
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    入门学习Linux常用必会60个命令实例详解 Linux必学的60个命令 Linux提供了大量的命令,利用它可以有效地完成大量的工作,如磁盘操作、文件存取、目录操作、进程管理、文件权限设定等。所以,在Linux系统上工作离不...
  • 例如,容易实现协议的设计。 Java EJB中有、无状态SessionBean的两个例子 两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,计算利息等;在...
  • 包含2中协议的网络编程 1.TCP 安全的 需要提前交流好要发送信息,才能发送 2.UDP 不安全的 不管接收方有没接收,UDP只管发送自己的消息 Socket是网络驱动层提供给应用程序编程的接口和一种机制。网络编程的入口...
    包含2中协议的网络编程
    1.TCP 安全的 需要提前交流好要发送信息,才能发送
    2.UDP 不安全的 不管接收方有没接收,UDP只管发送自己的消息

    Socket是网络驱动层提供给应用程序编程的接口和一种机制。网络编程的入口

    一般都用socket编程
    开发中涉及到的类都在java.net包中
    DatagramSocket类用于UDP通信
    ServerSocket用户TCP通信的服务端
    Socket类用于TCP通信的服务端和客户端

    一、UDP网络编程
    1.涉及到的类
    DatagramSocket类//定义socket入口
    DatagramPacket类//定义socket传输的内容
    InetAddress类

    2.
    DatagramSocket构造函数
    public DatagramSocket()//
    publicDatagramSocket(int port)
    publicDatagramSocket(int port,InetAddress laddr)

    原理:
    发送信息端:定义好socket和要发生的消息内容,然后通过send(DatagramPacket p) 发送给指定的IP和端口
    接受信息端:定义好socket监听对应的端口,然后调用receive(DatagramPacket p)方法,接收发送端发来的信息

    结束后两端都必须调用close方法关闭DatagramSocket方法,释放资源

    简单实例
    //发送信息类
    import java.io.IOException;
    import java.net.*;
    public class UdpSend {
           public static void main(String[] args){
                DatagramSocket ds;
                DatagramPacket dp;
                String strInfo = "hello UDP worldh哈哈" ;
                 try {
                      ds = new DatagramSocket();
                       //DatagramPacket(字节数字缓冲区,字符串长度,对方的IP地址,对方端口)
                      dp = new DatagramPacket(strInfo.getBytes(),
                                              //PS:这里必须先去getBytes()再取长度,不然如果存在中文会被截掉部分,中文2个字节,英文1个
                                              strInfo.getBytes().length ,
                                              InetAddress.getByName ("192.168.1.6" ),
                                              8080);
                      ds.send(dp);
                      ds.close();
                      System. out.println(strInfo);
                } catch (IOException e) {
                       // TODO Auto-generated catch block
                      e.printStackTrace();
                }
          }
    }

    import java.net.*;
    public class UdpRecv {
           public static void main(String[] args){
                DatagramSocket ds;
                DatagramPacket dp;
                
                 try{
                      ds = new DatagramSocket(8080);
                       byte[] buff = new byte[1024];
                      dp = new DatagramPacket(buff,1024);
                      ds.receive(dp);
                      String s = new String(dp.getData(),0,dp.getLength());
                      System. out.println(s+"from" +dp.getAddress().getHostAddress()+":"+dp.getPort());
                } catch(Exception e){
                      e.printStackTrace();
                      System. out.println(e.getMessage());
                }
          }
    
    }

    要比较直观的理解可以使用dos编译,
    cmd--变更到类路径下
    --javac *.java
    -- 输入start命令再打开一个DOS窗口
    --其中一个DOS窗口先运行接收类监听着:java UdpRecv


    --另一个窗口再运行发送信息类:java UdpSent


    --自动接收后返回




    展开全文
  • UDP,在传送数据前不需要先建立连接,远地的主机在收到...对应的应用层的协议主要有 DNS,TFTP,DHCP,SNMP,NFS 等。 TCP,提供面向连接的服务,在传送数据之前必须先建立连接,数据传送完成后要释放连接。因此TCP是...

    UDP,在传送数据前不需要先建立连接,远地的主机在收到UDP报文后也不需要给出任何确认。虽然UDP不提供可靠交付,但是正是因为这样,省去和很多的开销,使得它的速度比较快,比如一些对实时性要求较高的服务,就常常使用的是UDP。对应的应用层的协议主要有 DNS,TFTP,DHCP,SNMP,NFS 等。

    TCP,提供面向连接的服务,在传送数据之前必须先建立连接,数据传送完成后要释放连接。因此TCP是一种可靠的的运输服务,但是正因为这样,不可避免的增加了许多的开销,比如确认,流量控制等。对应的应用层的协议主要有 SMTP,TELNET,HTTP,FTP 等。

    一、TCP&UDP代码实现

    https://blog.csdn.net/wangdy0707/article/details/71106674

    二、TCP建链三次握手

    参考来源:

    https://blog.csdn.net/qzcsu/article/details/72861891

    TCP把连接作为最基本的对象,每一条TCP连接都有两个端点,这种断点我们叫作套接字(socket),它的定义为端口号拼接到IP地址即构成了套接字,例如,若IP地址为192.3.4.16 而端口号为80,那么得到的套接字为192.3.4.16:80。

    建立链接5个步骤:

    TCP服务器进程先创建传输控制块TCB,时刻准备接受客户进程的连接请求,此时服务器就进入了LISTEN(监听)状态;
    TCP客户进程也是先创建传输控制块TCB,然后向服务器发出连接请求报文,这是报文首部中的同部位SYN=1,同时选择一个初始序列号 seq=x ,此时,TCP客户端进程进入了 SYN-SENT(同步已发送状态)状态。TCP规定,SYN报文段(SYN=1的报文段)不能携带数据,但需要消耗掉一个序号。
    TCP服务器收到请求报文后,如果同意连接,则发出确认报文。确认报文中应该 ACK=1,SYN=1,确认号是ack=x+1,同时也要为自己初始化一个序列号 seq=y,此时,TCP服务器进程进入了SYN-RCVD(同步收到)状态。这个报文也不能携带数据,但是同样要消耗一个序号。
    TCP客户进程收到确认后,还要向服务器给出确认。确认报文的ACK=1,ack=y+1,自己的序列号seq=x+1,此时,TCP连接建立,客户端进入ESTABLISHED(已建立连接)状态。TCP规定,ACK报文段可以携带数据,但是如果不携带数据则不消耗序号。
    当服务器收到客户端的确认后也进入ESTABLISHED状态,此后双方就可以开始通信了。 

    一句话,主要防止已经失效的连接请求报文突然又传送到了服务器,从而产生错误。

    如果使用的是两次握手建立连接,假设有这样一种场景,客户端发送了第一个请求连接并且没有丢失,只是因为在网络结点中滞留的时间太长了,由于TCP的客户端迟迟没有收到确认报文,以为服务器没有收到,此时重新向服务器发送这条报文,此后客户端和服务器经过两次握手完成连接,传输数据,然后关闭连接。此时此前滞留的那一次请求连接,网络通畅了到达了服务器,这个报文本该是失效的,但是,两次握手的机制将会让客户端和服务器再次建立连接,这将导致不必要的错误和资源的浪费。

    如果采用的是三次握手,就算是那一次失效的报文传送过来了,服务端接受到了那条失效报文并且回复了确认报文,但是客户端不会再次发出确认。由于服务器收不到确认,就知道客户端并没有请求连接。

    三、TCP断链四次挥手

    客户端进程发出连接释放报文,并且停止发送数据。释放数据报文首部,FIN=1,其序列号为seq=u(等于前面已经传送过来的数据的最后一个字节的序号加1),此时,客户端进入FIN-WAIT-1(终止等待1)状态。 TCP规定,FIN报文段即使不携带数据,也要消耗一个序号。
    服务器收到连接释放报文,发出确认报文,ACK=1,ack=u+1,并且带上自己的序列号seq=v,此时,服务端就进入了CLOSE-WAIT(关闭等待)状态。TCP服务器通知高层的应用进程,客户端向服务器的方向就释放了,这时候处于半关闭状态,即客户端已经没有数据要发送了,但是服务器若发送数据,客户端依然要接受。这个状态还要持续一段时间,也就是整个CLOSE-WAIT状态持续的时间。
    客户端收到服务器的确认请求后,此时,客户端就进入FIN-WAIT-2(终止等待2)状态,等待服务器发送连接释放报文(在这之前还需要接受服务器发送的最后的数据)。
    服务器将最后的数据发送完毕后,就向客户端发送连接释放报文,FIN=1,ack=u+1,由于在半关闭状态,服务器很可能又发送了一些数据,假定此时的序列号为seq=w,此时,服务器就进入了LAST-ACK(最后确认)状态,等待客户端的确认。
    客户端收到服务器的连接释放报文后,必须发出确认,ACK=1,ack=w+1,而自己的序列号是seq=u+1,此时,客户端就进入了TIME-WAIT(时间等待)状态。注意此时TCP连接还没有释放,必须经过2∗∗MSL(最长报文段寿命)的时间后,当客户端撤销相应的TCB后,才进入CLOSED状态。
    服务器只要收到了客户端发出的确认,立即进入CLOSED状态。同样,撤销TCB后,就结束了这次的TCP连接。可以看到,服务器结束TCP连接的时间要比客户端早一些。

    展开全文
  • 在网上找到一些关于udp协议,学习后写了一个实例用于学习之用。 根据别人的经验,总结了以下几点内容: TCP与UDP效率比较:  TCP协议适用于对效率要求相对低,但对准确性要求相对高的场景下,或者是有一种连接...

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

    在网上找到一些关于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();
    		
    	}
    }
    




    展开全文
  • UDP和TCP协议及代码实例

    千次阅读 2018-07-08 18:16:19
    UDP:(User Datagram Protocol 用户数据报协议)是OSI(Open System Interconnection开放式系统互联) 参考模型中一种无连接的传输层协议,提供面向事务的简单不可靠信息传送服务。 UDP适用于一次只传送少量数据、...
  • UDP协议

    2018-06-20 14:04:00
    本篇学习笔记以udp协议的特点、使用场景、应用实例展开叙述 用户数据报协议UDP(User Datagram Protocol) UDP面向无连接的通信协议。所谓的无连接,不建立连接,不确定对方是否在线,甚至不确定对方是否存在 ...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    例如,容易实现协议的设计。 Java EJB中有、无状态SessionBean的两个例子 两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,计算利息等;...
  • GUI写到一半电脑系统挂了,也就算了,最多GUI还有一个提示框和实例,我们暂时不讲了,我们直接来重点吧,关于JAVA的网络请求是怎么实现的?当然是HTTP协议,但是不可否认,他的概念和思想都是我们必须去涉及的,...
  • UDP介绍及实例

    千次阅读 2018-09-03 20:19:58
    UDP不提供可靠性,它只是把应用程序传给IP层的数据报发送出去,但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接,且没有超时重发等机制,故而传输速度很快。 UDP特点: ...
  • TCP/UDP入门与实例详解

    2019-08-12 09:06:56
    传输层控制协议(Transport Control Protocol),TCP/IP协议栈的核心之一。位于应用层与网络层之间,提供面向连接的、可靠的字节流服务。 记住关键词“面向连接”、“可靠”、“字节流”,这是学习掌握TCP的关键: ...
  • 基于zynq板卡的vivado工程中对网口部分调用udp协议应用实例
  • JAVA之旅(三十二)——JAVA网络请求,IP地址,TCP/UDP通讯协议概述,Socket,UDP传输,多线程UDP聊天应用 GUI写到一半电脑系统挂了,也就算了,最多GUI还有一个提示框和实例,我们暂时不讲了,我们直接来重点吧...
  •  总结基于C#的UDP协议的同步通信。   二、实验平台  Visual Studio 2010   三、实验原理  UDP传输协议同TCP传输协议的区别可查阅相关文档,此处不再赘述。   四、实例  4.1 采用socket实现UDP  ...
  • Socket的UDP实例

    2020-01-17 15:32:21
    UDP —用户数据报协议,是一个无连接的简单的面向数据报的运输层协议UDP不提供可靠性,它只是把应用程序传给IP层的数据报发送出去,但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间...
  • socket编程:UDP通讯实例

    2012-01-16 05:22:10
     UDP协议的几点好处:  1.UDP不要求保持一个连接;  2.UDP没有因接收方认可收到数据包(或者当数据包没有正确抵达而自动重传)而带来的开销;  3.设计UDP的目的是用于短应用和控制信息;  4.在一个数据包接...
  • JDK中为开发网络应用程序提供了java.net包,该包下的类和接口几乎都是为网络编程服务的。 InetAddress:用于描述IP地址的对象 InetAddress类没有提供构造方法, 而是提供了静态方法来获取InetAddress实例 getByName...
  • JAVA中TCP/UDP编程实例

    2013-10-20 21:17:28
    开发时用127.0.0.1测试,关于127.0.0.1我就不多说了 首先我们必须了解我们能用的端口地址只能在0~65535之间 ...我一般用8000以上,网络应用中基本上都是TCP(Transmission Control Protocol传输控制协议)和UDP(User D
  • 基于SNMP协议管理实例

    2013-08-27 14:55:52
    1)SNMP简介SNMP是目前网络上用的最广泛的网络管理协议,被广泛的...由于基于UDP协议,所以可以实现众多产品设备的无障碍连接2)SNMP的工作机制:SNMP分为nms和agent两部分NMS叫做网络管理站,目前常用的有华为的...
  • VB Winsock 控件TCP与UDP连接实例

    万次阅读 2012-06-06 09:05:31
    利用 WinSock 控件可以与远程计算机建立连接,并通过用户数据文报协议 (UDP)或者传输控制协议 (TCP)进行数据交换。这两种协议都可以用来创建客户与服务器应用程序。与 Timer 控件类似,WinSock 控件在运行时是不可见...

空空如也

1 2 3 4 5 ... 14
收藏数 278
精华内容 111
关键字:

udp协议应用实例