精华内容
下载资源
问答
  • DatagramSocket

    2020-04-19 20:37:03
    DatagramSocket socket=new DatagramSocket(12344); //创建一个InetAddree,自己测试的时候要设置成自己的IP地址 InetAddress serverAddress=InetAddress.getByName("192.168.0.102"); while(true){ ...
    //网络的相关权限
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    //用户端
    try
    		{
    			DatagramSocket socket=new DatagramSocket(12344);
    			//创建一个InetAddree,自己测试的时候要设置成自己的IP地址
    			InetAddress serverAddress=InetAddress.getByName("192.168.0.102");
    			while(true){
    				String str="Hi, this is the string from the Android Client!";
    				byte data []=str.getBytes ();
    				//创建一个 DatagramPacket 对象,并指定要将这个数据包发送到网络当中的哪个地址以及端口号
    				DatagramPacket packet=new DatagramPacket (data,data.length,serverAddress,12345);
    				//调用 socket 对象的 send 方法,发送数据
    				socket.send (packet);
    				Thread.sleep(1000);
    			}
    		}
    		catch(SocketException e)
    		{}catch(UnknownHostException e){}catch(IOException e){}catch(InterruptedException e){}
    
    //服务器端
    try
    		{
    			DatagramSocket s=new DatagramSocket(12345);
    			byte data[]=new byte[1024];
    			//创建一个空 DatagramPacket 对象
    			DatagramPacket p=new DatagramPacket (data, data.length);
    			// 使用receive 方法接收客户端所发送的数据
    			s.receive(p);
    			String r=new String(p.getData(),p.getOffset(),p.getLength());
    			System.out.println(r);
    		}
    		catch(SocketException e)
    		{}catch(IOException e){}
    
    展开全文
  • datagramsocket

    2011-11-03 12:18:27
    17.4.2 使用DatagramSocket发送、接收数据 DatagramSocket本身只是码头,不维护状态,不能产生IO流,它的唯一作用就是接收和发送数据报,Java使用DatagramPacket来代表数据报,DatagramSocket接收和发送的数据都...
    17.4.2 使用DatagramSocket发送、接收数据

    DatagramSocket本身只是码头,不维护状态,不能产生IO流,它的唯一作用就是接收和发送数据报,Java使用DatagramPacket来代表数据报,DatagramSocket接收和发送的数据都是通过DatagramPacket对象完成的。

    先看一下DatagramSocket的构造器:

    DatagramSocket():创建一个DatagramSocket实例,并将该对象绑定到本机默认IP地址、本机所有可用端口中随机选择的某个端口。

    DatagramSocket(int prot):创建一个DatagramSocket实例,并将该对象绑定到本机默认IP地址、指定端口。

    DatagramSocket(int port, InetAddress laddr):创建一个DatagramSocket实例,并将该对象绑定到指定IP地址、指定端口。

    通过上面三个构造器中任意一个构造器即可创建一个DatagramSocket实例,通常在创建服务器时,我们创建指定端口的 DatagramSocket实例——这样保证其他客户端可以将数据发送到该服务器。一旦得到了DatagramSocket实例之后,就可以通过如下两个方法来接收和发送数据:

    receive(DatagramPacket p):从该DatagramSocket中接收数据报。

    send(DatagramPacket p):以该DatagramSocket对象向外发送数据报。

    从上面两个方法可以看出,使用DatagramSocket发送数据报时,DatagramSocket并不知道将该数据报发送到哪里,而是由 DatagramPacket自身决定数据报的目的。就像码头并不知道每个集装箱的目的地,码头只是将这些集装箱发送出去,而集装箱本身包含了该集装箱的目的地。

    当Client/Server程序使用UDP协议时,实际上并没有明显的服务器和客户端,因为两方都需要先建立一个DatagramSocket对象,用来接收或发送数据报,然后使用DatagramPacket对象作为传输数据的载体。通常固定IP、固定端口的DatagramSocket对象所在的程序被称为服务器,因为该DatagramSocket可以主动接收客户端数据。

    下面看一下DatagramPacket的构造器:

    DatagramPacket(byte buf[],int length):以一个空数组来创建DatagramPacket对象,该对象的作用是接收DatagramSocket中的数据。

    DatagramPacket(byte buf[], int length, InetAddress addr, int port):以一个包含数据的数组来创建DatagramPacket对象,创建该DatagramPacket时还指定了IP地址和端口——这就决定了该数据报的目的。

    DatagramPacket(byte[] buf, int offset, int length):以一个空数组来创建DatagramPacket对象,并指定接收到的数据放入buf数组中时从offset开始,最多放length个字节。

    DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port):创建一个用于发送的DatagramPacket对象,也多指定了一个offset参数。

    在接收数据前,应该采用上面的第一个或第三个构造器生成一个DatagramPacket对象,给出接收数据的字节数组及其长度。然后调用 DatagramSocket 的方法receive()等待数据报的到来,receive()将一直等待(也就是说会阻塞调用该方法的线程),直到收到一个数据报为止。如下代码所示:


    //创建接受数据的DatagramPacket对象
    DatagramPacket packet=new DatagramPacket(buf, 256);
    socket.receive(packet);//接收数据

    发送数据之前,调用第二个或第四个构造器创建DatagramPacket对象,此时的字节数组里存放了想发送的数据。除此之外,还要给出完整的目的地址,包括IP地址和端口号。发送数据是通过DatagramSocket的方法send()实现的,send()根据数据报的目的地址来寻径以传递数据报。如下代码所示:

    //创建一个发送数据的DatagramPacket对象
    DatagramPacket packet = new DatagramPacket(buf, length, address, port);
    //发送数据报
    socket.send(packet);

    当我们使用DatagramPacket来接收数据时,会感觉DatagramPacket设计得过于烦琐。对于开发者而言,只关心该 DatagramPacket能放多少数据,而DatagramPacket是否采用字节数组来存储数据完全不想关心。但Java要求创建接收数据用的 DatagramPacket时,必须传入一个空的字节数组,该数组的长度决定了该DatagramPacket能放多少数据,这实际上暴露了 DatagramPacket的实现细节。接着DatagramPacket又提供了一个getData()方法,该方法又可以返回 DatagramPacket对象里封装的字节数组,该方法更显得有些多余:如果程序需要获取DatagramPacket里封装的字节数组,直接访问传给 DatagramPacket构造器的字节数组实参即可,无须调用该方法。

    当服务器(也可以客户端)接收到一个DatagramPacket对象后,如果想向该数据报的发送者“反馈”一些信息,但由于UDP是面向非连接的,所以接收者并不知道每个数据报由谁发送过来,但程序可以调用DatagramPacket的如下三个方法来获取发送者的IP和端口:

    InetAddress getAddress():返回某台机器的 IP 地址,当程序准备发送次数据报时,该方法返回此数据报的目标机器的IP地址;当程序刚刚接收到一个数据报时,该方法返回该数据报的发送主机的IP地址。

    int getPort():返回某台机器的端口,当程序准备发送此数据报时,该方法返回此数据报的目标机器的端口;当程序刚刚接收到一个数据报时,该方法返回该数据报的发送主机的端口。

    SocketAddress getSocketAddress():返回完整SocketAddress,通常由IP地址和端口组成。当程序准备发送此数据报时,该方法返回此数据报的目标SocketAddress;当程序刚刚接收到一个数据报时,该方法返回该数据报是源SocketAddress。

    上面getSocketAddress方法的返回值是一个SocketAddress对象,该对象实际上就是一个IP地址和一个端口号,也就是说 SocketAddress对象封装了一个InetAddress对象和一个代表端口的整数,所以使用SocketAddress对象可以同时代表IP地址和端口。

    下面程序使用DatagramSocket实现Server/Client结构的网络通信程序,本程序的服务器端接收客户端传的文件路径地址,并将文件发送给客户端,服务器端代码如下:

    程序清单:codes/17/17-4/UdpServer.java


    package test;

    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;

    public class UdpServer {
    private DatagramSocket socket;
    private DatagramPacket inPacket;
    private DatagramPacket outPacket;
    private RandomAccessFile raf;
    private byte[] buff;
    private String filePath;
    private static final int BUFF_LEN = 4096;

    public UdpServer(){
    run();
    }

    private void run() {
    try {
    socket = new DatagramSocket(9023);// 服务器端固定端口接收客户端信息

    //开始从客户端接收数据
    System.out.println("开始从客户端接收数据...");
    buff = new byte[BUFF_LEN];
    inPacket = new DatagramPacket(buff, BUFF_LEN);

    StringBuffer sb = new StringBuffer();
    socket.receive(inPacket);//开始接收收据
    while (inPacket.getLength() == BUFF_LEN) { //如果填满了,就继续接收
    sb.append(new String(inPacket.getData(),0,inPacket.getData().length));
    socket.receive(inPacket);
    }
    sb.append(new String(inPacket.getData(),0,inPacket.getData().length));//构造不满BUFF_LEN的字符

    filePath = sb.toString();
    System.out.println("接收到的文件路径为:["+filePath+"]");

    //开始发送文件
    System.out.println("开始发送文件...");
    raf = new RandomAccessFile(filePath, "rw");
    buff = new byte[BUFF_LEN];
    int len = 0;
    while((len = raf.read(buff))!= -1){
    outPacket = new DatagramPacket(buff,0, len, inPacket.getAddress(),inPacket.getPort());
    socket.send(outPacket);
    }
    raf.close();
    System.out.println("文件发送成功...");

    } catch (SocketException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }finally{
    if(socket != null)
    socket.close();
    }

    }

    public static void main(String[] args) {
    new UdpServer();
    }
    }


    上面程序中粗体字代码就是使用DatagramSocket发送、接收DatagramPacket的关键代码,该程序可以接受1000个客户端发送过来的数据。

    客户端代码如下:

    程序清单:codes/17/17-4/UdpClient.java


    package test;

    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.SocketException;
    import java.net.UnknownHostException;

    public class UdpClient {
    private static DatagramSocket socket;
    private static DatagramPacket inPacket;
    private static DatagramPacket outPacket;
    private RandomAccessFile raf;
    private String filePath;
    private String toSaveFilePath;
    private byte[] buff;
    private static final int BUFF_LEN = 4096;

    public UdpClient() {

    }

    public UdpClient(String filePath, String toSaveFilePath) {
    this.filePath = filePath;
    this.toSaveFilePath = toSaveFilePath;
    run();
    }

    private void run() {
    try {
    socket = new DatagramSocket();// 客户端使用随机端口即可
    buff = filePath.getBytes();
    outPacket = new DatagramPacket(buff, buff.length, InetAddress
    .getByName("127.0.0.1"), 9023);
    System.out.println("开始发送请求文件路径...文件路径:[" + filePath + "]");
    socket.send(outPacket);

    // 开始接收文件
    System.out.println("发送请求文件路径成功,开始接收...");

    raf = new RandomAccessFile(toSaveFilePath, "rw");
    buff = new byte[BUFF_LEN];
    inPacket = new DatagramPacket(buff, BUFF_LEN);
    socket.receive(inPacket);//开始接收数据
    while (inPacket.getLength() == BUFF_LEN) {//如果填满了数组 继续接收
    raf.write(inPacket.getData(), 0, inPacket.getData().length);// 将接收到的数据写入文件中
    socket.receive(inPacket);
    }
    raf.write(inPacket.getData(), 0, inPacket.getData().length);//将不足BUFF_LEN的部分写入文件

    raf.close();
    System.out.println("文件接收成功...");

    } catch (NullPointerException e) {
    throw new NullPointerException("filePath is not exists!");
    } catch (UnknownHostException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    }finally{
    if(socket != null)
    socket.close();
    }

    }

    public String getFilePath() {
    return filePath;
    }

    public void setFilePath(String filePath) {
    this.filePath = filePath;
    }

    public String getToSaveFilePath() {
    return toSaveFilePath;
    }

    public void setToSaveFilePath(String toSaveFilePath) {
    this.toSaveFilePath = toSaveFilePath;
    }

    public static void main(String[] args) {
    String filePath = "E:"+File.separator+"qnyh.jpg";
    String toSaveFilePath = "D:"+File.separator+"qnyh.jpg";

    new UdpClient(filePath, toSaveFilePath);
    }
    }


    上面程序的粗体字代码同样也是通过DatagramSocket发送、接收DatagramPacket的关键代码,这些代码与服务器的代码基本相似。而客户端与服务器端的唯一区别在于:服务器所在IP地址、端口是固定的,所以客户端可以直接将该数据报发送给服务器,而服务器则需要根据接收到的数据报来决定将“反馈”数据报的目的地。

    读者可能会发现,使用DatagramSocket进行网络通信时,服务器端无须、也无法保存每个客户端的状态,客户端把数据报发送到服务器后,完全有可能立即退出。但不管客户端是否退出,服务器无法知道客户端的状态。

    当使用UDP协议时,如果想让一个客户端发送的聊天信息可被转发到其他所有客户端则比较困难,可以考虑在服务器使用Set来保存所有客户端信息,每当接收到一个客户端的数据报之后,程序检查该数据报的源SocketAddress是否在Set集合中,如果不在就将该SocketAddress添加到该Set集合中,但这样一来又涉及一个问题:可能有些客户端发送一个数据报之后永久性地退出了程序,但服务器端还将该客户端的SocketAddress 保存在Set集合中……总之,这种方式需要处理的问题比较多,编程比较烦琐。幸好Java为UDP协议提供了MulticastSocket类,通过该类可以轻松实现多点广播。
    展开全文
  • DatagramSocket例子

    2019-10-04 18:31:22
    在javaSE中,使用DatagramSocket进行的网络通信是基于UDP的。 DatagramSocket类: 表示发送和接收数据报包的套接字。数据报套接字是包投递服务的发送或接收点。从一台机器发送到另一台机器的多个包可能选择不同的...

    在javaSE中,使用DatagramSocket进行的网络通信是基于UDP的。

    DatagramSocket类:

    表示发送和接收数据报包的套接字。数据报套接字是包投递服务的发送或接收点。从一台机器发送到另一台机器的多个包可能选择不同的路由,也可能按不同的顺序到达。

    构造方法:(多个只说一个)

    DatagramSocket(int port)
        创建数据报套接字并将其绑定到本地主机上的指定端口。

    重要方法:

    public void send(DatagramPacket p)    throws IOException
    解释:从此套接字发送数据报包。DatagramPacket 包含的信息指示:将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。 如果存在安全管理器,且套接字当前没有连接到远程地址,则此方法首先执行某些安全性检查。

    public void receive(DatagramPacket p)   throws IOException
    解释:从此套接字接收数据报包。当此方法返回时,DatagramPacket的缓冲区填充了接收的数据。数据报包也包含发送方的IP地址和发送方机器上的端口号。
    此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长,该信息将被截短。如果存在安全管理器,而安全管理器的 checkAccept方法不允许接收操作,则包不能被接收。

     

    DatagramPacket类:

    表示数据报包。数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。

    构造方法:(有区分用于接收或发送的)

    接受

    DatagramPacket(byte[] buf, int length)
        构造 DatagramPacket,用来接收长度为 length 的数据包。

    DatagramPacket(byte[] buf, int offset, int length)
        构造 DatagramPacket,用来接收长度为 length 的包,在缓冲区中指定了偏移量。

    发送(多个只说一个)

    DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)
        构造数据报包,用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。

    重要方法:

    public byte[] getData()
    返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始,持续length长度。

     

    如何通信:

    发送方工作过程步骤:

    1. 创建DatagramSocket(可以设置本地端口,或由系统分配)
    2. 创建用于发送的DatagramPacket(主要设置发送的数据、远程地址和端口等信息)
    3. 通过DatagramSocket发送DatagramPacket(调用send方法)
    4. 关闭DatagramSocket

    接收方工作过程步骤:

    1. 创建DatagramSocket(主要设置本地地址和端口等信息)
    2. 创建用于接受的DatagramPacket(不需要设置地址和端口)
    3. 通过DatagramSocket接收发送方信息,填充DatagramPacket(调用receive方法)
    4. 读取DatagramPacket的数据(调用getData方法)
    5. 关闭DatagramSocket

    例子

    发送方代码:

    View Code
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    public class Sender {
    
        public static void main(String[] args) throws Exception {
            DatagramSocket sender = new DatagramSocket();// 1、创建DatagramSocket(可以设置本地端口,或由系统分配)
            String msg = "你好!";
            byte[] buf = msg.getBytes();
            DatagramPacket packet = new DatagramPacket(buf, buf.length,
                    InetAddress.getByName("127.0.0.1"), 10000);// 2、创建用于发送的DatagramPacket(主要设置发送的数据、远程地址和端口等信息)
            System.out.println("sender:发送信息----" + msg);
            sender.send(packet);// 3、通过DatagramSocket发送DatagramPacket
            System.out.println("sender:已经发送了信息");
            sender.close();// 4、关闭DatagramSocket
        }
    
    }

     

    接收方代码:

    View Code
     1 import java.net.DatagramPacket;
     2 import java.net.DatagramSocket;
     3 
     4 public class Receiver {
     5 
     6     public static void main(String[] args) throws Exception {
     7         DatagramSocket receiver = new DatagramSocket(10000);// 1、创建DatagramSocket(主要设置本地地址和端口等信息)
     8         byte[] buf = new byte[1024];
     9         DatagramPacket packet = new DatagramPacket(buf, buf.length);// 2、创建用于接受的DatagramPacket(不需要设置地址和端口)
    10         System.out.println("receiver:等待接收");
    11         receiver.receive(packet);// 3、通过DatagramSocket接受发送方信息,填充DatagramPacket
    12         String msg = new String(packet.getData(), 0, packet.getLength());// 4、读取DatagramPacket的数据
    13         System.out.println("receiver:得到的信息是:-----" + msg);
    14         receiver.close();// 5、关闭DatagramSocket
    15     }
    16 
    17 }

     

    转载于:https://www.cnblogs.com/dann/archive/2012/10/28/2743884.html

    展开全文
  • 信息安全老师布置了一个作业,要求编写一个可以让两个人利用Java UDP进行聊天的小程序,要求利用Datagramsocket和Datagrampacket,由于Java没学好,对于这两个类很是陌生,于是通过查询资料,对他俩有了以下这点浅薄...

    信息安全老师布置了一个作业,要求编写一个可以让两个人利用Java UDP进行聊天的小程序,要求利用Datagramsocket和Datagrampacket,由于Java没学好,对于这两个类很是陌生,于是通过查询资料,对他俩有了以下这点浅薄的认识

    UDP传输数据类似于在海上运输货物,DatagramSocket就像两个通信港口的码头,而DatagramPacket就像运输货物的轮船

    Datagrampacket类,用于封装UDP通信中发送或接收的数据
    Datagramsocket类,表示用来发送和接收数据报包的套接字

    在发送端:
    创建datagramsocket,随机端口号
    创建datagrampacket,制定数据,长度,地址和端口
    使用datagramsocket发送datagrampacket
    关闭datagramsocket
    异常处理

    在接收端:
    创建datagramsocket,匹配端口号
    创建datagrampacket,创建接收数据和有效数据长度
    接收socket
    接收packet
    关闭datagramsocket

    //发送端
    import java.io.IOException;
    import java.net.*;
    import java.util.Scanner;

    public class UDPSocketServerthread implements Runnable {

    byte[] ibuf = new byte[1024];
    String message;
    Scanner scanner = new Scanner(System.in);
    DatagramPacket datagramPacket;
    
    {   
    
        try {	   
    
            datagramPacket = new DatagramPacket(ibuf, ibuf.length, InetAddress.getByName("127.0.0.1"), 2020);
            //制定数据、长度、地址、端口
        } catch (UnknownHostException e) {	   
    
            e.printStackTrace();
        }
    }
    
    DatagramSocket dd;
    
    {	   	   
        try {   
    
            dd = new DatagramSocket(8080, InetAddress.getByName("127.0.0.1"));//随机端口号
        } catch (SocketException | UnknownHostException e) {	   
    
            e.printStackTrace();
        }
    }
    
    @Override
    public void run() {   
    
        while (true) {   
    
            message = scanner.nextLine();
            datagramPacket.setData(message.getBytes());
            try {     
                assert dd != null;
               dd.send(datagramPacket);//使用socket发送packet
            } catch (IOException e) {   
    
                e.printStackTrace();
            }
        }
    }
    

    }

    //接收端
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;

    public class UDPSocketClientthread implements Runnable {

    DatagramSocket datagramSocket;
    {	   
    
        try {		   
    
            datagramSocket = new DatagramSocket(8081);//匹配端口号
        } catch (SocketException e) {	   
    
            e.printStackTrace();
        }
    }
    
    byte[] ibuf = new byte[1024];
    DatagramPacket datagramPacket = new DatagramPacket(ibuf, ibuf.length);//接受数据和有效数据长度
    
    
    @Override
    public void run() {	   
    
        while (true) {	   
    
            try {	   
    
                datagramSocket.receive(datagramPacket);//接收packet
            } catch (IOException e) {	  
    
                e.printStackTrace();}
            System.out.println("Tom:" + new String(datagramPacket.getData(), 0, datagramPacket.getLength()));
        }
    }
    

    }

    展开全文
  • DatagramSocket And DatagramPacket
  • Socket和DatagramSocket的区别

    万次阅读 2018-10-08 18:29:51
    DatagramSocket使用的UDP连接,客户端不需要先连接数据,可以直接发送给指定服务端。 DatagramSocket: 客户端发送(直接发送数据,没有连接的过程): protected void connectServerWithUDPSocket(Context ...
  • java DatagramSocket 的上传文件客户端,tftp客户端。使用DatagramSocket代表UDP协议的Socket,使用DatagramPacket来代表数据报。
  • package test; import java.io.IOException; import java.net.DatagramPacket;...import java.net.DatagramSocket; import java.net.InetAddress; public class Server { public static void...
  • Java使用DatagramSocket

    2016-12-28 18:01:00
    Java使用DatagramSocket代表UDP协议的Socket,DatagramSocket本身只是码头,不维护状态,不能产生IO流,它的唯一作用就是接收和发送数据报,Java使用DatagramPacket来代表数据报,DatagramSocket接收和发送的数据都...
  • import org.junit.Test; import java.io.*; import java.net.DatagramPacket...import java.net.DatagramSocket; import java.net.InetSocketAddress; /** * @author * @date 2019/7/23 */ public class TestUd...
  •  a.DatagramPacket与DatagramSocket位于java.net包中  b.DatagramPacket表示存放数据的数据报,DatagramSocket表示接受或发送数据报的套接字  c.由这两个类所有构成的网络链接是基于UDP协议,是一种不可靠的...
  • /** * 将生成的数据,发送到对应的服务器的端口上 * @param msg * @return 成功0 失败-1 */ public int sendMsgAgent(String msg){ DatagramSocket datagramSocket = null; DatagramPacket datagramP
  • java.net.DatagramSocket

    千次阅读 2019-05-11 16:25:42
    此类表示用于发送和接收数据报包的套接字。 数据报套接字是分组传送服务的发送或接收点。在数据报套接字上发送或接收的每个数据包都是单独寻址和路由的。...为了接收广播数据包,应将DatagramSocket绑...
  • I DatagramSocket II DatagramSocket 构造方法 III DatagramSocket 数据操作 IV DatagramPacket V DatagramPacket 构造方法 VI DatagramPacket 设置参数 VII DatagramPacket 获取参数 VIII DatagramPacket IP...
  • DatagramSocket数据包/UDP

    2015-11-26 22:52:28
    之前有写过关于TCP协议的socket套接字,这里介绍的是UDP的数据包DatagramSocket。 TCP和UDP的优缺点以及他们各自的特点这里我就不多说了。总之都是有利有弊, 看中速度,那么就"牺牲"安全,注重安全,那么在速度...
  • 一、DatagramSocket类二、DatagramPacket类
  • 一、DatagramSocket DatagramSocket是使用UDP协议的Socket,它的作用是接收和发送数据包,但是它本身并不能产生IO流 1、创建DatagramSocket对象 DatagramSocket() //创建一个数据包套接字,绑定到本机上任意一个...
  • 网上看了很多,Java的偏多,这里只介绍Android 小米8测试结果,如有不当之处,敬请谅解! Android UDP 测试 ...public class DatagramSocket extends Object implements Closeable This class repres
  • 使用DatagramSocket发送、接收数据

    千次阅读 2018-03-21 12:13:55
    java使用DatagramSocket代表UDP协议的Socket,DatagramSocket本身只是码头,不维护状态,不能产生IO流,它的唯一作用就是接收和发送数据报,Java使用DatagramPacket来代表数据报,DatagramSocket接收和发送的数据都...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,968
精华内容 9,187
关键字:

datagramsocket