Socket通信

最新推荐文章于 2025-07-06 20:33:07 发布
最新推荐文章于 2025-07-06 20:33:07 发布
阅读量241 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 基础总结 文章标签： 网络编程--Socket通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Abner_G/article/details/90311037
本文详细介绍了Socket通信中TCP和UDP协议的实现。TCP协议部分阐述了客户端和服务器端Socket的创建、数据收发及资源释放，还说明了多客户端通信的实现思路；UDP协议部分介绍了客户端和服务器端的数据发送、接收及回应流程。

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

Socket通信

在这里插入图片描述

一.TCP协议

1.Socket:客户端的Socket
*
1.创造客户端的Socket
*
2.通过输出流，请求发出
*
3.输入流接收服务器的回应 //首先关闭客户端的输出流 客户端.shutdownOutput( )方法，得到输入流读取回应
*
4.释放资源

package cn.com.abner.intener.TCPdemo1.传数据;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Coco1 {
    public static void main(String[] args) {
        //客户端接口
        try {
            Socket coco=new Socket("localhost",5000);
            String info="Abner";
            OutputStream a=coco.getOutputStream();
            byte[] infos=info.getBytes();
            a.write(infos);
            
            //输入流接收服务器的回应
            coco.shutdownOutput();   //关闭客户端的输出流
            InputStream d=coco.getInputStream();
            BufferedReader f=new BufferedReader(new InputStreamReader(d));
            String reply;
            while((reply=f.readLine())!=null) {
                System.out.println("服务器回应"+reply);
            }
            f.close();
            d.close();
            a.close();
            coco.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }        
    }
}
*

2.ServerSocket：服务器端的Socket
*
1.创建一个Socket
*
2.监听的方法 accept( ) //监听并接收到端口中
*
3.获得输入流，获得用户请求 //服务器的输入流即为来自客户端的输入
*
4.回应客户端：通过输出流回应客户端 //服务器的输出流即为往客户端输出
*
5.释放相应资源

package cn.com.abner.intener.TCPdemo1.传数据;

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

public class Server1 {
    public static void main(String[] args) {
        //获取端口
        try {
            ServerSocket server=new ServerSocket(5000);
            //监听
            Socket coco=server.accept();
            //输入流
            InputStream a=coco.getInputStream();            //服务器的输入即为从客户端的输入
            BufferedReader b=new BufferedReader(new InputStreamReader(a));
            String info;
            while((info=b.readLine())!=null) {
                System.out.println("客户输入"+info);
            }
            
            //给客户端一个回应
            String reply=" 欢迎登陆";
            //通过输出流
            OutputStream c=coco.getOutputStream();            //服务器的输出即为往客户端的输出
            c.write(reply.getBytes());
            
            //关
            c.close();
            b.close();
            a.close();
            coco.close();
            server.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

*** 传递对象之前，必须实现Serializable接口**

package cn.com.abner.intener.TCPdemo2传对象;
import java.io.Serializable;
public class person implements Serializable {
     private String name;
     private String mima;
     
     public person() {
     }
     public person(String name, String mima) {
          this.name = name;
          this.mima = mima;
     }
     public String getName() {
          return name;
     }
     public void setName(String name) {
          this.name = name;
     }
     public String getMima() {
          return mima;
     }
     public void setMima(String mima) {
          this.mima = mima;
     }
     
}
package cn.com.abner.intener.TCPdemo2传对象;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server1 {
    public static void main(String[] args)  {
        //获取端口
        try {
            ServerSocket server=new ServerSocket(5000);
            //监听
            Socket coco=server.accept();
            //输入流
             InputStream a=coco.getInputStream();
            ObjectInputStream b=new ObjectInputStream(a);
            
            person ps = null;
            try {
                ps = (person)b.readObject();
                System.out.println("客户端输入姓名为 "+ps.getName()+"密码为 "+ps.getMima());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    

            
            //给客户端一个回应
            String reply=" 欢迎登陆";
            //通过输出流
            OutputStream c=coco.getOutputStream();            //服务器的输出即为往客户端的输出
            c.write(reply.getBytes());
            
            //关
            c.close();
            b.close();
            a.close();
            coco.close();
            server.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package cn.com.abner.intener.TCPdemo2传对象;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Coco1 {
    public static void main(String[] args) {
        //客户端接口
        try {
            Socket coco=new Socket("localhost",5000);
            //发送请求
            person ps=new person("Abner","12345");
            
            OutputStream a=coco.getOutputStream();
            ObjectOutputStream b=new ObjectOutputStream(a);
            
            b.writeObject(ps);
            
            //输入流接收服务器的回应
            coco.shutdownOutput();   //关闭客户端的输出流
            InputStream d=coco.getInputStream();
            BufferedReader f=new BufferedReader(new InputStreamReader(d));
            String reply;
            while((reply=f.readLine())!=null) {
                System.out.println("服务器回应"+reply);
            }
            f.close();
            d.close();
            a.close();
            b.close();
            coco.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
}

3.实现多客户端通行
*
思路：在服务器端根据不同的客户端执行不同的线程

package cn.com.abner.intener.TCPdemo3多线程;
import java.io.Serializable;
public class person implements Serializable {
     private String name;
     private String mima;
     
     public person() {
     }
     public person(String name, String mima) {
          this.name = name;
          this.mima = mima;
     }
     public String getName() {
          return name;
     }
     public void setName(String name) {
          this.name = name;
     }
     public String getMima() {
          return mima;
     }
     public void setMima(String mima) {
          this.mima = mima;
     }
     
}
	*

线程类
*
接收客户端请求，回复回应
每一个线程构造方法绑定一个客户端的socket
*/

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.Socket;

public class ServerThread extends Thread{
    private Socket coco;
    //每一个线程构造方法绑定一个客户端的socket
    public ServerThread(Socket coco) {
        this.coco = coco;
    }
    
    //接收客户端请求，回复回应
    public void run() {

        try {
        //输入流
        InputStream a=coco.getInputStream();
        ObjectInputStream b=new ObjectInputStream(a);
        
        person ps = null;
        try {
            ps = (person)b.readObject();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("客户端输入姓名为 "+ps.getName()+"密码为 "+ps.getMima());
        
        //获得客户端的IP
        InetAddress ia=coco.getInetAddress();
        String IP=ia.getHostAddress();
        System.out.println("相对应的IP为 "+IP);


        
        //给客户端一个回应
        String reply=" 欢迎登陆";
        //通过输出流
        OutputStream c=coco.getOutputStream();            //服务器的输出即为往客户端的输出
        c.write(reply.getBytes());
        
        //关
        c.close();
        b.close();
        a.close();
        coco.close();
        }catch(Exception ex) {
            ex.printStackTrace();
        }
    }
}
*

服务器端
*
1.获取服务器端口
*
2.监听 //因为要接收多个客户端请求，要一直处于监听状态（无限循环实现）
*
3.在循环内，监听–>创建一个和该客户端响应的线程–>启动线程

package cn.com.abner.intener.TCPdemo3多线程;
//服务器端
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args)  {
        //获取端口
        try {
            ServerSocket server=new ServerSocket(5000);
            //一直监听状态
            while(true) {
            Socket coco=server.accept();
            //创建一个和该客户端响应的线程
            ServerThread a=new ServerThread(coco);
            //启动线程
            a.start();
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
*

客户端不发生变化
*
1.创造客户端的Socket
*
2.通过输出流，请求发出
*
3.输入流接收服务器的回应 //首先关闭客户端的输出流 客户端.shutdownOutput( )方法，得到输入流读取回应
*
4.释放资源

package cn.com.abner.intener.TCPdemo3多线程;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Coco1 {
    public static void main(String[] args) {
        //客户端接口
        try {
            Socket coco=new Socket("localhost",5000);
            //发送请求
            person ps=new person("Abner","12345");
            
            OutputStream a=coco.getOutputStream();
            ObjectOutputStream b=new ObjectOutputStream(a);
            
            b.writeObject(ps);
            
            //输入流接收服务器的回应
            coco.shutdownOutput();   //关闭客户端的输出流
            InputStream d=coco.getInputStream();
            BufferedReader f=new BufferedReader(new InputStreamReader(d));
            String reply;
            while((reply=f.readLine())!=null) {
                System.out.println("服务器回应"+reply);
            }
            f.close();
            d.close();
            a.close();
            b.close();
            coco.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }

}

二.UDP协议

DatagramSocket (服务器客户端)
*
1.客户端
*
发送数据
*
1.定义发送数据
*
2.将数据打散到byte数组中
*
3.获取对方的主机
*
4.创造客户端发送端口
*
5.将数据打包成数据包(需要2的字节数组，和3的对方主机，才能完成打包)
*
6.客户端口发送数据包（需要4的客户端口和5的数据包，才能完成发送）
*
收取服务器回应
*
1.定义收取包
*
2.在端口把数据包放在收取包中
*
3，取出数据包中的数据
*
释放资源

package cn.com.abner.intener.UDPdemo1数据;

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

public class Coco {
    public static void main(String[] args) {
        //数据
        String info="Allen";
        //打散数据
        byte[] infos=info.getBytes();
        //对方的地址和端口
        InetAddress ia;
        //创造端口
        DatagramSocket coco;
        try {
            ia = InetAddress.getByName("localhost");
        
        //将数据打包成数据包
        DatagramPacket dp=new DatagramPacket(infos, infos.length,ia ,5000 );
        
        coco=new DatagramSocket();
        //端口发送数据
        coco.send(dp);
        
        //收取服务器回应
        //收取包
        byte[] replys=new byte[1024];
        DatagramPacket rp=new DatagramPacket(infos,infos.length);
        //端口接收
        coco.receive(rp);
        //取出数据包中的数据
        String reply=new String(rp.getData(),0,rp.getData().length);
        System.out.println("服务器回应 "+reply);
        
        coco.close();    
        
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }catch (SocketException e1) {
            e1.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

}

2.服务器端
收取服务器回应
1.定义收取包
2.创造服务器的接收端
3.在端口把数据包放在收取包中
4.取出数据包中的数据
回应客户端
1.定义回应数据
2.获取服务器中的端口地址
3.打包回应的数据
4.发送回应数据包
释放资源
package cn.com.abner.intener.UDPdemo1数据;

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

public class Server {
    public static void main(String[] args) {
        //收取包
        byte [] infos=new byte[1024];
        DatagramPacket dp=new DatagramPacket(infos,infos.length);
        //创造接收端口
        try {
            DatagramSocket server=new DatagramSocket(5000);
            //取出数据到收取包中
            server.receive(dp);
            //取出数据包中的数据
            String info=new String(dp.getData(),0,dp.getData().length);
            System.out.println("客户端输入 "+info);
            
        //给客户端回应
            String reply="OK";
            byte[] replys=reply.getBytes();
            //获得服务器的端口地址
            SocketAddress ia=dp.getSocketAddress();
            //打包回应数据
            DatagramPacket rp=new DatagramPacket(replys, 0, replys.length,ia);
            //发送数据包
            server.send(rp);
            
            server.close();
        } catch (SocketException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

}
网络通信（基于TCP/IP实现客户端/服务器的通信）
weixin_65029285的博客
08-13 1493
被连接者需要完成的任务（服务端）：1、创建socket内核对象，内核创建完成后会返回它的描述符（该描述只是为了完成连接，三次握手）2、准备本机地址(ip地址+端口号)3、绑定(把本机地址与socket对象进行绑定)4、开启监听，并设置排队的队列长度5、等待连接，连接成功后，内核会再返回一个连接成功的Socket描述符，专门用来通信for(;;
unity与winform 使用socket通信.rar
08-07
在Unity与Winform之间使用Socket通信时，通常会创建一个服务器端（通常是Winform应用）来监听特定的端口，等待客户端（Unity应用）的连接请求。一旦连接建立，双方就可以通过发送和接收数据进行通信。 在Winform中...
socket通信
WalleChoy's blog
06-16 483
一.服务端服务端开启socket，端口 开输入流监听客户端信息 读取客户端传来的信息并处理 开启输出流并写出数据二.客户端开启socket端口 写出待处理数据 开启输入流读取获取服务端传来的信息附注：server:public class Service { public static void main(String[] args) throws IOException {
网络编程底层通信（socket）
最新发布
weixin_46287157的博客
07-06 1088
socket（套接字）是网络通信的端点，是应用层与传输层之间的接口。它允许不同主机或同一主机的不同进程之间进行通信：参数见下表proto（通常省略）：协议号，通常为0，表示使用默认协议 socket.IPPROTO_TCP：6 socket.IPPROTO_UDP：17 socket.IPPROTO_ICMP ：1fileno：文件描述符，可选参数，如果指定，将从指定的文件描述符创建一个套接字对象通常使用如下简洁方法创建TCP/IPUDP/IPfamily参数描述常见用途。
S7-1200与ABB机器人进行SOCKET通信的具体方法示例.docx
07-06
SOCKET通信基于TCP/IP协议，提供了一种程序间通信的方式，为数据交换提供了端口和通道。 首先，ABB 机器人需启用616-1 PC Interface 选项，这是进行SOCKET通信的基础。在RobotStudio软件中，选择合适的ABB机器人...
Socket调试助手，该助手可用于调试socket通信，包含socket客户端，socket服务器，udp客户端，udp服务器
10-28
Socket调试助手，该助手可用于调试socket通信，包含socket客户端，socket服务器，udp客户端，udp服务器
Android中socket通信简单实现
01-03
Android中socket通信简单实现 socket通信需要有一个服务器和客户端，可以把同一个APP作为服务器跟客户端，也可以分开成两个APP。 先上个图： 这里以一个APP作为服务器跟客户端为示例 1、添加网络访问权限 2、写...
Socket通讯
丕子李
06-30 950
这是一个同学做的。放在这里供以后参考。 ############################## server.c ############################## #include #include #include #include #include #include #include #include #include #inclu
socket 通信
w418856的博客
06-27 1044
WebSocket是HTML5下一种新的协议（websocket协议本质上是一个基于tcp的协议）它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的Websocket是一个持久化的协议首先，客户端发起http请求，经过3次握手后，建立起TCP连接；http请求里存放WebSocket支持的版本号等信息，如：Upgrade、Connection、WebSocket-Version等；然后，服务器收到客户端的握手请求后，同样采用HTTP协议回馈数据；
Socket 通信
qq_42168856的博客
03-21 649
socket通信 一、socket通信基本原理 socket是基于应用服务与TCP/IP通信之间的一个抽象，他将TCP/IP协议里面复杂的通信逻辑进行分装，对用户来说，只要通过一组简单的API就可以实现网络的连接。 服务端初始化ServerSocket，对指定的端口进行绑定，然后对端口及进行监听，通过调用accept方法阻塞端口。此时，客户端有一个socket连接到服务端，那么服务端通过监听和...
控制台Socket通信编程实践
基于控制台的Socket通信是计算机网络编程中的一种基础且经典的技术实现方式。Socket通信允许位于不同主机的程序通过网络进行数据交换。控制台Socket通信通常涉及客户端和服务器两部分，其中服务器负责监听来自客户端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Abner G

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值