大数据必学Java基础（八十二）：基于UDP的网络编程

基于UDP的网络编程

TCP

客户端：Socket

程序感受到的使用流：输出流

服务器端： ServerSocket --> Socket 程序感受到的使用流：输入流

（客户端和服务器端地位不平等）

UDP

发送方：DatagramSocket 发送：数据包 DatagramPacket

接收方：DatagramSocket 接收：数据包 DatagramPacket

（发送方和接收方的地址是平等的）

UDP案例：完成网站的咨询聊天

一、功能分解1：单向通信

发送方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestSend {//发送方：

    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        System.out.println("学生上线。。。");
        //1.准备套接字： 指定发送方的端口号
        DatagramSocket ds = new DatagramSocket(8888);
        //2.准备数据包
        String str = "你好";
        byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
         */
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
        //发送：
        ds.send(dp);

        //关闭资源
        ds.close();
    }
}

接收方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestReceive {//接收方

    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        System.out.println("老师上线了。。");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds = new DatagramSocket(9999);
        //2.有一个空的数据包，打算用来接收  对方传过来的数据包：
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b,b.length);
        //3.接收对方的数据包，然后放入我们的dp数据包中填充
        ds.receive(dp);//接收完以后 dp里面就填充好内容了

        //4.取出数据：
        byte[] data = dp.getData();
        String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
        System.out.println("学生对我说："+s);

        //5.关闭资源：
        ds.close();

    }
}

二、功能分解2：双向通信

发送方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestSend {//发送方：

    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        System.out.println("学生上线。。。");
        //1.准备套接字： 指定发送方的端口号
        DatagramSocket ds = new DatagramSocket(8888);
        //2.准备数据包
        Scanner sc = new Scanner(System.in);
        System.out.print("学生：");
        String str = sc.next();
        byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为Z字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
         */
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
        //发送：
        ds.send(dp);

        //接收老师发送回来的信息：
        byte[] b = new byte[1024];
        DatagramPacket dp2 = new DatagramPacket(b,b.length);
        ds.receive(dp2);//接收完以后 dp2里面就填充好内容了

        //取出数据：
        byte[] data = dp2.getData();
        String s = new String(data,0,dp2.getLength());//dp.getLength()数组包中的有效长度
        System.out.println("老师对我说："+s);

        //关闭资源
        ds.close();
    }
}

接收方：

package com.lanson.test04;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

/**
 * @author : Lansonli
 */
public class TestReceive {//接收方

    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        System.out.println("老师上线了。。");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds = new DatagramSocket(9999);
        //2.有一个空的数据包，打算用来接收  对方传过来的数据包：
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b,b.length);
        //3.接收对方的数据包，然后放入我们的dp数据包中填充
        ds.receive(dp);//接收完以后 dp里面就填充好内容了

        //4.取出数据：
        byte[] data = dp.getData();
        String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
        System.out.println("学生对我说："+s);

        //老师进行回复：
        Scanner sc = new Scanner(System.in);
        System.out.print("老师：");
        String str = sc.next();
        byte[] bytes = str.getBytes();
        //封装数据，并且指定学生的ip和端口号
        DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
        //发送：
        ds.send(dp2);
        //5.关闭资源：
        ds.close();

    }
}

三、功能分解3：加入完整的处理异常方式

发送方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestSend {//发送方：

    //这是一个main方法，是程序的入口：
    public static void main(String[] args)  {
        System.out.println("学生上线。。。");
        //1.准备套接字： 指定发送方的端口号
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(8888);
            //2.准备数据包
            Scanner sc = new Scanner(System.in);
            System.out.print("学生：");
            String str = sc.next();
            byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为Z字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
         */
            DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
            //发送：
            ds.send(dp);

            //接收老师发送回来的信息：
            byte[] b = new byte[1024];
            DatagramPacket dp2 = new DatagramPacket(b,b.length);
            ds.receive(dp2);//接收完以后 dp2里面就填充好内容了

            //取出数据：
            byte[] data = dp2.getData();
            String s = new String(data,0,dp2.getLength());//dp.getLength()数组包中的有效长度
            System.out.println("老师对我说："+s);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            ds.close();
        }

    }
}

接收方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestReceive {//接收方

    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        System.out.println("老师上线了。。");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(9999);
            //2.有一个空的数据包，打算用来接收  对方传过来的数据包：
            byte[] b = new byte[1024];
            DatagramPacket dp = new DatagramPacket(b,b.length);
            //3.接收对方的数据包，然后放入我们的dp数据包中填充
            ds.receive(dp);//接收完以后 dp里面就填充好内容了

            //4.取出数据：
            byte[] data = dp.getData();
            String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
            System.out.println("学生对我说："+s);

            //老师进行回复：
            Scanner sc = new Scanner(System.in);
            System.out.print("老师：");
            String str = sc.next();
            byte[] bytes = str.getBytes();
            //封装数据，并且指定学生的ip和端口号
            DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
            //发送：
            ds.send(dp2);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源：
            ds.close();
        }

    }
}

四、功能分解4：正常通信

发送方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestSend {//发送方：

    //这是一个main方法，是程序的入口：
    public static void main(String[] args)  {
        System.out.println("学生上线。。。");
        //1.准备套接字： 指定发送方的端口号
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(8888);
            while(true){
                //2.准备数据包
                Scanner sc = new Scanner(System.in);
                System.out.print("学生：");
                String str = sc.next();

                byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为Z字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
         */
                DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
                //发送：
                ds.send(dp);
                if(str.equals("byebye")){
                    System.out.println("学生下线。。");
                    break;
                }
                //接收老师发送回来的信息：
                byte[] b = new byte[1024];
                DatagramPacket dp2 = new DatagramPacket(b,b.length);
                ds.receive(dp2);//接收完以后 dp2里面就填充好内容了

                //取出数据：
                byte[] data = dp2.getData();
                String s = new String(data,0,dp2.getLength());//dp.getLength()数组包中的有效长度
                System.out.println("老师对我说："+s);
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            ds.close();
        }

    }
}

接收方：

package com.lanson.test04;

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

/**
 * @author : Lansonli
 */
public class TestReceive {//接收方

    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        System.out.println("老师上线了。。");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(9999);
            while(true){
                //2.有一个空的数据包，打算用来接收  对方传过来的数据包：
                byte[] b = new byte[1024];
                DatagramPacket dp = new DatagramPacket(b,b.length);
                //3.接收对方的数据包，然后放入我们的dp数据包中填充
                ds.receive(dp);//接收完以后 dp里面就填充好内容了

                //4.取出数据：
                byte[] data = dp.getData();
                String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
                System.out.println("学生对我说："+s);
                if(s.equals("byebye")){
                    System.out.println("学生已经下线了，老师也下线。。。");
                    break;
                }

                //老师进行回复：
                Scanner sc = new Scanner(System.in);
                System.out.print("老师：");
                String str = sc.next();
                byte[] bytes = str.getBytes();
                //封装数据，并且指定学生的ip和端口号
                DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
                //发送：
                ds.send(dp2);
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源：
            ds.close();
        }

    }
}

📢博客主页：https://lansonli.blog.csdn.net
📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
📢本文由 Lansonli 原创，首发于 CSDN博客🙉
📢停下休息的时候不要忘了别人还在奔跑，希望大家抓紧时间学习，全力奔赴更美好的生活✨

标签： java 网络 udp

本文转载自: https://blog.csdn.net/xiaoweite1/article/details/127421415
版权归原作者 Lansonli 所有，如有侵权，请联系我们删除。

大数据必学Java基础（八十二）：基于UDP的网络编程

基于UDP的网络编程

一、功能分解1：单向通信

二、功能分解2：双向通信

三、功能分解3：加入完整的处理异常方式

四、功能分解4：正常通信

发表评论

“大数据必学Java基础（八十二）：基于UDP的网络编程”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航