服务端代码：

import socket
import time

print("服务端开启")
# 创建套接字
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置IP和端口
# host = socket.gethostname()
host = '127.0.0.1'
port = 3333
# bind绑定该端口
mySocket.bind((host, port))
# 监听
mySocket.listen(10)
while True:
    # 接收客户端连接
    print("等待连接....")
    client, address = mySocket.accept()
    print("新连接")
    print("IP is %s" % address[0])
    print("port is %d\n" % address[1])
    while True:
        # 发送消息
        msg = "连接成功"
        client.send(msg.encode(encoding='utf-8'))
        print("发送完成")
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))  # 格式化时间戳为标准格式
        if msg == "EOF":
            break
        if msg == "quit":
            client.close()
            mySocket.close()
            print("程序结束\n")
            exit()

        # 读取消息
        msg = client.recv(1024)
        print("服务端接收:", msg.decode("utf-8"))  # 把接收到的数据进行解码
        print("读取完成")
        if msg == b"EOF":
            break
        if msg == b"quit":
            client.close()
            mySocket.close()
            print("程序结束\n")
            exit()

客户端代码：连接后保持连接

import socket

print("客户端开启")
# 创建套接字
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置ip和端口
# host = socket.gethostname()
host = '127.0.0.1'
port = 3333

try:
    mySocket.connect((host, port))  ##连接到服务器
    print("连接到服务器")
except:  ##连接不成功，运行最初的ip
    print('连接不成功')

while 1:
    # 接收消息
    msg = mySocket.recv(1024)
    print("客户端接收：%s" % msg.decode("utf-8"))  # 把接收到的数据进行解码
    print("读取完成")
    if msg == b"EOF":
        break
    if msg == b"quit":
        mySocket.close()
        print("程序结束\n")
        exit()

    # 发送消息
    msg = input("客户端发送:")
    mySocket.send(msg.encode(encoding='utf-8'))
    print("发送完成")
    if msg == "EOF":
        break
    if msg == "quit":
        mySocket.close()
        print("程序结束\n")
        exit()
print("程序结束\n")

客户端代码：发送后自动断开连接

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',3333))
msg = sk.recv(1024).decode('utf-8')  # 最多接受1024字节
print(msg)
sk.send('你好'.encode('utf-8'))
#sk.close()

（一）Socket概念：

socket时TCP/IP协议的抽象，是操作系统对外开放的接口

socket起源于unix，京客户端和服务端各自管理一个文件，是其能分别对文件进行读写操作
socket的通信流程：

(二)代码实现：

运行代码时要先运行服务器端，在运行客户端

编写TCP和UDP实现服务端与客户端的通信：

只能固定发送数据

TCP实现：

服务器端实现：

• 创建Socket，并将socket绑定端口
• while循环使得socket一直在等待状态
• 监听端口
• 获取客户端请求信息后，执行相关业务逻辑

import java.net.ServerSocket;
import java.net.Socket;
        public class TCPServer{
             public static void main(String []agrs)throws Exception{
                  ServerSocket ss=new ServerSocket(65000);      //创建Socket，并将socket绑定端口
                  while(true){                                 //while循环使得socket一直在等待状态
                      Socket socket=ss.accept();               //监听端口
                      new LengthCalculator(socket).start();     //获取客户端请求信息后，执行相关业务逻辑
                      }
                 }
   }

线程运行持续获得客户端的请求后，回送信息：

• 获取socket输入流
• 获取socket输出流
• buff读取输入内容
• 将接受流的byte数组转化为字符串
• 回送客户端字符串长度
• 关闭

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class LengthCalculator extends Thread{
            private Socket socket;
            public LengthCalculator(Socket socket){
                   this.socket=socket;
                   }
             public void run(){
                     try{
                          //获取socket输入流
                          OutputStream os=socket.getOutputStream();   
                          //获取socket输出流
                          InputStream is=socket.getInputStream();
                          int ch=0;
                          //buff读取输入内容
                          byte[]buff=new byte[1024];
                          ch=is.read(buff);
                          //将接受流的byte数组转化为字符串
                          String content=new String(buff,0,ch);
                          //回送客户端字符串长度
                             os.write(String.valueOf(content.length()).getBytes());
                          //关闭
                          is.close();
                          os.close();
                          socket.close();
                  }catch(IOException e){
                  e.printStackTrace();
         }
      }
  }

客户端的实现：

• 创建socket，并指定连接端口
• 获取输出流
• 获取输入流
• 将要传递给server的字符串转换为byte数组
• buff读取输入内容
• ch获取读取长度
• 关闭输入流及socket

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

    public class TCPClient{
         public static void main(String []args)throws Exception{
               //创建socket，并指定连接端口
                Socket socket=new Socket(new InetSocketAddress("127.0.0.1",65000);
                //获取输出流
                OutputStream os=socket.getOutputStream();
                //获取输入流
                InputStream is=socket.getInputStream();
                //将要传递给server的字符串转换为byte数组
                os.write(new String("hello world").getBytes());
                int ch=0;
                //buff读取输入内容
                byte[]buff=new byte[1024];
                //ch获取读取长度
                ch=is.read(buff);
                String connect=new String (buff,0,ch);
                System.out.println(connect);
                //关闭输入流及socket
                is.close();
                os.close();
                socket.close();
          }
     }

UDP实现：

运行代码时要先运行服务器端，在运行客户端
服务器端：

• 服务器端接受客户端发送的数据报
  • 监听端口号
  • 存储从客户端接收的内容
  • 将客户端发送的内容封装进入DatagramPacket中
  • 将数据从二进制转化为字符串的形式
  • 将要发送的信息转化为二进制
• 服务端发送数据报
  • 从DatagramPacket对象中获取到数据的来源地址和端口号
  • 发送数据给客户端

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

        public class UDPServer{
            public static void main(String []args)  throws Exception{
            //服务器端接受客户端发送的数据报
             //监听端口号
                DatagramSocket socket=new DatagramSocket(65001);
                //存储从客户端接收的内容
                byte[]buff=new byte[100];
                //将客户端发送的内容封装进入DatagramPacket中
                DatagramPacket packet=new DatagramPacket(buff,buff.length);
                socket.receive(packet);
                //将数据从二进制转化为字符串的形式
                byte[]data=packet.getData();
                String content=new String(data,0,packet.getLength());
                System.out.println(content);
               // 将要发送的信息转化为二进制
               byte[]sendedContent=String.valueOf(content.length()).getBytes();
            
            //服务端发送数据报
            //从DatagramPacket对象中获取到数据的来源地址和端口号
              DatagramPacket packetToClient=new DatagramPacket(sendedContent,sendedContent.length,packet.getAddress(),packet.getPort());
              //发送数据给客户端
              socket.send(packetToClient);
             }
        }  
            

客户端实现：

• 客户端给服务器端发送数据
  • 存储要发送的数据
  • 将IP地址封装成InetAddres对象
  • 将要发送给服务器端的数据封装为DatagramPacket对象，要写上ip与端口号
  • 发送数据给服务器
• 客户端接收服务器的数据
  • 创建DatagramPacket对象来存储服务器发送的数据
  • 将服务器端发送的数据取出并打印到控制台

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

public class UDPClient{
      public static void main(String[]args)throws Exception{
                  //客户端给服务器端发送数据
                 DatagramSocket socket=new DatagramSocket();
                 //存储要发送的数据
                 byte[]buf="hello world".getBytes();
                 //将IP地址封装成InetAddres对象
                 InetAddress address=InetAddress.getByName("127.0.0.1");
                 //将要发送给服务器端的数据封装为DatagramPacket对象，要写上ip与端口号
                 DatagramPacket packet=new DatagramPacket(buf,buf.length,address,65001);
                 //发送数据给服务器
                 socket.send(packet);
                         
                    //客户端接收服务器的数据
                    byte[]data=new byte[100];
                    //创建DatagramPacket对象来存储服务器发送的数据
                    DatagramPacket receivedPacket=new DatagramPacket(buf,buf.length);
              
                 socket.receive(receivedPacket);
                 //将服务器端发送的数据取出并打印到控制台
                 String content=new String(receivedPacket.getData(),0,receivedPacket.getLength());
                 System.out.println(content);
        }
    }

（三）升级版

可从键盘输入数据并发送

import java.io.*;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;

public class Client {
	public static void main(String[] args) throws IOException {
		Socket socket = new Socket();
		// 连接本地
		socket.setSoTimeout(3000);
		 // 连接本地，端口2000；超时时间3000ms
	    socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), 2000), 3000);

	    System.out.println("已发起服务器连接，并进入后续流程～");
	    System.out.println("客户端信息：" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
	    System.out.println("服务器信息：" + socket.getInetAddress() + " P:" + socket.getPort());

	    try {
	        // 发送接收数据
	        todo(socket);
	    } catch (Exception e) {
	        System.out.println("异常关闭");
	    }

	    // 释放资源
	    socket.close();
	    System.out.println("客户端已退出～");

	}

	private static void todo(Socket client) throws IOException {
	    // 构建键盘输入流
	    InputStream in = System.in;
	    BufferedReader input = new BufferedReader(new InputStreamReader(in));
	    // 得到Socket输出流，并转换为打印流
	    OutputStream outputStream = client.getOutputStream();
	    PrintStream socketPrintStream = new PrintStream(outputStream);
	    // 得到Socket输入流，并转换为BufferedReader
	    InputStream inputStream = client.getInputStream();
	    BufferedReader socketBufferedReader = new BufferedReader(new InputStreamReader(inputStream));

	    boolean flag = true;
	    do {
	        // 键盘读取一行
	        String str = input.readLine();
	        // 发送到服务器
	        socketPrintStream.println(str);
	        // 从服务器读取一行
	        String echo = socketBufferedReader.readLine();
	        if ("bye".equalsIgnoreCase(echo)) {
	            flag = false;
	        }else {
	            System.out.println(echo);
	        }
	    }while (flag);

	    // 资源释放
	    socketPrintStream.close();
	    socketBufferedReader.close();

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(2000);
        System.out.println("服务器准备就绪～");
        System.out.println("服务器信息：" + server.getInetAddress() + " P:" + server.getLocalPort());
        // 等待客户端连接
        for (; ; ) {
            // 得到客户端
            Socket client = server.accept();
            // 客户端构建异步线程
            ClientHandler clientHandler = new ClientHandler(client);
            // 启动线程
            clientHandler.start();
        }

    }

    /**
     * 客户端消息处理
     */
    private static class ClientHandler extends Thread {
        private Socket socket;
        private boolean flag = true;

        ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            super.run();
            System.out.println("新客户端连接：" + socket.getInetAddress() +
                    " P:" + socket.getPort());

            try {
                // 得到打印流，用于数据输出；服务器回送数据使用
                PrintStream socketOutput = new PrintStream(socket.getOutputStream());
                // 得到输入流，用于接收数据
                BufferedReader socketInput = new BufferedReader(new InputStreamReader(
                        socket.getInputStream()));

                do {
                    // 客户端拿到一条数据
                    String str = socketInput.readLine();
                    if ("bye".equalsIgnoreCase(str)) {
                        flag = false;
                        // 回送
                        socketOutput.println("bye");
                    } else {
                        // 打印到屏幕。并回送数据长度
                        System.out.println(str);
                        socketOutput.println("回送：" + str.length());
                    }

                } while (flag);

                socketInput.close();
                socketOutput.close();

            } catch (Exception e) {
                System.out.println("连接异常断开");
            } finally {
                // 连接关闭
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("客户端已退出：" + socket.getInetAddress() +
                    " P:" + socket.getPort());

        }
    }
}

服务器端运行后如图：

客户端运行后如图：

在客户端输入数据后如图效果

输入bye时退出：

运行代码时要先运行服务器端，在运行客户端

1.所需头文件：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>

2.定义TCP服务端类

//定义TCP服务端类
class CTcpServer{
public:
  int m_listenfd;
  int m_clientfd;

  //构造函数
  CTcpServer();

  //初始化服务端
  bool initServer();

  //accept
  bool Accept();

  //send data
  int Send(void *buff, int bufflen);

  //recv data
  int Recv(void *buff, int bufflen);

  //close listen fd
  void listenClose();

  //close client fd
  void clientClose();

  //析构函数
  ~CTcpServer();
};

3.主函数实现：

//main函数实现
int main()
{
  char buff[1024+1] = {0};

  //实例化一个server类
  CTcpServer tcpserver;

  //初始化服务器
  if(tcpserver.initServer() == false) {printf("init server error\n"); return false;}

  while(1){
    if(tcpserver.Accept() == false) continue;

    if(fork() > 0) {tcpserver.clientClose(); continue;}  //父进程负责监听，关闭client fd

    tcpserver.listenClose();  //子进程关闭listen fd

    printf("##############server start###############\n");
    while(tcpserver.Recv(buff, sizeof(buff)) > 0){
      printf("server recv: %s\n", buff);
      strcat(buff, "---@ok");
      tcpserver.Send(buff, strlen(buff));
      memset(buff, 0x00, sizeof(buff));
      printf("----------------------------------------\n");
    }
    return 0;
  }
  return 0;
}

4.构造函数、析构函数实现

//构造函数
CTcpServer::CTcpServer(){
  m_listenfd = 0;
  m_clientfd = 0;
}

//析构函数
CTcpServer::~CTcpServer(){
  if(m_listenfd!=0) close(m_listenfd);
  if(m_clientfd!=0) close(m_clientfd);
}

5.初始化实现：

//初始化
bool CTcpServer::initServer(){

  if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0; }
  m_listenfd = socket(AF_INET,SOCK_STREAM,0);     // 创建服务端的socket

  // 把服务端用于通信的地址和端口绑定到socket上
  struct sockaddr_in servaddr;                    // 服务端地址信息的数据结构
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;                  // 协议族，在socket编程中只能是AF_INET

  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   // 本主机的任意ip地址
  servaddr.sin_port = htons(8000);                // 绑定通信端口

  if (bind(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
    {close(m_listenfd); m_listenfd=0; return false;}

  // 把socket设置为监听模式
  if (listen(m_listenfd,5) != 0 ) { close(m_listenfd); m_listenfd=0; return false; }

  return true;
}

6.accept、send、recv、关闭等函数实现：

//accept
bool CTcpServer::Accept(){

/****************************************************
* len表示第二个参数addr的大小，不顾要求给定地址
* addr: 用于记录发起连接请求的那个客户端的IP端口
* 建立连接时服务器的TCP协议会自动解析客户端发来的数据包，从中获取客户端的IP和端口号
* 这里如果服务器应用层需要用到客户端的 IP和端口号，可以给accept指定第二个参数addr,以获取TCP链接时的客户端ip和端口号；如果服务器应用层不需要，则写NULL即可
* addr的结构体类型为 struct sockaddr，在listen函数详解中我们有介绍过，由于这个结构体用起来不是非常方便，我们需要定义struct sockaddr_in结构体来使得sockaddr结构体操作更为便捷。
*****************************************************/
  m_clientfd = accept(m_listenfd, NULL, 0);
  if(m_clientfd == -1) return false;
  return true;
}

//send
int CTcpServer::Send(void *buff, int bufflen){
  return send(m_clientfd, buff, bufflen, 0);
}

//recv
int CTcpServer::Recv(void *buff, int bufflen){
  return recv(m_clientfd, buff, bufflen, 0);
}

//listenclose
void CTcpServer::listenClose(){
  if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0;}
}

//clientclose
void CTcpServer::clientClose(){
  if (m_clientfd!=0) { close(m_clientfd); m_clientfd=0; }
}

7.运行结果：

服务端：

客户端：