网络编程 udp tcp的使用

最新推荐文章于 2023-11-17 23:05:01 发布
最新推荐文章于 2023-11-17 23:05:01 发布
阅读量47 收藏
点赞数
文章标签： 网络 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62491932/article/details/130476245
版权 
111111
/*
    InetAddress
        此类表示Internet协议（IP）地址

    public static InetAddress getByName​(String host)：确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
    public String getHostName​()：获取此IP地址的主机名
    public String getHostAddress​()：返回文本显示中的IP地址字符串
 */
class InetAddressDemos {
    public static void main(String[] args) throws UnknownHostException {
        //public static InetAddress getByName​(String host)：确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
//        InetAddress address = InetAddress.getByName("itheima");
        InetAddress address = InetAddress.getByName("192.168.119.44");

        //public String getHostName​()：获取此IP地址的主机名
        String name = address.getHostName();
        //public String getHostAddress​()：返回文本显示中的IP地址字符串
        String ip = address.getHostAddress();

        System.out.println("主机名：" + name);
        System.out.println("IP地址：" + ip);
    }
}

/*
    UDP发送数据的步骤
        1:创建发送端的Socket对象(DatagramSocket)
        2:创建数据，并把数据打包
        3:调用DatagramSocket对象的方法发送数据
        4:关闭发送端

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        // DatagramSocket​() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
        DatagramSocket ds = new DatagramSocket();

        //创建数据，并把数据打包
        //DatagramPacket​(byte[] buf, int length, InetAddress address, int port)
        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bys = "hello,udp,我来了".getBytes();
//        int length = bys.length;
//        InetAddress address = InetAddress.getByName("192.168.119.44");
//        int port = 10086;
//        DatagramPacket dp = new DatagramPacket(bys,length,address,port);
        DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.119.44"),10086);

        //调用DatagramSocket对象的方法发送数据
        //void send​(DatagramPacket p) 从此套接字发送数据报包
        ds.send(dp);

        //关闭发送端
        //void close​() 关闭此数据报套接字
        ds.close();
    }
}
/*
    UDP接收数据的步骤
        1:创建接收端的Socket对象(DatagramSocket)
        2:创建一个数据包，用于接收数据
        3:调用DatagramSocket对象的方法接收数据
        4:解析数据包，并把数据在控制台显示
        5:关闭接收端
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        //DatagramSocket​(int port) 构造数据报套接字并将其绑定到本地主机上的指定端口
        DatagramSocket ds = new DatagramSocket(10086);

        //创建一个数据包，用于接收数据
        //DatagramPacket​(byte[] buf, int length) 构造一个 DatagramPacket用于接收长度为 length数据包
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys,bys.length);

        //调用DatagramSocket对象的方法接收数据
        ds.receive(dp);

        //解析数据包，并把数据在控制台显示
        //byte[] getData() 返回数据缓冲区
//        byte[] datas = dp.getData();
        //int getLength​() 返回要发送的数据的长度或接收到的数据的长度
//        int len = dp.getLength();
//        String dataString = new String(datas,0,len);
//        System.out.println("数据是：" + dataString);
        System.out.println("数据是：" + new String(dp.getData(),0,dp.getLength()));

        //关闭接收端
        ds.close();
    }
}

 

/*
    UDP发送数据：
        数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();

        //自己封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = br.readLine()) != null) {
            //输入的数据是886，发送数据结束
            if ("886".equals(line)) {
                break;
            }

            //创建数据，并把数据打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.119.44"), 12345);

            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }

        //关闭发送端
        ds.close();
    }
}

/*
    UDP接收数据：
        因为接收端不知道发送端什么时候停止发送，故采用死循环接收
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);

        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);

            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        }

        //关闭接收端
//        ds.close();
    }
}

/*
    TCP发送数据的步骤
        1:创建客户端的Socket对象(Socket)
        2:获取输出流，写数据
        3:释放资源
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket​(InetAddress address, int port) 创建流套接字并将其连接到指定IP地址的指定端口号
//        Socket s = new Socket(InetAddress.getByName("192.168.119.44"),10000);
        //Socket​(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("192.168.119.44",10001);

        //获取输出流，写数据
        //OutputStream getOutputStream​() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //释放资源
        s.close();
    }
}
/*
    TCP接收数据的步骤
        1:创建服务器端的Socket对象(ServerSocket)
        2:获取输入流，读数据，并把数据显示在控制台
        3:释放资源
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        //ServerSocket​(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10001);

        //Socket accept​() 侦听要连接到此套接字并接受它
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);
        System.out.println("数据是：" + data);

        //释放资源
        s.close();
        ss.close();
    }
}

/*
    客户端：发送数据，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        Socket s = new Socket("192.168.119.44", 10002);

        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //接收服务器反馈
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("客户端：" + data);

        //释放资源
//        is.close();
//        os.close();
        s.close();
    }
}
/*
    服务器：接收数据，给出反馈
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        ServerSocket ss = new ServerSocket(10002);

        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("服务器：" + data);

        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("数据已经收到".getBytes());

        //释放资源
//        s.close();
        ss.close();
    }
}

/*
    客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.119.44",10003);

        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }

            //获取输出流对象
//            OutputStream os = s.getOutputStream();
//            os.write(line.getBytes());
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        s.close();
    }
}
/*
    服务器：接收到的数据在控制台输出
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10003);

        //监听客户端的连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //获取输入流
//        InputStream is = s.getInputStream();
//        InputStreamReader isr = new InputStreamReader(is);
//        BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //释放资源
        ss.close();
    }
}


/*
    服务器：接收到的数据写入文本文件，给出反馈
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));

        String line;
        while ((line=br.readLine())!=null) { //等待读取数据
//            if("886".equals(line)) {
//                break;
//            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

//        System.out.println(11111);

        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bwServer.write("文件上传成功");
        bwServer.newLine();
        bwServer.flush();

        //释放资源
        bw.close();
        ss.close();
    }
}
/*
    客户端：数据来自于文本文件，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.119.44",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

//        System.out.println(22222);

        //自定义结束标记
//        bw.write("886");
//        bw.newLine();
//        bw.flush();

        //public void shutdownOutput​()
        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

        //释放资源
        br.close();
        s.close();
    }
}

/*
    客户端：数据来自于文本文件，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.119.44",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

        //释放资源
        br.close();
        s.close();
    }
}
/*
    服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //监听客户端连接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //为每一个客户端开启一个线程
            new Thread(new ServerThread(s)).start();
        }

//        ss.close();
    }
}

JAVA在开发hui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
网络编程-tcp实现ftp功能
SUN_QL_的博客
04-13 309
linux系统中通过网络编程用tcp实现ftp功能，实现网络通信
关于网络编程
weixin_53212110的博客
01-29 1877
关于Socket套接字，UDP，TCP等基础知识
java169-DatagramPacket 数据报包类
qq_41632427的博客
06-27 367
java
网络原理与网络编程初
m0_47265327的博客
04-04 121
网络原理 与网络编程初
DatagramPacket与DatagramSocket
最新发布
qq_50754735的博客
11-17 147
系统需要用UDP接收三类数据报文（不同长度），接收到对十进制转换成十六进制进行在线解析，进行一些校验并标记异常。
java使用DatagramSocket和DatagramPacket进行通信
qq_38345598的博客
06-03 5448
一、DatagramSocket DatagramSocket是使用UDP协议的Socket,它的作用是接收和发送数据包，但是它本身并不能产生IO流 1、创建DatagramSocket对象 DatagramSocket() //创建一个数据包套接字，绑定到本机上任意一个可用的端口 DatagramSocket(DatagramSocketImpl) //创建一个绑定的数据报套接字， 与指定的datagramsocketimpl相关（一般不使用） DatagramSocket(SocketAdd.
网络编程 udp tcp
08-22
网络编程是计算机科学中的一个重要领域，它涉及到通过网络在不同设备间交换数据。...通过编写和比较UDP和TCP的聊天程序，开发者能够深入理解这两种协议的优缺点，为今后的网络编程工作打下坚实基础。
java网络编程使用tcp、udp实现多用户对话
01-10
总之，Java网络编程使用TCP和UDP实现多用户对话，涉及到客户端与服务器的连接建立、数据传输、异常处理、多线程或异步编程、以及安全性等多个方面。通过学习和实践，可以掌握这些关键技术，为开发高效、稳定的网络...
Linux网络编程-TCP&UDP测试工具.zip
12-08
TCP&UDP测试工具
python网络编程 使用UDP、TCP协议收发信息详解
09-18
主要介绍了python网络编程 使用UDP、TCP协议收发信息详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
简单的聊天程序 网络编程 UDP TCP
01-11
TCP和UDP在网络编程中的结合也是常见的，比如可以使用TCP作为主要的消息传输通道，保证消息的可靠传输，同时利用UDP进行实时性的辅助信息交换，如位置更新或语音数据。这样可以在保证基本通信质量的同时，提升系统的...
UDP数据报DatagramSocket与DatagramPacket简单用法
Thisiwycf的博客
04-23 663
运行于本地主机DatagramSocket始终指向己方，DatagramPacket始终指向对方。
Java UDP通信：DatagramPacket与DatagramSocket 详解
热门推荐
s990420的博客
08-02 1万+
一、UDP协议简介 UDP（UserDatagramProtocol）是一个简单的面向消息的传输层协议，尽管UDP提供标头和有效负载的完整性验证（通过校验和），但它不保证向上层协议提供消息传递，并且UDP层在发送后不会保留UDP 消息的状态。因此，UDP有时被称为不可靠的数据报协议。如果需要传输可靠性，则必须在用户应用程序中实现。 UDP是基于IP的简单协议，不可靠的协议。 UDP的优点：简单，轻量化。 UDP的缺点：没有流控制，没有应答确认机制，不能解决丢包、重发、错序问题。 综上所述，UDP使用
UDP协议(多人聊天)
weixin_63719049的博客
02-12 1692
UDP协议(多人聊天)
网络通信 Datagram 实现UDP
Mr_Leixiansheng的博客
10-13 698
UdpServer 1、创建DatagramSocket，指定端口号 2、创建DatagramPacket,接收客户端发送的数据 3、接收客户端数据 4、读取数据 5、服务器反馈 UdpClient 1、定义发送信息、地址、端口 2、创建DatagramPacket ，包含要发送的信息 3、创建DatagramSocket 4、发送数据
Java网络编程（3）
weixin_52821030的博客
12-06 797
基于UDP协议的通信程序 1.什么的UDP，它的优缺点是什么？ UDP：用户数据报协议【无连接的协议】 优点：消耗小，效率高 缺点：不能保证数据的安全与可靠 2.建立基于UDP的网络通讯是不区分客户端和服务器 基于UDP的网络通讯程序是不区分客户端和服务器。 java.net.DatagramPacket---该类表示数据报包【打包被发送的数据/接收发来的数据】 构造方法： Da...
UDP通信
程序人生
04-01 262
UDP通信 1. 构建接收包DatagramPacket: 1、构造接收包-DatagramPacket(byte[] buf,int length) 将数据包中的length长的数据装进buf的数组中 -DatagramPacket(byte[] buf,int offset,int length) 将数据包中从offset开始，length长的数据装进buf的数组中2、构建发送包-Dat
Java中的DatagramPacket与DatagramSocket的初步
上帝派来的逗比
09-28 1102
1.基本概念： 　　a.DatagramPacket与DatagramSocket位于java.net包中 　　b.DatagramPacket表示存放数据的数据报，DatagramSocket表示接受或发送数据报的套接字 　　c.由这两个类所有构成的网络链接是基于UDP协议，是一种不可靠的协议。 　　之所以不可靠是因为发送方不负责数据是否发送成功，接收方收到数据时也不会
使用DatagramSocket发送, 接收数据(UDP协议)
十年
08-16 1573
这个世界收到了你们的信息。 我是这个世界的一个和平主义者，我首先收到信息是你们文明的幸运，警告你们：不要回答！不要回答！！不要回答！！！ 你们的方向有千万颗恒星，只要不回答，这个世界就无法定位发射源。如果回答，发射源将被定位，你们的行星体系将遭到入侵，你们的世界将被占领！ 不要回答！不要回答！！不要回答！！！...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值