一直不理解Http协议，觉得很抽象很神秘，看 《how tomcat work》时看到搭建了一个简单的http服务器，发现协议其实就是对消息格式的规范，就是大家都按这个规范约定的格式发消息收消息。
1.建立sockerserver服务
ServerSocket serverSocket = null;
		int port = 8088;
		try {
			serverSocket = new ServerSocket(port, 1, InetAddress
					.getByName("127.0.0.1"));
			log.info("服务启动");
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
2.监听相应端口
socket = serverSocket.accept();
				input = socket.getInputStream();
				output = socket.getOutputStream();

3.对监听到的字节进行解析
// create Request object and parse
				Request request = new Request(input);
				request.parse();
Request 实际上就是解析HTTP协议并得到资源的请求路径uri。
public void parse() {
		// Read a set of characters from the socket
		StringBuffer request = new StringBuffer(2048);
		int i;
		byte[] buffer = new byte[2048];
		try {
			i = input.read(buffer);
		} catch (IOException e) {
			e.printStackTrace();
			i = -1;
		}
		for (int j = 0; j < i; j++) {
			request.append((char) buffer[j]);
		}
		log.info("request head /n"+request.toString());
		uri = parseUri(request.toString());
	}

	private String parseUri(String requestString) {
		int index1, index2;
		index1 = requestString.indexOf(' ');
		if (index1 != -1) {
			index2 = requestString.indexOf(' ', index1 + 1);
			if (index2 > index1)
				return requestString.substring(index1 + 1, index2);
		}
		return null;
	}
4.对请求进行响应
// create Response object
				Response response = new Response(output);
				response.setRequest(request);
				response.sendStaticResource();
这里实际上根据request分析的uri进行资源的字节化，输出到socket的out
public void sendStaticResource() throws IOException {
		byte[] bytes = new byte[BUFFER_SIZE];
		FileInputStream fis = null;
		try {
			File file = new File(HttpServer.WEB_ROOT, request.getUri());
			if (file.exists()) {
				fis = new FileInputStream(file);
				int ch = fis.read(bytes, 0, BUFFER_SIZE);
				while (ch != -1) {
					output.write(bytes, 0, ch);
					ch = fis.read(bytes, 0, BUFFER_SIZE);
				}
			} else {
				// file not found
				String errorMessage = "HTTP/1.1 404 File Not Found/r/n"
						+ "Content-Type: text/html/r/n"
						+ "Content-Length: 23/r/n" + "/r/n" +

						"<h1>File Not Found</h1>";
				output.write(errorMessage.getBytes());
			}
		} catch (Exception e) {
			// thrown if cannot instantiate a File object
			System.out.println(e.toString());
		} finally {
			if (fis != null)
				fis.close();
		}
	}
可以看到其实就是简单的将资源用字节流输出。
最后提供完整的代码包（http://download.csdn.net/source/3194644），运行HttpServer.java 后可以通过浏览器访问：http://localhost:8088/index.htm 可以看到静态页面，通过后台可以看到请求的Http信息。

现在碰到了一个棘手的服务器问题，描述如下：服务器采用netty的tcp协议作为client-server的通讯方式，tcp的好处是与客户端的连接为长连接，消息格式精简，传递比较快速，而且服务器可以发送push消息。但现在的问题是，公司的网络出口ip经常会变更，而tcp是根据ip+port来判断客户端连接的，因此随着ip的变化，该连接肯定失效了。游戏会发生让玩家重新登陆的情况，这样的话，玩家是无法接受的，相当于无缘无故被踢出了游戏。
 
但是不少公司都是仅有几个出口ip，说明这种情况还是比较多见的，而且像qq等软件，用了tcp或者udp协议，也可以很好的适应这种环境，因此肯定有合适的解决方案。现在想到的一种办法是，每个tcp请求，都带有session信息，可以用一个64位的标志id的字节来存储，这样对协议增加的网络流量是微乎其微的，服务器需要对每个请求sessionId进行处理，判断是否有效，如果有效的话可以直接跟服务器通讯，无效的话需要重新登陆，获取新的sessionId。
 
另外一个重要问题是，客户端的tcp连接是无法估计保障的，可能玩家会突然关闭浏览器，而不会给服务器发送close信息。如果服务器对每个客户端的连接建立一个对象的话，需要管理这个对象的生命周期，设置一个失效时间，例如30分钟，如果30分钟没有操作的话，就自动销毁，这样可以防止对象累计越来越多产生内存泄露的情况。

使用python在网络上传送图片数据，需要以byte格式读取图片，这样才可以通过socket传输。

当客户端连上服务器，服务器首先把图片数据的尺寸传输过去，然后再传输图片。

服务器端代码

# server
import socket               # 导入 socket 模块

s = socket.socket()         # 创建 socket 对象
host = socket.gethostname()  # 获取本地主机名
port = 12345                # 设置端口
s.bind((host, port))        # 绑定端口

pic_path = r'd:\Pictures\7.JPG'

with open(pic_path, 'rb') as f:
    data = f.read()

s.listen(5)                 # 等待客户端连接
while True:
    conn, addr = s.accept()     # 建立客户端连接
    print('连接地址:', addr)
    conn.send(str(len(data)).encode('utf-8'))
    conn.send(data)
    conn.close()                # 关闭连接

客户端连接到服务器端后，会首先接收图片数据大小以方便处理，然后接收图片数据，写到路径下。

客户端代码

import socket  # 导入 socket 模块


s = socket.socket()  # 创建 socket 对象
host = socket.gethostname() 
port = 12345  # 设置端口号

s.connect((host, port))
r = s.recv(1024)
print(r)
data_len = eval(r)
data = s.recv(data_len)
s.close()


with open(r'C:\Users\Desktop\1.png', 'ba') as f:
    f.write(data)
    f.close()


 

参考：https://www.runoob.com/python/python-socket.html

 

sk.bind(address)
s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组(host,port)的形式表示地址。
sk.listen(backlog)
开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列
sk.setblocking(bool)
是否阻塞(默认True)，如果设置False，那么accept和recv时一旦无数据，则报错。
sk.accept()
接受连接并返回(conn,address),其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
接收TCP 客户的连接(阻塞式)等待连接的到来
sk.connect(address)
连接到address处的套接字。一般，address的格式为元组(hostname,port),如果连接出错，返回socket.error错误。
sk.connect_ex(address)
同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
sk.close()
关闭套接字
sk.recv(bufsize[,flag])
接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
sk.recvfrom(bufsize[.flag])
与recv()类似，但返回值是(data,address)。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
sk.send(string[,flag])
将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
sk.sendall(string[,flag])
将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
内部通过递归调用send，将所有内容发送出去。
sk.sendto(string[,flag],address)
将数据发送到套接字，address是形式为(ipaddr，port)的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
sk.settimeout(timeout)
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作(如 client 连接最多等待5s )
sk.getpeername()
返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)。
sk.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr,port)
sk.fileno()
套接字的文件描述符