UDP和TCP通信

最新推荐文章于 2023-04-12 13:07:23 发布
最新推荐文章于 2023-04-12 13:07:23 发布
阅读量443 收藏
点赞数
分类专栏： 多线程 文章标签： udp tcp/ip java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46128623/article/details/127538999
版权

1.UDP服务端和客户端 “一对一” 和“ 多对多” 传送和接收信息

  • 一对一
import org.junit.Test;

import java.net.*;

public class TestUdp {

    //服务端
    @Test
    public  void serverTest() throws Exception {

        DatagramSocket socket=new DatagramSocket(8888);
        //创建一个数据包对象接收数据
        byte[] buffer=new byte[1024*64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        //等待接收数据
        socket.receive(packet);

        //取出数据
        int len = packet.getLength();
        String rs = new String(buffer,0,len);
        System.out.println(rs);
        socket.close();

    }
    //客户端
    @Test
    public  void clientTest() throws Exception {
        //创建发送对象（人）
        DatagramSocket socket = new DatagramSocket();
        //创建一个数据包对象封装数据
        byte[] buffer="我是一个快乐的韭菜盒子".getBytes();
        DatagramPacket packet=new DatagramPacket(buffer,buffer.length, InetAddress.getLocalHost(),8888);
        //3。发送数据
        socket.send(packet);
        socket.close();
    }

}
  • 多对多（组播）
import org.junit.Test;

import java.net.*;
import java.util.Scanner;
//测试组播
public class TestUdpgroupBrocastt {



    //服务端
    @Test
    public  void serverTest() throws Exception {

      //  DatagramSocket socket=new DatagramSocket(8888);
        //创建一个组播对象接口
        MulticastSocket socket=new MulticastSocket(9999);
        //把当前接收端加到一个组播组中，绑定对应的组播消息的组播IP
        //joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)
        socket.joinGroup(new InetSocketAddress(InetAddress.getByName("224.0.1.1"),9999),
                NetworkInterface.getByInetAddress(InetAddress.getLocalHost()));
        //创建一个数据包对象接收数据
        byte[] buffer=new byte[1024*64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        while (true) {
            //等待接收数据
            socket.receive(packet);
            //取出数据
            int len = packet.getLength();
            String rs = new String(buffer,0,len);
            System.out.println(rs);
            //获取发送端的IP和端口
            System.out.println("收到了来自:"+packet.getAddress()+",对方接口是:"+packet.getPort()+"的消息:"+rs);
        }
      //  socket.close();

    }



    //客户端
    @Test
    public  void clientTest() throws Exception {
        //创建发送对象（人）
        DatagramSocket socket  = new DatagramSocket();
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入内容:");
            String msg = sc.nextLine();
            if("exit".equals(msg)){
                socket.close();
                return;
            }
            //创建一个数据包对象封装数据
            byte[] buffer=msg.getBytes();
            DatagramPacket packet=new DatagramPacket(buffer,buffer.length,InetAddress.getByName("224.0.1.1"),9999);
            //3。发送数据
            socket.send(packet);
        }

    }

}
  1. TCP通信
//基础通信（存在的问题：当服务端接收不到数据就会报连接异常）
import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TestTcp {

    @Test
    public  void client() throws  Exception{
        //1.创建socket接口
        Socket socket = new Socket("127.0.0.1",7777);
        //2.从socket通信管道中得到一个字节输出流，负责发送给数据
        OutputStream os = socket.getOutputStream();
        //3.把低级的字节流包装成打印流
        PrintStream ps = new PrintStream(os);
        //4.发送消息
        ps.println("我是TCP 客户端，你要一起玩吗？");
        ps.flush();

    }

    @Test
    public  void server() throws IOException {
        //1.注册接口
        ServerSocket sserverocket = new ServerSocket(7777);
        //2.必须调用accept接口，，等待客户端的socket连接请求
        Socket socket = sserverocket.accept();
        //3.从socket中得到一个字节输入流

        InputStream is = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        //3.按行读取数据
        String msg;
        if((msg= br.readLine())!=null){
            System.out.println(socket.getRemoteSocketAddress()+"说了:"+msg);
        }


    }
}
  • TCP通信-多发多收消息
    待解决问题：1.目前服务端是单线程的，每次只能处理一个客户端的消息。（加入一个循环）
    2.客户端的端口只有一个（解决方式如下图）
    Allow multiple instances
package com.practies;

import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TestThreadTcp {
    @Test
    public  void client() throws IOException {
        Socket socket = new Socket("127.0.0.1",7777);
        OutputStream os = socket.getOutputStream();
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
        //关闭端口
        ///socket.close();
    }

    @Test
    public  void server(){
        try {
            System.out.println("服务器启动成功");
            ServerSocket ss=new ServerSocket(7777);
            while(true){
                //从socket管道接受数据
                Socket socket= ss.accept();
                //创建线程开始处理
                new ServerReaderThread(socket).start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //创建线程方法
    public   class  ServerReaderThread extends Thread{
        private  Socket socket;
        public  ServerReaderThread(Socket socket){
            this.socket=socket;
        }

        @Override
        public void run() {
            try {
                InputStream is = socket.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                String msg;
                while ((msg=br.readLine())!=null){
                    System.out.println(socket.getRemoteSocketAddress()+"说了:"+msg);
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
  • 上述代码存在的问题：当客户端反复发送数据时，服务端会一直创建线程，线程太多时，会占用系统cpu、资源等等，因此引入线程池
package com.practies;

import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.*;

public class TestThreadTcp2 {
    private static ExecutorService pool = new ThreadPoolExecutor(3,5,
            6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(2),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    @Test
    public  void client() throws IOException {
        Socket socket = new Socket("127.0.0.1",7777);
        OutputStream os = socket.getOutputStream();
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
        //关闭端口
        ///socket.close();
    }

    @Test
    public  void server(){
        //使用一个静态变量记住一个线程池对象
        try {
            System.out.println("服务器启动成功");
            ServerSocket ss=new ServerSocket(7777);
            while(true){
                //从socket管道接受数据
                Socket socket= ss.accept();
                //创建线程开始处理
                System.out.println(socket.getRemoteSocketAddress()+"它来了，上线了!");
                Runnable target = new ServerReadRunnable(socket);
                pool.execute(target);

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //创建线程方法
    public  class ServerReadRunnable implements Runnable {
        private  Socket socket;
        public  ServerReadRunnable(Socket socket){
            this.socket=socket;
        }

        @Override
        public void run() {
            try {
                InputStream is = socket.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                String msg;
                while ((msg=br.readLine())!=null){
                    System.out.println(socket.getRemoteSocketAddress()+"说了:"+msg);
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

        }
    }

}
  • TCP通信实战-即时通信（类似弹幕）
import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.*;

public class TestThreadTcp3 {
  //定义一个静态的list集合存储当前全部在线的socket
   public static List<Socket> allOnlineSockets= new ArrayList<Socket>();

    @Test
    public  void client() throws IOException {
        Socket socket = new Socket("127.0.0.1",7777);
        //创建一个独立的线程负责这个客户端的读消息
        new ClientReadThread(socket).start();
        OutputStream os = socket.getOutputStream();
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
        //关闭端口
        ///socket.close();
    }

    @Test
    public  void server(){
        try {
            System.out.println("服务器启动成功");
            ServerSocket ss=new ServerSocket(7777);
            while(true){
                //从socket管道接受数据
                Socket socket= ss.accept();
                allOnlineSockets.add(socket);
                //创建线程开始处理
                new  ServerReaderThread(socket).start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //创建线程方法
    public   class  ServerReaderThread extends Thread{
        private  Socket socket;
        public  ServerReaderThread(Socket socket){
            this.socket=socket;
        }

        @Override
        public void run() {
            try {
                InputStream is = socket.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                String msg;
                while ((msg=br.readLine())!=null){
                    System.out.println(socket.getRemoteSocketAddress()+"说了:"+msg);
                    //把消息发给全部的管道
                    sendMsgtoAll(msg);
                }
            } catch (IOException e) {
                System.out.println(socket.getRemoteSocketAddress()+",下线了，下次再来哦");
                allOnlineSockets.remove(socket);
            }
        }
    }
    public void sendMsgtoAll(String msg ) throws IOException {
        for (Socket socket : allOnlineSockets) {
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println(msg);
            ps.flush();
        }
    }


    public  class ClientReadThread extends Thread {
        private  Socket socket;
        public   ClientReadThread(Socket socket){
            this.socket=socket;
        }

        @Override
        public void run() {
            try {
                InputStream is = socket.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                String msg;
                while ((msg=br.readLine())!=null){
                    System.out.println("收到消息了。。。。。"+msg);
                }
            } catch (IOException e) {
                System.out.println("服务端把你踢出去了");
            }

        }
    }

}
  1. BS
    （1）、之前的客户端都是什么样的 。其实就是CS架构，客户端实需要我们自己开发实现的。
    (2)、BS结构是什么样的，需要开发客户端吗？ 浏览器访问服务端，不需要开发客户端。
package com.practies;

import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class BSServerTest {
    @Test
    public  void server(){
        try {
            System.out.println("服务器启动成功");
            ServerSocket ss=new ServerSocket(7777);
            while(true){
                //从socket管道接受数据
                Socket socket= ss.accept();
                //创建线程开始处理
                new ServerReaderThread(socket).start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //创建线程方法
    public   class  ServerReaderThread extends Thread{
        private  Socket socket;
        public  ServerReaderThread(Socket socket){
            this.socket=socket;
        }

        @Override
        public void run() {

            try {
                PrintStream ps = new PrintStream(socket.getOutputStream());
                //响应HTTP格式
                ps.println("HTTP/1.1 200 OK");
                ps.println("Content-Type:text/html;charset=UTF-8");
                ps.println();//按照HTTP要求必须发一个空行
                ps.println("<span style='color:red;font-size:90px'>哈哈</span>");
                ps.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }


        }
    }
}


package com.practies;

import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.*;

public class BSServerTest2 {
    private static ExecutorService pool = new ThreadPoolExecutor(3,5,
            6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(2),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());


    @Test
    public  void server(){
        //使用一个静态变量记住一个线程池对象
        try {
            System.out.println("服务器启动成功");
            ServerSocket ss=new ServerSocket(7777);
            while(true){
                //从socket管道接受数据
                Socket socket= ss.accept();
                //创建线程开始处理
                System.out.println(socket.getRemoteSocketAddress()+"它来了，上线了!");
                Runnable target = new ServerReadRunnable(socket);
                pool.execute(target);

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //创建线程方法
    public  class ServerReadRunnable implements Runnable {
        private  Socket socket;
        public  ServerReadRunnable(Socket socket){
            this.socket=socket;
        }

        @Override
        public void run() {
            try {
                PrintStream ps = new PrintStream(socket.getOutputStream());
                //响应HTTP格式
                ps.println("HTTP/1.1 200 OK");
                ps.println("Content-Type:text/html;charset=UTF-8");
                ps.println();//按照HTTP要求必须发一个空行
                ps.println("<span style='color:red;font-size:90px'>哈哈</span>");
                ps.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

        }
    }


}
lj66
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
浅谈TCP和UDP协议
m0_67266787的博客
05-16 468
目录 TCP和UDP的区别 UDP 特点： 使用场景 UDP变形 QUIC协议 直播中的帧 嵌入式 TCP TCP三次握手 TCP四次挥手 TCP状态机 TCP和UDP的区别 我们大多数人的回答是，TCP是面向连接的，UDP是面向无连接的。 那么什么是面向连接，什么是面向无连接？，再互通之前，面向连接的协议会先建立连接，例如：TCP会三次握手， 而UDP不会。 所谓的建立连接，是为了在客户端和服务端维护连接，而建立一定的数据结构来维护双方交互的状态，用这样的数据结构来保证所谓的面
UDP和TCP通信调试
09-08
方便调试udp tcp通信，及其串口，USB调试，各类字符串转换
TCP与UDP
MAKABAKA__ZJC的博客
06-07 542
TCP与UDP
通过UDP建立TCP连接
湖中岛——玄雨
05-10 1357
解释通过UDP广播查询服务器的IP地址，然后再建立TCP点对点连接。 应用场景在服务器IP未知时，并且已知服务器与客户端明确在一个局域网或者允许组播的子网下。通过UDP发现服务器地址然后再进行TCP连接（PS:万维网很多路由器对组播进行了限制，所以不能通过UDP报文在万维网上进行服务器查询）
UDP实现服务器和客户端通信
southernbrid的博客
04-12 2512
UDP (User Datagram Protocol) 是一种面向无连接的传输层协议，它不保证数据包的可靠性，但具有传输速度快的优点。在UDP通信中，数据包被封装在UDP数据报中，每个数据报包括目标端口号和源端口号，不需要在每个数据包中都建立连接或断开连接。UDP通信的工作方式与TCP通信不同。在TCP通信中，客户端和服务器之间需要先建立连接，然后才能传输数据。而在UDP通信中，客户端和服务器可以直接发送数据包，不需要事先建立连接。
网络 TCP/UDP协议(笔记)
weixin_60547084的博客
03-26 704
文章目录1. TCP协议2. UDP协议3. TCP与UDP的区别3.1 TCP 稳定可靠3.2 UDP 速度快 1. TCP协议 TCP协议类似于打电话，需要建立链接，TCP协议又分为以下三个步骤 三次握手，就是为了解决网络信道不可靠的问题 客户端先向服务端发送一个SYN包，询问能否建立链接 服务端同意链接后，向客户端发送一个SYN+ACK包 客户端收到后，在向服务端发送一个ACK包，因此建立连接 传输确认，会有丢包问题和乱序问题 发送缓冲：把数据分成0~N个字节 发送报文：TCP协议头中会附带
Windows下面的UDP和TCP通信demo
08-09
在IT领域，网络通信是计算机科学的一个重要组成部分，TCP（传输控制协议）和UDP（用户数据报协议）是两种广泛使用的传输层协议。本篇将深入探讨Windows环境下使用TCP和UDP进行通信的基本概念、实现方式以及相关的...
安川机器人与PLC进行UDP通信与TCP通信指导手册.zip
最新发布
08-28
综上，安川机器人与PLC的UDP和TCP通信涉及网络协议的选型、参数配置、编程实现以及错误处理等多个环节，理解并熟练掌握这些知识对于实现两者间的高效、可靠通信至关重要。在实际操作中，还需要结合具体的设备和项目...
TCP和UDP通信代码实现
07-15
在C#中，可以使用System.Net.Sockets命名空间中的TcpClient和TcpListener类来实现TCP通信。 首先，创建一个TcpListener实例，设置监听的IP地址和端口号，然后调用Start方法开始监听。当有客户端连接时，...
vc++UDP、TCP通信
06-13
基于VC++的TCPUDP通信实例代码，已经将代码打包并制作exe
TCP/UDP协议操作流程及接口介绍
要好好学习
09-12 1333
传输层的协议：TCP/UDP协议TCP：传输控制协议，面向连接，可靠传输，面向字节流；——应用于对安全性要求大于实时性的场景（文件传输等）；UDP：用户数据报协议，无连接，不可靠，面向数据报；——应用于对实时性性要求大于安全性的场景（视频、音频等）；①创建套接字：在内核中创建socket结构体，将进程与网卡关联起来；②为套接字绑定地址信息：给创建的socket结构体描述源端地址信息；③接收数据：从socket接收缓冲区中取出数据；④向服务器发送数据：将要发送的数据放入发送缓冲区；⑤关闭套接字；①创建套接字；
Server端和Client端常见的通信方式TCP/IP和UDP
zhaizhai的博客
06-24 7902
一、前提知识1）网络编程主要包括两种通信方式：TCP/IP通信和UDP通信；前者是属于可靠地，端到端的字节流通信协议；后者是一种不可靠的连接。2）Socket:两台机器建立一个双向的网络连接实现数据交换，这个双向链路的一端称为一个Socket；     Socket编程是网络编程所必须经历的，根据TCP协议和UDP协议的不同，在网络编程方面就有面向两个协议的不同socket，一个是面向字节流（TC...
TCP和UDP相关问题
SwitchD的博客
03-25 5083
目录一、网络基础1.OSI 七层模型划分为以下七层：（不实用）2.TCP/IP五层（或四层）模型二、UDP与TCP的区别三、如何基于UDP协议实现可靠传输（实际想说的是TCP）四、什么场景中适合使用TCP和UDP 一、网络基础 1.OSI 七层模型划分为以下七层：（不实用） 2.TCP/IP五层（或四层）模型 传输层（UDP和TCP都属于传输层） 传输层是操作系统内核实现的，一般都是现成的协议，很少会涉及到自定制。负责端对端的数据传输，只考虑起点和终点，不考虑中间过程。 二、UDP与TCP的区别 1.
udp与tcp两种服务器基本应用
q739404976的博客
01-15 311
Tcp   tcp的特点：   1. tcp协议通讯是面向连接的，tcp的客户端一旦建立，马上要与服务端建立连接。    2. tcp协议在连接中传输大数据量,tcp是基于IO流进行数据传输。   3. 通过三次握手机制连接，可靠协议(保证数据传输的完整性)   4. 因为tcp是面向连接的，所以效率稍低.    5. tcp协议是分客户端与服务端。      tcp协议下的So
C# Socket客户端与服务端通信_TCP和UDP
zls365365的博客
01-22 1274
客户端与服务端通信主要有两种模式，一种是TCP，一种是UDP。UDP速度最快,客户端只管发送，服务端是能接多少就接多少。一般应用到游戏行业。而TCP会保证两边能接收成功。下面做了一个简单的...
17、TCP和UDP网络通讯的区别及实现方式
M.y/g/c/w/f
02-29 1143
TCP：Transmission Control Protocol 传输控制协议TCP是一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议，在 OSI模型中，它完成第四层传输层所指定的功能。 UDP：是User Datagram Protocol的简称，用户数据包协议，是 OSI 参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务
解决TCP连接不上
qq_43570115的博客
03-11 9992
非常值得看的一篇文章！提供四种针对Tcp连接不上的问题的解决办法
socket通信udp和tcp区别
08-25
UDP（User Datagram Protocol）和TCP（Transmission Control Protocol）是两种在计算机网络中常用的传输协议。它们有以下几点主要区别： 1. 可靠性：TCP是面向连接的协议，提供可靠的数据传输。它通过使用确认和重...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值