Java-Socket(TCP协议或UDP协议)通信

胡安民

已于 2022-05-18 22:06:38 修改

阅读量1.7k

点赞数 2

CC 4.0 BY-SA版权

于 2021-09-14 09:00:58 首次发布

本文链接：https://blog.csdn.net/weixin_45203607/article/details/120252115

所有文章专栏收录该内容

622 篇文章

订阅专栏

本文详细介绍了TCP（面向连接的可靠传输）和UDP（无连接的不可靠传输）的区别，包括数据传输方式、可靠性、大小限制和应用场景，以及基于Socket的Java编程实例，涵盖了长连接、文件上传和简易网页服务器的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

介绍TCP和UDP

两类传输协议：TCP；UDP

TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

比较：

UDP：

1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。

2，UDP传输数据时是有大小限制的，每个被传输的数据包必须限定在64KB之内。

3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方

TCP：

1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接时间。
2，TCP传输数据大小限制理论是没有限制,但是受限于网速等其他设备限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大的数据。
3，TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。

应用：

1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

三，基于Socket的java网络编程

1，什么是Socket

网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。

但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

2，Socket通讯的过程

Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。

对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：

（1）创建Socket；

（2）打开连接到Socket的输入/出流；

（3）按照一定的协议对Socket进行读/写操作；

（4）关闭Socket

TCP协议的Socket通信

客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

//客服端
public class TCPClient {
    public static void main(String[] args) throws IOException {

        //创建和服务器连接
        Socket socket =new Socket("127.0.0.1",8888);
		
        //将客户端的 消息 发给 服务端
        OutputStream os = socket.getOutputStream();
        os.write("你好服务器".getBytes());
		//接受服务端返回来的消息
        InputStream is=socket.getInputStream();
        byte[] bytes=new byte[1024];
        int len=is.read(bytes);
        System.out.println(new String(bytes,0,len));
		//关闭 socket 通信
        socket.close();

    }
    
}

服务端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {


    public static void main(String[] args) throws IOException {
			//指定访问 客服端的 端口
        ServerSocket server=new ServerSocket(8888);
		// 接收客户端发送的数据。如果未收到会一致阻塞
        Socket socket=server.accept();
		// 读取请求 来的信息
        InputStream is=socket.getInputStream();
        byte[] bytes=new byte[1024];
        int len=is.read(bytes);
        System.out.println(new String(bytes,0,len));

		// 服务器  返回 消息  给客户端 
        OutputStream os= socket.getOutputStream();
        os.write("收到谢谢".getBytes());
        socket.close();
        server.close();



    }
}

先启动服务端然后在启动客服端否则就会报错连接失败因为没有找到服务器

最后效果就是 :

服务端接收到客服端发来的信息 你好服务器

而客户端接收到服务端返回的消息 收到谢谢

UDP 协议的Socket通信

客服端

package UDP;

import java.io.InputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SocketClient {

    public static void main(String[] args) {
        try {
            // 客户端要发送给服务器的消息
            String sendMsg = "客户端发送的消息";
            //发生内容 的长度
            int  sendMsgLength=sendMsg.getBytes().length;
            // 获取服务器的地址
            InetAddress addr = InetAddress.getByName("localhost");

            // 创建packet包对象，封装要发送的包数据和服务器地址和端口号
            DatagramPacket packet = new DatagramPacket(sendMsg.getBytes(),sendMsgLength , addr, 8088);

            // 创建Socket对象
            DatagramSocket socket = new DatagramSocket();
            // 发送消息到服务器
            socket.send(packet);

            //接服务器传 来的数据
            byte[] receBuf = new byte[1024];
            DatagramPacket recePacket = new DatagramPacket(receBuf, receBuf.length);
            socket .receive(recePacket);
            String receStr = new String(recePacket.getData(), 0 , recePacket.getLength());
            System.out.println( receStr);


            // 关闭socket
            socket.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

服务端

package UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SocketServer {

    public static void main(String[] args) {
        try {
            // 要接收的报文
            byte[] bytes = new byte[1024];
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length);

            // 创建socket并指定端口
            DatagramSocket socket = new DatagramSocket(8088);

            // 接收客户端发送的数据。如果未收到会一致阻塞
            socket.receive(packet);
            String receiveMsg = new String(packet.getData(),0,packet.getLength());
            System.out.println(receiveMsg);


            // 服务要发送给客户端的消息
            String sendMsg = "服务端发送的消息";
            //发生内容 的长度
            packet.setData(sendMsg.getBytes());
            packet.setLength(sendMsg.getBytes().length);
            // 创建packet包对象，封装要发送的包数据和服务器地址和端口号
            // 发送消息到服务器
            socket.send(packet);


            // 关闭socket
            socket.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }


}

先启动服务端然后在启动客服端否则客服端就会陷入无线等待中

最后效果就是 :

服务端接收到客服端发来的信息 客户端发送的消息

而客户端接收到服务端返回的消息 服务端发送的消息

socket长连接服务端的实现

前面的Client/Server程序只能实现Server和一个客户的对话。在实际应用中，往往是在服务器上运行一个永久的程序，它可以接收来自其他多个客户端的请求，提供相应的服务。为了实现在服务器方给多个客户提供服务的功能，需要对上面的程序进行改造，利用多线程实现多客户机制。服务器总是在指定的端口上监听是否有客户请求，一旦监听到客户请求，服务器就会启动一个专门的服务线程来响应该客户的请求，而服务器本身在启动完线程之后马上又进入监听状态，等待下一个客户的到来。

总结: 实现原理就是不关闭socket,然后加上多线程

以下案例使用的是 TCP协议的Socket通信

客户端

package chang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

//客服端
public class TCPClient {
    public static void main(String[] args) throws IOException {
    //发送100个客户端请求
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //和服务器创建连接
                        Socket socket =new Socket("127.0.0.1",8800);

                        OutputStream os = socket.getOutputStream();
                        String str="你好服务器====:___:";
                        os.write(str.getBytes());
						//服务器返回的信息
                        InputStream is=socket.getInputStream();
                        byte[] bytes=new byte[1024];
                        int len=is.read(bytes);
                        System.out.println(new String(bytes,0,len));

                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }





    }

}

长连接服务端

package chang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TCPServer {



    public static void main(String[] args) throws IOException {

        ServerSocket server=new ServerSocket(8800);
                while (true){
                // 监听客户端的请求,没有的话就会进行阻塞
                     Socket socket=server.accept();
					//开启一个线程进行处理客户端的请求
                     new  Thread(new Runnable() {
                         @Override
                         public void run() {
                             try {

                                 InputStream is=socket.getInputStream();
                                 byte[] bytes=new byte[1024];
                                 int len=is.read(bytes);
                                 System.out.println(new String(bytes,0,len));
                                 OutputStream os= socket.getOutputStream();
                                 //响应给客户端
                                 os.write("收到谢谢".getBytes());
                                 socket.close();
                             } catch (IOException e) {
                                 e.printStackTrace();
                             }


                         }
                     }).start();
                 }

        }

}

将服务端开启后就能不断的,接收客户端请求服务端

当然客户端也能实现长连接参照服务端就行了,代码差不多但是要注意使用长连接不能关闭socket也就是并不能使用这个代码 socket.close();UDP协议的Socke 也一样参照上面代码就行

上传文件案例

可以实现多个用户同时上传一个服务器里下面利用多线程实现的

客户端

package io;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

//客服端
public class TCPClient {
    public static void main(String[] args) throws IOException {

        new  Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    FileInputStream fis=new FileInputStream("src\\io\\client\\1.png");
                    //和服务器创建连接
                    Socket socket =new Socket("127.0.0.1",8811);
                    OutputStream os = socket.getOutputStream();
                    int len=0;
                    byte[] bytes=new byte[1024];
                    while ((len=fis.read(bytes))!=-1){
                        os.write(bytes,0,len);
                    }
                    socket.shutdownOutput(); //结束发送数据
                    InputStream is=socket.getInputStream();
                    byte[] bytes1=new byte[1024];
                    int len1=0;
                    while ((len1=is.read(bytes1))!=-1){
                        System.out.println(new String(bytes1,0,len1));
                    }
                    //将打开的文件关闭
                    fis.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

}

服务端

package io;

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

public class TCPServer {


    public static void main(String[] args) throws IOException {

        ServerSocket server=new ServerSocket(8811);
        while (true){
        Socket socket=server.accept();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    InputStream is=socket.getInputStream();
                    File file=new File("src\\io\\server");
                    if(file.exists()){
                        file.mkdirs();
                    }

                    //自定义文件名
                    String filename="it"+System.currentTimeMillis()+new Random().nextInt(99999)+".jpg";

                    FileOutputStream fos=new FileOutputStream(file+"\\"+filename);
                    int len=0;
                    byte[] bytes=new byte[1024];
                    while ((len=is.read(bytes))!=-1){
                        fos.write(bytes,0,len);
                    }

                    OutputStream os= socket.getOutputStream();
                    os.write("上传成功".getBytes());
                    //将打开的文件关闭
                    fos.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        }


    }
}

先启动服务端然后在使用客户端上传

模拟网页服务器

package Web;

import sun.security.util.Length;

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8811);
        while (true) {
            Socket socket = server.accept();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        InputStream is = socket.getInputStream();
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        String line = br.readLine();
                        System.out.println(line);
                        String[] arr = line.split(" ");
                        //获取网页中请求的路径
                        String htmlpath = arr[1].substring(1);
                        //读取请求路径的文件
                        FileInputStream fis = new FileInputStream(htmlpath);
                        OutputStream os = socket.getOutputStream();
                        //写入http协议 响应头  固定写法
                        os.write("HTTP/1.1 200 ok\r\n".getBytes());
                        os.write("Content-Type:text/html\r\n".getBytes());
                        //必须写入空行,否则游览器不解析
                        os.write("\r\n".getBytes());

                        //将游览器请求的 路径文件内容 读给游览器
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = fis.read(bytes)) != -1) {
                            os.write(bytes, 0, len);

                        }
                        //将打开的文件关闭
                        fis.close();
                        socket.close();

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


                }
            }).start();
        }
    }


}

我创建的是一个普通的java项目,在src下面创建一个Web文件夹

这是我的目录

先开启服务器然后在游览器中输入

http://192.168.1.119:8811/src/Web/index.html , ip地址换成你服务的

注意

不建议在Socket里用BufferedOutputStream,BufferedInputStream和BufferedWriter,BufferedReader进行网络发收送数据,会出现各种未知现象,而且也加快不了啥速度可能还会慢,因为Socket是网络数据的传输,而不是物理传输,使用缓存流的目的是每次多从磁盘中能多拿点数据而已,而在网络中拿数据取决你的网速,理论上只服务端和客户端的网速同一水平并且足够快,那么读写的速度就会非常快的

点赞 -收藏加 -关注便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复感谢,配合,希望我的努力对你有帮助^_^