本文主要是介绍使用java中Socket完成TCP协议或UDP协议通信，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

使用java中Socket完成TCP协议或UDP协议通信

介绍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 {
        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());
                                 //关闭流
                                 os.flush();
                                 os.close();
                                 is.close();
                                 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();

        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);

                        }
                        os.flush();
                        fis.close();
                        socket.close();

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


                }
            }).start();
        }
    }


}

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

这是我的目录

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

http://192.168.1.119:8811/src/Web/index.html

ip地址换成你服务的

这篇关于使用java中Socket完成TCP协议或UDP协议通信的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！