Socket网络编程（附java,python代码）_python java socket

软件结构

C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。

B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

网络通信协议

• 网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。

• TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

• 

TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能。

• 链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。
• 网络层：网络层是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
• 运输层：主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。
• 应用层：主要负责应用程序的协议，例如HTTP协议、FTP协议等。

网络编程三要素

协议

• 协议：计算机网络通信必须遵守的规则，常用的协议有TCP和UDP

UDP

用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。

特点:数据被限制在64kb以内，超出这个范围就不能发送了。

数据报(Datagram):网络传输的基本单位

TCP

传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

• 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
  • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  • 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。
    
    完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

IP地址

• IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

IP地址分类

• IPv4：是一个32位的二进制数，通常被分为4个字节，表示成a.b.c.d 的形式。

• IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。

为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

端口号

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

• 端口号：用两个字节表示的整数，它的取值范围是0到65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

案例

用于模拟QQ发送和接收消息，采用Socket和多线程进行接收和发送消息。实现下图所示效果

UDP实现

java代码如下：
UDPClient.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UDPClient {
    public static void main(String args[]) throws IOException, InterruptedException {
        Scanner scanner = new Scanner(System.in);
        byte[] data = new byte[1024];
        //监听8889端口
        DatagramSocket ds = new DatagramSocket(8889);
        InetAddress loc = InetAddress.getByName("127.0.0.1");
        Thread thread = new Thread(() -> {
            while (true)
            {
                try {
                    String send = scanner.nextLine();
                    byte[] send_bytes = send.getBytes("UTF-8");
                    //定义发送数据的DatagramPacket实例
                    DatagramPacket dp_send = new DatagramPacket(send_bytes, send_bytes.length, loc, 8888);
                    ds.send(dp_send);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        Thread thread1 = new Thread(() -> {
            while (true) {
                try {
                    //定义接收数据的DatagramPacket实例
                    DatagramPacket dp_receive = new DatagramPacket(data, 1024);
                    // 接收数据
                    ds.receive(dp_receive);
                    System.out.println("received：" + new String(dp_receive.getData(), 0, dp_receive.getLength()));
                    dp_receive.setLength(1024);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread.join();
        thread1.join();
        ds.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

UDPServer.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UDPServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        Scanner scanner = new Scanner(System.in);
        byte[] data = new byte[1024];
        // 监听8888端口
        DatagramSocket ds = new DatagramSocket(8888);
        InetAddress loc = InetAddress.getByName("127.0.0.1");
        Thread thread = new Thread(() -> {
            while (true)
            {
                try {
                    String send = scanner.nextLine();
                    byte[] send_bytes = send.getBytes("UTF-8");
                    //定义发送数据的DatagramPacket实例
                    DatagramPacket dp_send = new DatagramPacket(send_bytes, send_bytes.length, loc, 8889);
                    ds.send(dp_send);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        Thread thread1 = new Thread(() -> {
            while (true) {
                try {
                    //定义接收数据的DatagramPacket实例
                    DatagramPacket dp_receive = new DatagramPacket(data, 1024);
                    //接收数据
                    ds.receive(dp_receive);
                    System.out.println("received：" + new String(dp_receive.getData(), 0, dp_receive.getLength()));
                    //由于dp_receive在接收了数据之后，其内部消息长度值会变为实际接收的消息的字节数，所以这里要将dp_receive的内部消息长度重新置为1024
                    dp_receive.setLength(1024);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread.join();
        thread1.join();
        ds.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

python代码如下：
server.py

import socket
import threading
address_self = ('127.0.0.1', 8888)  # 服务端地址和端口
address = ('127.0.0.1', 8889)
#SOCK_DGRAM UDP类型
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(address_self)  # 绑定服务端地址和端口
# 接收数据函数
def rev():
    while True:
        data, addr = s.recvfrom(1024)  # 返回数据和接入连接的（客户端）地址
        data = data.decode()
        print('Received:', data)
# 发送数据函数
def send_message():
    while True:
        send = input('')
        s.sendto(send.encode(), address)  # UDP 是无状态连接，所以每次连接都需要给出目的地址
t1 = threading.Thread(target=rev)
t2 = threading.Thread(target=send_message)
t1.start()
t2.start()
t1.join()
t2.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

client.py

import socket
import threading
address = ('127.0.0.1', 8888)  # 服务端地址和端口
address_self = ('127.0.0.1', 8889)  # 服务端地址和端口
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(address_self)
def rev():
    while True:
        data, addr = s.recvfrom(1024)  # 返回数据和接入连接的（客户端）地址
        data = data.decode()
        print('Received:', data)

def send_message():
    while True:
        send = input('')
        s.sendto(send.encode(), address)  # UDP 是无状态连接，所以每次连接都需要给出目的地址
t1 = threading.Thread(target=rev)
t2 = threading.Thread(target=send_message)
t1.start()
t2.start()
t1.join()
t2.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

TCP实现

java代码如下：
TCPClient.java

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

public class TCPClient {
    public static void main(String[] args) throws IOException, InterruptedException {
    	// 定义接收端的ip和端口号
        Socket socket = new Socket("127.0.0.1",8888);
        //发数据
        OutputStream os = socket.getOutputStream();
        // 此线程用于发送数据
        Thread thread = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            while (true) {
                try {
                    String s = scanner.nextLine();
                    os.write(s.getBytes());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        // 开启线程
        thread.start();
        // 此线程用于接收数据
        Thread thread1 = new Thread(() -> {
            //读数据
            try {
                InputStream is = socket.getInputStream();
                while (true) {
                    byte[] bytes = new byte[1024];
                    int len = is.read(bytes);
                    System.out.println("Received:"+new String(bytes, 0, len));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
		// 开启线程
        thread1.start();
        // 等待线程
        thread.join();
        thread.join();
        socket.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

TCPServer.java

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import static java.lang.System.*;

public class TCPServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 给服务端绑定端口号
        ServerSocket s_socket = new ServerSocket(8888);
        // 等待连接
        Socket socket = s_socket.accept();
        // 该线程用于发送数据
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OutputStream os = socket.getOutputStream();
                    Scanner scanner = new Scanner(System.in);
                    while (true) {
                        String s = scanner.nextLine();
                        os.write(s.getBytes());
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        // 开启线程
        thread1.start();
        // 此线程用于接收数据
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                InputStream is = null;
                try {
                    is = socket.getInputStream();
                    while (true)
                    {
                        byte[] bytes = new byte[1024];
                        int len = is.read(bytes);
                        out.println("Received:"+new String(bytes, 0, len));
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        // 开启线程
        thread2.start();
        // 等待线程
        thread1.join();
        thread2.join();
        socket.close();
        s_socket.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

python实现
该代码进行了一个有趣的改进，客户端发送消息给服务端，服务端接收到该消息后将其通过requests发送给图灵机器人API，获得返回数据，然后再发送给客户端，实现了和机器人的对话。
client.py

import socket
import sys
address = ('127.0.0.1', 8888)  # 服务端地址和端口
address_self = ('127.0.0.1',56789)
# AF_INET 使用ipv4
# SOCK_STREAM使用TCP套接字类型
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(address_self)
try:
    s.connect(address)  # 尝试连接服务端
except Exception:
    print('Server not found！')
    sys.exit()
while True:
    message = input('message: ')
    s.sendall(message.encode())
    data = s.recv(1024)
    data = data.decode()
    print('Recieved:', data)

    if message == 'close':  # 自定义结束字符串
        break
s.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

server.py

import socket
import datetime
import json
import requests

tuling='' #此处需要填写您的apikey
api_url = "http://openapi.tuling123.com/openapi/api/v2"
userid = 123456
#调用图灵API,返回数据
def get_message(message,userid):
    req = {
    "perception":
    {
        "inputText":
        {
            "text": message
        },

        "selfInfo":
        {
            "location":
            {
                "city": "成都",
                "province": "四川",
                "street": "双流区"
            }
        }
    },
    "userInfo":
    {
        "apiKey": tuling,
        "userId": userid
    }
    }
    req = json.dumps(req).encode('utf8')
    response_str = requests.post(api_url, data=req, headers={'content-type': 'application/json'}).text
    response_dic = json.loads(response_str)
    results_text = response_dic['results'][0]['values']['text']
    return results_text

address = ('127.0.0.1', 8888)  # 服务端地址和端口
# AF_INET 使用ipv4
# SOCK_STREAM使用TCP套接字类型
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(address)  # 绑定服务端地址和端口
s.listen(5)
print("等待连接。。。。")
conn, addr = s.accept()  # 返回客户端地址和一个新的 socket 连接
print('Connected with', addr)
while True:
    data = conn.recv(1024)  # buffersize 等于 1024
    data = data.decode()
    print('Received:', data)
    if data == "date":
        conn.sendall(datetime.datetime.now().strftime('%Y{y}%m{m}%d{d}').format(y='年', m='月', d='日').encode()) #返回日期
        continue
    if data == "time":
        conn.sendall(datetime.datetime.now().strftime('%H{h}%M{m}%S{s}').format(h='时', m='分', s='秒').encode())  # 返回时间
        continue
    text = get_message(data,userid)
    print(text)
    conn.sendall(text.encode())

conn.close()
s.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

效果图如下：

今天的分享就到这里了，希望大家能够有所收获，欢迎关注。