Socket
 
1 环境查看
 
通过cmd窗口的命令:ipconfig查看本机IP地址
 
查看网络情况是否正常:ping百度官网
 
 
 
 
用来进行本地测试的地址 127.0.0.1,回环测试地址,默认代表的就是本机的IP
 
 
2 Socket概述
 
socket编程也叫套接字编程,应用程序可以通过它发送或者接受数据,可对其像打开文件一样打开/关闭/读写等操作.
套接字允许应用程序将I/O插入到网络中,并与网络中的其他应用程序进行通信.
网络套接字是IP地址与端口号TCP协议的组合
Socket就是为网络编程提供的一种机制,通信的两端都有Socket
网络通信其实就是Socket之间的通信,数据在两个Socket之间通过I/O进行传输.
 

 
 
3 服务器端
 
3.1 ServerSocket
 
在服务器端选择一个端口号,在指定端口上等待客户端发起连接
 
 
 
构造方法:
 ServerSocket(int port) 创建绑定到特定端口的服务器套接字
 常用方法:
 Socket accept() 侦听并接收到此套接字的连接
 void close() 关闭此套接字
 启动服务:
 ServerSocket ss = new ServerSocket(端口号);
 等待客户端发起连接,连接后会建立起通道:Socket socket = ss.accept();
 
 
4 客户端Socket
 
我们经常使用的就是客户端
 
 
 
构造方法:
 Socket(String host,int port) 创建一个流套接字,并将其连接到指定主机上的指定端口号
 常用方法:
 InputStream getInputStream() 返回此套接字的输入流
 OutputStream getOutputStream() 返回此套接字的输出流
 void close() 关闭此套接字
 新建Socket对象,连接指定IP指定的端口
 Socket s = new Socket(IP,port);
 从Socket获取双向的流:
 InputStream in = s.getInputStream();
 OutputStream out = s.getOutputStream();
 
 
5 入门案例
 
5.1服务器端代码编写
 
 
 
需求: 服务器端接收客户端发来的数据”hello”,并且给客户端响应数据”world”
 
 
创建包: cn.tedu.net
 创建类: Server.java
 
package cn.tedu.net;

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

/**本类用来表示Socket网络编程案例的服务器端
 * 完成步骤分析:
 * 1.启动服务器
 * 2.接收客户端的连接请求
 * 3.接收客户端发来的数据
 * */
/**测试注意事项:先启动服务器端,再启动客户端*/
public class Server {
	public static void main(String[] args) throws Exception {
		//1.启动服务器,指定端口号为8888,等待客户端的连接
		/**注意:
		 * 1.使用ServerSocket需要导包java.net.ServerSocket
		 * 2.此操作会抛出异常
		 * 3.指定的端口号范围是:0-655535,而0-1024是系统端口号,不能指定
		 * */
		ServerSocket ss = new ServerSocket(8888);
		//2.接收客户端的连接请求,并建立数据通信通道
		Socket socket = ss.accept();
		//3.获取到读取流,接收并读取客户端发来的数据
		InputStream in = socket.getInputStream();
		//通过循环挨个读取显示读到的内容
		for(int i = 0;i < 5;i++) {
			//int b = in.read();//此方法读取的结果是把字符转成数字
			char c = (char) in.read();//为了直接显示读取到的字符,需要强制类型转换(大转小,int转char)
			System.out.print(c);//print()同行输出,注意细节哦
		}
		//5.给客户端发送数据
		OutputStream out = socket.getOutputStream();
		out.write("world".getBytes());
		out.flush();
		
		//4.释放资源
		/**注意关流的顺序,后出现的先关闭*/
		in.close();
		ss.close();
	}
}
 
5.2 客户端代码编写
 
创建包: cn.tedu.net
 创建类: Client.java
 
package cn.tedu.net;

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

/**本类用来表示Socket网络编程案例的客户端
 * 完成步骤分析:
 * 1.指定要连接的服务器
 * 2.给服务器发送hello
 * */
public class Client {
	public static void main(String[] args) throws Exception {
		//1.指定要连接的服务器,需要同时指定服务器的IP & Port
		/**注意:
		 * 1.使用Socket需要导包java.net.Socket
		 * 2.此操作会抛出异常
		 * 3.如果使用的是本机的IP,地址是固定值,用来测试时使用127.0.0.1
		 * */
		Socket socket = new Socket("127.0.0.1",8888);
		//2.给服务器端发送hello
		OutputStream out = socket.getOutputStream();
		//把要输出的数据hello字符串转变成byte[]的形式进行输出
		out.write("hello".getBytes());
		out.flush();
		
		//4.读取从服务器端返回的数据
		InputStream in = socket.getInputStream();
		for (int i = 0; i < 5; i++) {
			char c = (char) in.read();//为了显示字符而不是数字,强制类型转换成char
			System.out.print(c);//不换行展示获取到的数据
		}
		
		//3.释放资源
		//out.close();
		socket.close();
		
	}
}
 
5.3 测试注意事项:
 
1.测试顺序:先启动服务器端,再启动客户端
 2.可以打开多个控制台显示窗口,方便查看
 3.可以将其中一个控制台显示窗口固定,否则多个窗口的显示内容是一样的
 4.注意每次测试完毕后,都需要将之前的控制台窗口都关闭后再次进行新一轮的测试
 
 
 
 
注意:要先启动服务器端再启动客户端,否则会报错,如下所示:
 
 
注意，下次测试的时候，把上次测试的窗口都关掉,重复启动多次,正在使用,新次测试就无法使用
 
 
6 服务器端线程模型
 
入门案例中,存在两种阻塞状态:
 
服务器端的accept()一直在等待客户端的连接
通信中的read()死等数据
 
 
7 读一行写一行案例
 
创建包: cn.tedu.net
 创建类: TestIO.java
 
package cn.tedu.net;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**这个类用来测试一行一行读取,一行一行写出*/
public class TestIO {
	public static void main(String[] args) {
		//method();//初步测试readLine()
		method2();//改进
	}
	public static void method2() {
		BufferedReader in = null;
		PrintWriter out = null;
		try {
			//1.读取一行数据,先拿到读取数据的流,注意文件需要自己在win创建
			in = new BufferedReader(new FileReader("D:\\b.txt"));
			//2.定义变量,记录每行读取到的数据
			String line;
			//3.设置循环读取数据,只要有数据就一直读取
			while( (line=in.readLine()) != null) {
				System.out.println(line);
			}
			
			//4.一行行写出数据:PrintWriter
			out = new PrintWriter(new FileWriter("D:\\b.txt"));
			out.println("java");
			out.println("hello");
			out.flush();//为了防止有数据没有发送过去,可以刷一下
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				//5.释放资源
				out.close();
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public static void method() {
		try {
			//1.读取一行数据,先拿到读取数据的流,注意文件需要自己在win创建
			BufferedReader in = new BufferedReader(new FileReader("D:\\b.txt"));
			//2.调用readLine方法进行测试
			String line = in.readLine();
			String line2 = in.readLine();
			String line3 = in.readLine();
			//测试1:b.txt没有数据时,readLine()返回null
			//测试2:b.txt有数据,而且是1整行数据,readLine()可以返回整行全部数据
			//测试3:b.txt有数据,而且是多行数据,readLine()只可以返回第1行全部数据
			/**原因:readLine()在读取数据时,会读取特殊标记,换行符\r\n,读到换行符就结束
			 * 结论:readLine()只可以读取1整行数据,如果是多行数据,需要多次调用
			 * */
			//3.打印测试结果
			System.out.println(line);
			System.out.println(line2);
			System.out.println(line3);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
 
8 拓展 : 回声案例
 
 
 
需求：接收客户端输入的每行数据,服务器再把回应给到用户
 
 
8.1 服务器端
 
 
 
接收客户端输入的每行数据,服务器再把回应给到用户
 
 
创建包: cn.tedu.net
 创建类: Server2.java
 
package cn.tedu.net;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**这个类用来当做回声案例的服务器端
 * 1.启动服务器
 * 2.接收客户端的连接请求
 * 3.给每个用户分配对应的话务员
 * 4.话务员:主要负责和对应的客户端对象进行沟通I/O
 * */
/**1.创建优化后的Server2类,充当服务器端*/
public class Server2 {
	/**2.创建方法,负责服务多个客户*/
	public void service() {
		/**3.匿名对象+匿名内部类(重写run方法)*/
		new Thread() {
			/**5.把业务写在run()中*/
			@Override
			public void run() {
				try {
					//5.1 启动服务器,设置端口号为8000并等待客户端连接
					ServerSocket ss = new ServerSocket(8000);
					System.out.println("服务器启动成功!");
					while(true) {//死循环,一直accept,也就是接受客户端的连接请求
						//5.2 一直接受所有客户端的连接请求
						Socket socket = ss.accept();
						System.out.println("客户端连接成功!");
						//5.3 给每个客户分配自己对应的话务员,1v1
						HuaWuThread t = new HuaWuThread(socket);
						t.start();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
				
			};
		}.start();/**4.启动线程*/
	}
	
	/**6.创建话务员内部类,主要负责和客户端沟通 I/O*/
	class HuaWuThread extends Thread{
		//6.1 定义本类中的成员变量socket,用来保持通话
		Socket socket;
		//6.2含参构造,接受当前的连接信息,保持通话,为谁服务就保存谁的数据
		public HuaWuThread(Socket socket) {
			this.socket = socket;
		}
		//6.3把话务员的业务放在run(),一直读取客户端发来的数据,并作出回应
		@Override
		public void run() {
			try {
				//7.1读取一行BufferedReader,并且写出一行PrintWriter --双向流
				BufferedReader in = new BufferedReader(
						new InputStreamReader(socket.getInputStream()));
				PrintWriter out = new PrintWriter(
						new OutputStreamWriter(socket.getOutputStream()));
				//7.2读取客户端发来的一行数据
				String line;//定义变量,记录读取到的一行数据
				while((line = in.readLine()) != null) {//只要有数据就一直读
					System.out.println("客户端发来的数据:"+line);
					//7.1可以给客户端作出响应-接收键盘输入的响应
					System.out.println("请输入您的回应:");
					String input = new Scanner(System.in).nextLine();
					//7.2发出作为服务器的响应
					out.println(input);
					out.flush();//把数据刷出去
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		Server2 s = new Server2();
		s.service();
	}
}
 
8.2 客户端
 
 
 
接收客户端输入的每行数据,服务器再把回应给到用户
 
 
创建包: cn.tedu.net
 创建类:Client2.java
 
package cn.tedu.net;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**本类用来做回声案例的客户端
 * 1.连接指定的服务器
 * 2.给服务器发送数据
 * 3.接收服务器响应的数据
 * */
public class Client2 {
	public static void main(String[] args) {
		try {
			//1.连接指定的服务器,同时指定服务器的IP和端口号
			Socket socket = new Socket("127.0.0.1",8000);
			//2.给服务器发送数据
			while(true) {
				//向服务器写出一行数据,并且读取服务器响应回来的数据
				PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
				BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				//3.通过流对象进行发送和读取的操作
				System.out.println("请输入您想给服务器发送的数据:");
				String input = new Scanner(System.in).nextLine();
				out.println(input);//向服务端发送指定数据
				out.flush();//把数据刷出去
				String line = in.readLine();//读取回声数据
				System.out.println("服务器端响应的数据是:"+line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

博客核心内容：
 
 
1.Socket是什么 
 2.基于TCP协议的网络编程模型（进阶代码） 
 3.基于TCP协议的网络编程带来的两个问题以及相应的解决措施（通信循环和链接循环） 
 4.socket.error: [Errno 98] Address already in use（IP地址和端口号已经被占用的解决措施） 
 5.基于socket实现远程执行命令 
 6.基于TCP网络编程出现的粘包以及相应的解决方案 
 7.基于Socket网络编程之客户端并发实现（利用了多进程的技术） 
 8.进程池中同步与异步的解决方案
 
 

（一）Socket是什么
 
1、C/S架构与socket的关系：我们学习socket就是为了完成C/S架构的开发 
 2、C/S架构的软件（软件属于应用层）是基于网络进行通信的，网络的核心即一堆协议，协议即标准，你想开发一款基于网络通信的软件，就必须遵循这些标准 
 3、互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层：如下图所示 
  
 4、Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议，所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。 
  
 5、也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序而程序的pid是同一台机器上不同进程或者线程的标识。 
 

 TCP服务端的编程模型：
（二）基于TCP协议的网络编程
 
ss = socket() #创建服务器套接字
ss.bind()      #把地址绑定到套接字
ss.listen()      #监听链接
inf_loop:      #服务器无限循环
    cs = ss.accept() #接受客户端链接
    comm_loop:         #通讯循环
        cs.recv()/cs.send() #对话(接收与发送)
    cs.close()    #关闭客户端套接字
ss.close()        #关闭服务器套接字(可选)
 
TCP客户端的编程模型：
 
cs = socket()    # 创建客户套接字
cs.connect()    # 尝试连接服务器
comm_loop:        # 通讯循环
    cs.send()/cs.recv()    # 对话(发送/接收)
cs.close()            # 关闭客户套接字
 
相关注意事项：
 
套接字家族的名字：AF_INET,指定我们的套接字是基于网络进行通信的。

socket.SOCK_STREAM指的是TCP协议,即流式协议
socket.SOCK_DGRAM指的是UDP协议,即数据报协议

phone.listen(5)的含义：TCP协议当中含有一个半链接池,5指的是半链接池的数量,而不是
指的并发的数量,相当于可以同时将5个链接给挂起来。

我觉得使用连接池最大的一个好处就是减少连接的创建和关闭，增加系统负载能力.

我认为在这里面可以画一个编程模型图(略)

conn,addr = phone.accept()

conn指的是TCP协议3次握手之后建立的那个链接,
addr指的是客户端的IP地址和端口号

conn.read(1024)基于TCP协议接收到的消息是:1024表示的是字节,即1kb


phone.send("hello") 在发消息的过程中,不能直接发送字符串,而应该发送二进制串,因为数据的传输
都应该是二进制形式
 
版本一：简易版本 
 服务端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.bind(("127.0.0.1",8081))

phone.listen(5)
print("starting")

conn,addr = phone.accept()
print(conn)
print(addr)


client_msg = conn.recv(1024)
print("客户端发送过来的消息是:%s"%client_msg)
conn.send(client_msg.upper())

conn.close()
phone.close()
 
客户端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
#指定socket套接字通信所用的协议：TCP协议
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#随后客户端的套接字发送链接请求
phone.connect(('127.0.0.1',8081))

#随后客户端向服务端发送消息

phone.send("hello".encode("utf-8"))

server_msg = phone.recv(1024)
print("服务端发送过来的消息是:%s"%server_msg)
 
服务端的运行结果：
 
starting
<socket.socket fd=384, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8081), raddr=('127.0.0.1', 52596)>
('127.0.0.1', 52596)
客户端发送过来的消息是:b'hello'

Process finished with exit code 0
 
客户端的运行结果：
 
服务端发送过来的消息是:b'HELLO'

Process finished with exit code 0
 
我自己总结的编程模型： 
 服务端：
 
服务器端编程模型：
1.创建socket套接字对象,并指定通信所用的协议
socket_obj = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

2.将套接字对象绑定服务器端的IP地址和相应端口号
socket_obj.bind(("127.0.0.1",8080))

3.套接字对象监听这个端口,并指定半链接池的数量
socket_obj.listen(5)

4.服务器端接收客户端的链接请求
conn,addr = socket_obj.accept()

5.双方发送消息

6.关闭连接
close()
 
客户端：
 
客户端编程模型：
1.创建socket套接字对象,并指定通信所用的协议
socket_obj = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

2.随后客户端的套接字对象发送链接请求
socket_obj.connect(("127.0.0.1",8080))

3.双方发送消息


4.关闭连接
close()
 
图示： 
  
 在上面的基础上我们将代码进行改进：（2次改进） 
 服务端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket

#1、创建一个socket套接字对象,同时需要指定网络通信所用的协议,在这里用的是TCP协议
socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#2、socket套接字绑定IP地址和端口号
socket_server.bind(("127.0.0.1",8083))

#3、通过socket这个监听器对8080端口号进行监听状态
socket_server.listen(5)

#4、服务器端接收套接字发送过来的请求
print("等待建立连接中........")
conn ,address = socket_server.accept()
print("建立连接")
print("客户端的地址是:",address)
"""
从下面开始双方将会基于这个链接进行相互通信,下面应该建立一个循环
"""
while True:
    print("服务端在等待客户端发送消息..........")
    cli_msg = conn.recv(1024).decode("utf-8")
    print("客户端发送过来的数据是:%s"%cli_msg)

    #要想获得最终的结果:需要将二进制串解码成字符串
    conn.send("我已经收到消息了!".encode("utf-8"))

conn.close()
socket_server.close()
 
客户端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket

#1、创建一个socket套接字对象,同时需要指定网络通信所用的协议,在这里用的是TCP协议
socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#2、通过socket这个套接字向服务端发送链接请求
socket_client.connect(("127.0.0.1",8083))

"""
从下面开始双方将会基于这个链接进行相互通信
"""
while True:
    msg = input(">>:").strip()
    socket_client.send(msg.encode("utf-8"))

    server_msg = socket_client.recv(1024).decode("utf-8")
    print("服务端发送过来的数据是:%s"%server_msg)


socket_client.close()
 
最终运行结果： 
 服务端的结果：
 
等待建立连接中........
建立连接
客户端的地址是: ('127.0.0.1', 55745)
服务端在等待客户端发送消息..........
客户端发送过来的数据是:spark
服务端在等待客户端发送消息..........
客户端发送过来的数据是:fjdsflkd
服务端在等待客户端发送消息..........
客户端发送过来的数据是:fds
服务端在等待客户端发送消息..........
客户端发送过来的数据是:fdsfdsfdsfdsfsfdsfds
服务端在等待客户端发送消息..........
客户端发送过来的数据是:fds
服务端在等待客户端发送消息..........
客户端发送过来的数据是:zhangmingyang
服务端在等待客户端发送消息..........
 
客户端的结果：
 
>>:spark
服务端发送过来的数据是:我已经收到消息了!
>>:fjdsflkd
服务端发送过来的数据是:我已经收到消息了!
>>:fds
服务端发送过来的数据是:我已经收到消息了!
>>:fdsfdsfdsfdsfsfdsfds
服务端发送过来的数据是:我已经收到消息了!
>>:fds
服务端发送过来的数据是:我已经收到消息了!
>>:zhangmingyang
服务端发送过来的数据是:我已经收到消息了!
>>:
 
综上：我们可以总结出一个result： 
 服务端在两个地方会发生卡的情况： 
 1、客户端没有发送链接请求,或者说等待客户端发送链接请求的时候会卡 
 conn ,address = socket_server.accept() 
 2、服务端等待客户端发送消息的时候会卡: 
 cli_msg = conn.recv(1024).decode(“utf-8”) 
 

 基于TCP协议的问题： 


1、客户端不能发送空的数据,否则在服务端就会卡： 

 cli_msg = conn.recv(1024).decode(“utf-8”) 

 解决方法： 

 在客户端通过语句级别进行控制： 

 msg = input(“>>:”).strip() 

 #如果msg消息为空,则不进行消息的发送 

 if not msg:continue
（三）基于TCP协议的网络编程带来的两个问题以及相应的解决措施
 
2、**TCP协议是双向的连接:在客户端强制终止的时候,服务端会报错:远程主机强迫关闭了一个现有的连接 
 服务端在等待客户端发送消息……….** 
 Traceback (most recent call last): 
 File “D:/Python Work Location/Python 0507/day08/directory2/服务端.py”, line 25, in 
 cli_msg = conn.recv(1024).decode(“utf-8”) 
 ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。 
 呵呵,客户异常的终止了自己的客户端,服务端就down了,你感觉合适吗？
 
解决方法：异常处理机制(将可能出现的代码块进行捕获)
 
while True: 
 try: 
 print(“服务端在等待客户端发送消息……….”) 
 cli_msg = conn.recv(1024).decode(“utf-8”) 
 print(“客户端发送过来的数据是:%s”%cli_msg) 
 #要想获得最终的结果:需要将二进制串解码成字符串 
 conn.send(“我已经收到消息了!”.encode(“utf-8”)) 
 except ConnectionResetError: 
 break
 
又一个问题：此时服务端不会异常终止掉,但是会终止掉。 
 解决方法：while True：链接循环不能终止, 仅仅终止通信循环[呵呵,其实我感觉下面那个应该叫做 
 链接循环]
 
注意：在linux当中,如果客户端单方面的终止，服务端并不会终止跑出异常，而是在服务端里面一直死循环. 
 改正之后的客户端代码：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket

#1、创建一个socket套接字对象,同时需要指定网络通信所用的协议,在这里用的是TCP协议
socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#2、通过socket这个套接字向服务端发送链接请求
socket_client.connect(("172.22.178.52",8083))

"""
从下面开始双方将会基于这个链接进行相互通信
"""
while True:
    msg = input(">>:").strip()

    #如果msg消息为空,则不进行消息的发送
    if not msg:continue

    socket_client.send(msg.encode("utf-8"))
    print("消息已经发送!")

    server_msg = socket_client.recv(1024).decode("utf-8")
    print("服务端发送过来的数据是:%s"%server_msg)


socket_client.close()
 
改正之后的服务端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket

#1、创建一个socket套接字对象,同时需要指定网络通信所用的协议,在这里用的是TCP协议
socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#2、socket套接字绑定IP地址和端口号
socket_server.bind(("172.22.178.52",8083))

#3、通过socket这个监听器对8080端口号进行监听状态
socket_server.listen(5)

#4、服务器端接收套接字发送过来的请求
while True:
    print("等待建立连接中........")
    conn ,address = socket_server.accept()
    print("建立连接")
    print("客户端的地址是:",address)
    """
    从下面开始双方将会基于这个链接进行相互通信,下面应该建立一个循环
    """
    while True:
        try:#针对windows系统客户端断开链接
            print("服务端在等待客户端发送消息..........")
            cli_msg = conn.recv(1024).decode("utf-8")
            #考虑Linux的情况系统客户端断开链接
            if not cli_msg: break
            print("客户端发送过来的数据是:%s"%cli_msg)
            #要想获得最终的结果:需要将二进制串解码成字符串
            conn.send("我已经收到消息了!".encode("utf-8"))
        except ConnectionResetError:
            break
    #若客户端终止链接,此时服务端也应该终止链接,但是不应该终止监听状态
    conn.close()


socket_server.close()
 


 有的时候当我们在重启服务端时可能会遇到：
（四）socket.error: [Errno 98] Address already in use
 
Traceback (most recent call last):
  File "服务端.py", line 9, in <module>
    socket_server.bind(("172.22.178.52",6819))
socket.error: [Errno 98] Address already in use
 
这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法） 
 解决方法： 
 加入一条socket配置，重用ip和端口
 
socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
socket_server.bind(("172.22.178.52",6819))
 


 ssh的原理：
（五）基于socket实现远程执行命令
 
ssh：可以远程操作对方的主机.(ssh本质上是基于socket编写的一个软件)
xshell,是ssh的一个客户端;服务器上会安装一个ssh的服务端.
原理：在客户端执行一条命令之后,这条命令并不会在客户端本地被执行,而是会被当做一条字符串发送给
服务端,在服务端被执行,执行完之后在将结果通过socket套接字发送回来,随后客户端在自己的终端在显示
出来,当然给人的一种错觉是这条命令是在客户端本地被执行的。

即在服务端执行命令,并将结果返回给客户端。
 
代码示例： 
 服务端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
import subprocess

#创建socket套接字,并指定通信所用的协议
socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#重新使用IP地址和端口号
socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
socket_server.bind(("127.0.0.1",8081))
socket_server.listen(5)

while True:
    print("等待客户端的连接.........")
    conn,address = socket_server.accept()
    print("链接已经生成")
    print("客户端的信息是:",address)

    """
    双方建立了连接后,就开始进行相同通信
    """
    while True:
        try:
            client_msg = conn.recv(1024).decode("utf-8")
            print("客户端发送的消息是:%s" %client_msg)
            res = subprocess.Popen(client_msg,shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            res_err = res.stderr.read()
            if res_err:
                cmd_res = res_err
            else:
                cmd_res = res.stdout.read()
            conn.send(cmd_res)

        except Exception:
            break

    conn.close()

socket_server.close()
 
客户端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-


import socket

#创建socket套接字,并指定通信所用的协议
socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#客户端向服务端发送链接请求
socket_client.connect(("127.0.0.1",8081))

"""
双方建立了连接后,就开始进行相同通信
"""
while True:
    str_msg = input(">>")
    if not str_msg: continue
    socket_client.send(str_msg.encode('utf-8'))
    print("消息已经发送出去!")
    ser_msg = socket_client.recv(1024).decode("gbk")
    print("服务端发送过来的消息是:%s"%ser_msg)

socket_client.close()
 
服务端的执行结果：
 
等待客户端的连接.........
链接已经生成
客户端的信息是: ('127.0.0.1', 51680)
客户端发送的消息是:ls
客户端发送的消息是:dir
客户端发送的消息是:ipconfig
 
客户端的执行结果：
 
D:\Python34\python.exe "D:/Python Work Location/Python 0507/day08/directory4/客户端.py"
>>ls
消息已经发送出去!
服务端发送过来的消息是:'ls' 不是内部或外部命令，也不是可运行的程序
或批处理文件。

>>dir
消息已经发送出去!
服务端发送过来的消息是: 驱动器 D 中的卷是 NewDisk
 卷的序列号是 B823-EC5F

 D:\Python Work Location\Python 0507\day08\directory4 的目录

2017/06/23  02:41    <DIR>          .
2017/06/23  02:41    <DIR>          ..
2017/06/23  02:41               637 客户端.py
2017/06/23  02:39             1,252 服务端.py
               2 个文件          1,889 字节
               2 个目录 387,609,653,248 可用字节

>>ipconfig
消息已经发送出去!
服务端发送过来的消息是:
Windows IP 配置


无线局域网适配器 无线网络连接 4:

   媒体状态  . . . . . . . . . . . . : 媒体已断开
   连接特定的 DNS 后缀 . . . . . . . : 

无线局域网适配器 无线网络连接 3:

   媒体状态  . . . . . . . . . . . . : 媒体已断开
   连接特定的 DNS 后缀 . . . . . . . : 

以太网适配器 本地连接 2:

   连接特定的 DNS 后缀 . . . . . . . : 
   本地链接 IPv6 地址. . . . . . . . : fe80::bcc1:4f1e:cf40:b7e8%24
   IPv4 地址 . . . . . . . . . . . . : 10.255.48.51
   子网掩码  . . . . . . . . . . . . : 255.255.255.0
   默认网关. . . . . . . . . . . . . : 

以太网适配器 Bluetooth 网络连接 2:

   媒体状态  . . . . . . . . . . . . : 媒体已断开
   连接特定的 DNS 后缀 . . . . . . . : 

无线局域网适配器 无线网络连接:

   连接特定的 DNS 后缀 . . . . . . . : 
   本地链接 IPv6 地址. . . . . . . . : fe80::f8fc:fab4:f423:7ad3%15
   IPv4 地址 . . . . . . . . . . . . : 192.168.1.13
   子网掩码  . . . . . . . . . . . . : 255.255.255.0
   默认网关. . . . . . . . . . . . . : fe80::1%15
 


 自定义报头解决粘包问题：
（七）粘包以及解决措施
 
1、如果命令的执行结果小于1024个字节,就会接着收结果,为上一次遗留的结果。 
 2、我们基于socket这种机制写的是应用程序 
 3、内核态与用户态的概念：CPU的两种工作状态: 
 如果是内核态：操作系统操纵硬件 
 如果是用户态：操作应用程序,用户态不能操作硬件,但是此时应用程序会发起一个系统调用, 
 去操作我们的网卡 
 4、客户端的应用程序不断将结果丢到操作系统的缓存当中 
 5、服务端与客户端的状态是一发一收？这种说法是错误的,客户端一发,难道服务端就一定要 
 一收吗? 
 正确答案：客户端发和服务端收,两者之间没有一点关系,双方操作的都是各自的缓存。
 
代码示例：非一收一发的情况： 
 总结：在socket编程当中,无论是收发,只与自己的缓存有关系,跟对方没有关系.
 
粘包的两种情况： 
 1、在客户端发送的时候产生粘包[客户端发送的数据包数据量比较小的时候,并且相互之间时间间隔 
 比较短的时候===>此时操作系统还没有来得及将缓存中的数据给发送出去==>导致这几条数据基本上同时到达对方的缓存当中,由于对方收的是1kb的数据,所以将数据一下子都获取出来] 
 问题：为什么没有来得及？
 
2、问题：程序运行的速度快还是网络运行（网络延迟）的速度快？ 
 基于网络通信的软件：最大的瓶颈在于网络IO 
 
总结：无论是在客户端还是服务端,粘包现象都和TCP/IP工作的方式有关(流失协议)
 
UDP不会粘包的原因：数据报协议,没发一条消息都是单独的一条数据报。
 
原因： 
 所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。(即不知道数据流的开始 
 与结束)
 
解决方法： 
 如果我们知道每个数据报的长度的话,那我们就可以针对性的收了
 
也就是无论我们是在客户端粘包还是在服务端粘包,本质的原因就是因为我们不知道从哪里收,即不知道数据的 
 长度是多少。 
 示例程序1：客户端
 
#!/usr/bin/python
# -*- coding:utf-8 -*-


import socket
import time
import struct

socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#客户端的套接字发送链接请求
socket_client.connect(("127.0.0.1",8083))

"""
双方建立好链接请求之后,进行相同通信
"""
msg = "zhang贸发大水范德萨范德萨zhangdir"
print(len(msg))
print(msg)
len_msg = struct.pack('i',len(msg.encode("utf-8")))
socket_client.send(len_msg)
socket_client.send(msg.encode("utf-8"))

socket_client.close()
 
服务端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
import time
import struct

socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket_server.bind(("127.0.0.1",8083))
socket_server.listen(5)

#等待客户端的socket发送链接请求,并建立连接
print("等待链接中......")
conn,addresss = socket_server.accept()
print("链接已生成......")
print("客户端的地址是:",addresss)

"""
双方建立好链接请求之后,进行相同通信
"""

msg_len = struct.unpack('i',conn.recv(4))
print(msg_len[0])

msg = conn.recv(msg_len[0])
print(msg.decode('utf-8'))

conn.close()
socket_server.close()
 
运行结果： 
 客户端：
 
23
zhang贸发大水范德萨范德萨zhangdir
 
服务端：
 
等待链接中......
链接已生成......
客户端的地址是: ('127.0.0.1', 50107)
43
zhang贸发大水范德萨范德萨zhangdir

Process finished with exit code 0
 
示例程序：远程执行命令的解决方案 
 客户端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-


import socket
import struct
import json

#创建socket套接字,并指定通信所用的协议
socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#客户端向服务端发送链接请求
socket_client.connect(("127.0.0.1",8081))

"""
双方建立了连接后,就开始进行相同通信
"""
while True:
    str_msg = input(">>")
    if not str_msg: continue
    socket_client.send(str_msg.encode('utf-8'))
    print("消息已经发送出去!")
    #我们在客户端就先收取4个字节的长度,并进行解包,看看服务端发送过来的数据到底多长
    total_size = struct.unpack('i',socket_client.recv(4))[0]
    #下面这样写是不合适的,我们应该一点一点的拿,通过for循环
    #ser_msg = socket_client.recv(ser_len[0])
    recv_size = 0
    data = b''
    while recv_size < total_size:
        #socket_client.recv(1024)虽然写的是收取1024个字节,但是收取的是实际的字节
        recv_data = socket_client.recv(1024)
        data += recv_data
        #不能写1024,写真实接收的数据
        recv_size += len(recv_data)
    print("服务端发送过来的消息是:%s"%data.decode('gbk'))

socket_client.close()
 
服务端：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
import subprocess
import struct
import json

#创建socket套接字,并指定通信所用的协议
socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#重新使用IP地址和端口号
socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
socket_server.bind(("127.0.0.1",8081))
socket_server.listen(5)

while True:
    print("等待客户端的连接.........")
    conn,address = socket_server.accept()
    print("链接已经生成")
    print("客户端的信息是:",address)

    """
    双方建立了连接后,就开始进行相同通信
    """
    while True:
        try:
            client_msg = conn.recv(1024).decode("utf-8")
            if not client_msg:break
            print("客户端发送的消息是:%s" %client_msg)
            res = subprocess.Popen(client_msg,shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            #获取的结果是平台格式的二进制串
            res_err = res.stderr.read()
            if res_err:
                cmd_res = res_err
            else:
                cmd_res = res.stdout.read()
            #服务端在真正发送数据的时候,应该先发送一下数据的长度

            aa = struct.pack('i', len(cmd_res))
            #这两条数据肯定会黏在一起的
            #先发送报头的长度
            conn.send(aa)
            #在发送真实的数据
            conn.send(cmd_res)

        except Exception:
            break

    conn.close()

socket_server.close()
 


 服务端程序：
（七）基于Socket网络编程之客户端并发实现（多进程）
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
from multiprocessing import Process
import time

#1、创建一个socket套接字对象,同时需要指定网络通信所用的协议,在这里用的是TCP协议
socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

#2、socket套接字绑定IP地址和端口号
socket_server.bind(("127.0.0.1",8081))

#3、通过socket这个监听器对8080端口号进行监听状态
socket_server.listen(5)

#4、服务器端接收套接字发送过来的请求
def talk(conn):
    #通信循环
    while True:
        try:#针对windows系统客户端断开链接
            print("服务端在等待客户端发送消息..........")
            cli_msg = conn.recv(1024).decode("utf-8")
            #考虑Linux的情况系统客户端断开链接
            if not cli_msg: break
            print("客户端发送过来的数据是:%s"%cli_msg)
            #要想获得最终的结果:需要将二进制串解码成字符串
            conn.send("我已经收到消息了!".encode("utf-8"))
        except ConnectionResetError:
            break
    # 若客户端终止链接,此时服务端也应该终止链接,但是不应该终止监听状态
    conn.close()

if __name__ == '__main__':
    while True:
        #链接循环
        print("等待建立连接中........")
        conn ,address = socket_server.accept()
        print("建立连接")
        print("客户端的地址是:",address)
        """
        从下面开始双方将会基于这个链接进行相互通信,下面应该建立一个循环
        """
        p = Process(target=talk,args=(conn,),name=str(address))
        print("进程的名称是:%s"%p.name)
        p.start()

        time.sleep(15)

        """
        在这里我有一个疑问,为什么不是写多个？
        """

    socket_server.close()
 
客户端程序：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-


import socket


socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket_client.connect(("127.0.0.1",8081))

"""
双方建立连接后进行通信
"""

while True:
    msg = input(">>:").strip()
    if not msg: continue
    socket_client.send(msg.encode("utf-8"))

    server_msg = socket_client.recv(1024).decode("utf-8")
    print("服务端发送过来的数据是:%s"%server_msg)


socket_client.close()
 
另外一个客户端代码是相同的。 
 运行结果：
 
等待建立连接中........
建立连接
客户端的地址是: ('127.0.0.1', 61406)
进程的名称是:('127.0.0.1', 61406)
服务端在等待客户端发送消息..........
等待建立连接中........
建立连接
客户端的地址是: ('127.0.0.1', 61410)
进程的名称是:('127.0.0.1', 61410)
服务端在等待客户端发送消息..........
等待建立连接中........
 
注意：在这个程序当中利用了主进程和子进程两个进程进而实现并发的效果！ 
 

 服务端同步的执行代码：
（八）进程池中同步与异步的执行方案
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
from multiprocessing import Process,Pool
import time

socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
socket_server.bind(("127.0.0.1",8081))
socket_server.listen(5)


def talk(conn,addr):
    while True:
        try:
            msg = conn.recv(1024)
            if not msg:break
            print("客户端发送过来的数据是:%s" % msg)
            conn.send(msg.upper())
        except Exception:
            break



if __name__ == "__main__":
    pool = Pool(processes=4)
    while True:
        # 链接循环
        print("等待建立连接中........")
        conn, address = socket_server.accept()
        print("建立连接")
        print("客户端的地址是:", address)

        #建立完连接之后向进程池中提交任务
        pool.apply(func=talk,args=(conn,address,))
        #问题:只有当第一个提交的任务执行完毕之后,进程池中才会建立连接,接受第二个任务,并进行执行
 
问题： 
 在进程池中同步(打电话)的提交任务,若提交的前一个任务没有执行完,后一个任务则不能执行. 
 此时进程池中的任务将变为串行的效果，当然这种结果并不是我们想要的。
 
异步的解决方案（服务端）： 
 代码示例：
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
from multiprocessing import Process,Pool
import time
import os

socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
socket_server.bind(("127.0.0.1",8081))
socket_server.listen(5)


def talk(conn,addr):
    print("当前执行的进程PID是\033[41;1m%s\033[0m"%os.getpid())
    while True:
        try:
            msg = conn.recv(1024)
            if not msg:break
            print("客户端发送过来的数据是:%s" % msg.decode("utf-8"))
            conn.send(msg.upper())
        except Exception:
            break



if __name__ == "__main__":
    pool = Pool(processes=2)
    res_l = []
    while True:
        # 链接循环
        print("等待建立连接中........")
        conn, address = socket_server.accept()
        print("建立连接")
        print("客户端的地址是:", address)

        #建立完连接之后向进程池中提交任务
        res = pool.apply_async(func=talk,args=(conn,address))

        #通过程序可以知道:res_l中仅仅添加了AsyncResult对象,但是并没有得到执行
        res_l.append(res)
        print(res_l)
 
运行结果：
 
D:\Python34\python.exe "D:/Python Work Location/Python 0507/day10/服务端进程池.py"
等待建立连接中........
建立连接
客户端的地址是: ('127.0.0.1', 57599)
[<multiprocessing.pool.ApplyResult object at 0x00000000030774E0>]
等待建立连接中........
当前执行的进程PID是7564
建立连接
客户端的地址是: ('127.0.0.1', 57603)
[<multiprocessing.pool.ApplyResult object at 0x00000000030774E0>, <multiprocessing.pool.ApplyResult object at 0x0000000003077978>]
等待建立连接中........
当前执行的进程PID是13832
建立连接
客户端的地址是: ('127.0.0.1', 57604)
[<multiprocessing.pool.ApplyResult object at 0x00000000030774E0>, <multiprocessing.pool.ApplyResult object at 0x0000000003077978>, <multiprocessing.pool.ApplyResult object at 0x0000000003077550>]
等待建立连接中........
建立连接
客户端的地址是: ('127.0.0.1', 57608)
[<multiprocessing.pool.ApplyResult object at 0x00000000030774E0>, <multiprocessing.pool.ApplyResult object at 0x0000000003077978>, <multiprocessing.pool.ApplyResult object at 0x0000000003077550>, <multiprocessing.pool.ApplyResult object at 0x00000000030874A8>]
等待建立连接中........
建立连接
客户端的地址是: ('127.0.0.1', 57612)
[<multiprocessing.pool.ApplyResult object at 0x00000000030774E0>, <multiprocessing.pool.ApplyResult object at 0x0000000003077978>, <multiprocessing.pool.ApplyResult object at 0x0000000003077550>, <multiprocessing.pool.ApplyResult object at 0x00000000030874A8>, <multiprocessing.pool.ApplyResult object at 0x0000000003087550>]
等待建立连接中........
客户端发送过来的数据是:dfdsf
客户端发送过来的数据是:gdsgs
当前执行的进程PID是7564
客户端发送过来的数据是:gdsgdgg
当前执行的进程PID是13832
当前执行的进程PID是7564
 
从上面的程序可以看出： 
 进程池当中始终共享着开始创建的那num个进程,减小了创建进程的开销.