一. HTTP全称是Hyper Transfer protocol ，即超文本传输协议，当今普遍采用版本Http1.1，HTTP协议已属于应用层协议，它构建在TCP之上，处于TCP/IP架构的顶端，为了更好的理解HTTP协议，我们基于java的SocketAPI设计一个简单的应用层通信协议，来窥探协议实现的一些过程与细节。
客户端向服务端发送一条命令，服务端接收到命令后，会判断命令是否为"HELLO"，若是则返回客户端"hello!",否则返回客户端"bye bye"。
1.协议请求：
1 package com.zqf.fenbushi;
2 //协议请求
3 //2016110758 邹奇方
4 public class Request {
5
6 /**
7 * 协议编码 0：GBK；1：UTF-8
8 */
9 private byte encode;
10 /**
11 * 命令
12 */
13 private String command;
14 /**
15 * 命令长度
16 */
17 private int commandLength;
18
19 public byte getEncode() {
20 return encode;
21 }
22
23 public void setEncode(byte encode) {
24 this.encode = encode;
25 }
26
27 public String getCommand() {
28 return command;
29 }
30
31 public void setCommand(String command) {
32 this.command = command;
33 }
34
35 public int getCommandLength() {
36 return commandLength;
37 }
38
39 public void setCommandLength(int commandLength) {
40 this.commandLength = commandLength;
41 }
42
43 }
2.协议响应：
1 package com.zqf.fenbushi;
2 //协议响应
3 //2016110758 邹奇方
4 public class Response {
5 /**
6 * 编码
7 */
8 private byte encode;
9 /**
10 * 响应
11 */
12 private String response;
13 /**
14 * 响应长度
15 */
16 private int responseLength;
17
18 public byte getEncode() {
19 return encode;
20 }
21
22 public void setEncode(byte encode) {
23 this.encode = encode;
24 }
25
26 public String getResponse() {
27 return response;
28 }
29
30 public void setResponse(String response) {
31 this.response = response;
32 }
33
34 public int getResponseLength() {
35 return responseLength;
36 }
37
38 public void setResponseLength(int responseLength) {
39 this.responseLength = responseLength;
40 }
41
42 @Override
43 public String toString() {
44 return "Response [encode=" + encode + ", response=" + response + ", responseLength=" + responseLength + "]";
45 }
46
47 }
3.客户端发送，以及服务端响应处理代码：
1 package com.zqf.fenbushi;
2 //客服端发送，以及服务端响应处理代码
3 //2016110758 邹奇方
4 import java.net.ServerSocket;
5 import java.net.Socket;
6
7
8 public class Server {
9 public static void main(String[] args) throws Exception{
10 System.out.println("开启服务器...");
11 ServerSocket server = new ServerSocket(16789);
12 while(true) {
13 Socket client = server.accept();
14 //读取请求数据
15 Request request = ProtocolUtil.readRequest(client.getInputStream());
16 //封装响应数据
17 Response response = new Response();
18 System.out.println("response"+response);
19 response.setEncode(Encode.UTF8.getValue());
20 response.setResponse(request.getCommand().equals("HELLO") ? "hello!" : "bye bye");
21 response.setResponseLength(response.getResponse().length());
22 //响应到客户端
23 ProtocolUtil.writeResponse(client.getOutputStream(), response);
24 }
25 }
26 }
4.客户端：
1 package com.zqf.fenbushi;
2 //客户端
3 //2016110758 邹奇方
4 import java.net.Socket;
5
6 public class Client {
7
8 public static void main(String[] args) throws Exception {
9 //组装请求数据
10 Request request = new Request();
11 request.setCommand("HELLO");
12 request.setCommandLength(request.getCommand().length());
13 request.setEncode(Encode.UTF8.getValue());
14 Socket client = new Socket("127.0.0.1", 16789);
15 System.out.println(client);
16
17
18 //发送请求
19 ProtocolUtil.writeRequest(client.getOutputStream(), request);
20 //读取相应
21 Response response = ProtocolUtil.readResponse(client.getInputStream());
22 System.out.println(response);
23 }
24 }
5.ProtocolUtil 类：
1 package com.zqf.fenbushi;
2
3 //2016110758 邹奇方
4 import java.io.InputStream;
5 import java.io.OutputStream;
6
7 public class ProtocolUtil {
8
9 public static void writeRequest(OutputStream out, Request request) {
10 try {
11 out.write(request.getEncode());
12 //write一个int值会截取其低8位传输，丢弃其高24位，因此需要将基本类型转化为字节流
13 //java采用Big Endian字节序，而所有的网络协议也都是以Big Endian字节序来进行传输，所以再进行数据的传输和接收时，需要先将数据转化成Big Endian字节序
14 //out.write(request.getCommandLength());
15 out.write(int2ByteArray(request.getCommandLength()));
16 out.write(Encode.GBK.getValue() == request.getEncode() ? request.getCommand().getBytes("GBK") : request.getCommand().getBytes("UTF8"));
17 out.flush();
18 } catch (Exception e) {
19 System.err.println(e.getMessage());
20 }
21 }
22
23 /**
24 * 将响应输出到客户端
25 * @param os
26 * @param response
27 */
28 public static void writeResponse(OutputStream out, Response response) {
29 try {
30 out.write(response.getEncode());
31 out.write(int2ByteArray(response.getResponseLength()));
32 out.write(Encode.GBK.getValue() == response.getEncode() ? response.getResponse().getBytes("GBK") : response.getResponse().getBytes("UTF8"));
33 out.flush();
34 } catch (Exception e) {
35 System.err.println(e.getMessage());
36 }
37 }
38
39 public static Request readRequest(InputStream is) {
40 Request request = new Request();
41 try {
42 //读取编码
43 byte [] encodeByte = new byte[1];
44 is.read(encodeByte);
45 byte encode = encodeByte[0];
46 //读取命令长度
47 byte [] commandLengthByte = new byte[4];//缓冲区
48 is.read(commandLengthByte);
49 int commandLength = byte2Int(commandLengthByte);
50 //读取命令
51 byte [] commandByte = new byte[commandLength];
52 is.read(commandByte);
53 String command = Encode.GBK.getValue() == encode ? new String(commandByte, "GBK") : new String(commandByte, "UTF8");
54 //组装请求返回
55 request.setEncode(encode);
56 request.setCommand(command);
57 request.setCommandLength(commandLength);
58 } catch (Exception e) {
59 System.err.println(e.getMessage());
60 }
61 return request;
62 }
63
64 public static Response readResponse(InputStream is) {
65 Response response = new Response();
66 try {
67 byte [] encodeByte = new byte[1];
68 is.read(encodeByte);
69 byte encode = encodeByte[0];
70 byte [] responseLengthByte = new byte[4];
71 is.read(responseLengthByte);
72 int commandLength = byte2Int(responseLengthByte);
73 byte [] responseByte = new byte[commandLength];
74 is.read(responseByte);
75 String resContent = Encode.GBK.getValue() == encode ? new String(responseByte, "GBK") : new String(responseByte, "UTF8");
76 response.setEncode(encode);
77 response.setResponse(resContent);
78 response.setResponseLength(commandLength);
79 } catch (Exception e) {
80 System.err.println(e.getMessage());
81 }
82 return response;
83 }
84
85 public static int byte2Int(byte [] bytes) {
86 int num = bytes[3] & 0xFF;
87 num |= ((bytes[2] << 8) & 0xFF00);
88 num |= ((bytes[1] << 16) & 0xFF0000);
89 num |= ((bytes[0] << 24) & 0xFF000000);
90 return num;
91 }
92
93 public static byte[] int2ByteArray(int i) {
94 byte [] result = new byte[4];
95 result[0] = (byte) ((i >> 24) & 0xFF);
96 result[1] = (byte) ((i >> 16) & 0xFF);
97 result[2] = (byte) ((i >> 8) & 0xFF);
98 result[3] = (byte) (i & 0xFF);
99 return result;
100 }
101
102 }
6.Encode类：
1 package com.zqf.fenbushi;
2
3 //2016110758 邹奇方
4 public class Encode {
5
6 private byte enCode; //编码，取值1表示 utf-8编码，取值0表示 gbk编码
7
8
9 public static Encode UTF8 = new Encode("utf-8");
10 public static Encode GBK = new Encode("gbk");
11
12 public Encode(String enCode){
13
14 if(enCode.equals("utf-8")){
15 this.enCode = 1;
16 }
17 if(enCode.equals("gbk")){
18 this.enCode = 0;
19 }
20 }
21
22 public byte getValue(){
23
24 return this.enCode;
25
26 }
27
28 //测试
29 public static void main(String[] args) {
30
31 System.out.println(Encode.UTF8.getValue());
32 System.out.println(Encode.GBK.getValue());
33
34 }
35
36 }
以上代码运行结果：（在客服端输入HELLO，则输出hello,输入不是HELLO,则输出为bye bye）
（此输入为HELLO）
（此输入不是HELLO）
二.HTTP请求与响应
下图是HTTP请求与响应的过程步骤，在此不详细赘述。
三.通过HttpClient发送HTTP请求
HttpClient对HTTP协议通信的过程进行了封装，下面是简单的通过HttpClient发送HTTP GET请求，并获取服务端响应的代码：
1 //url前加上http协议头，标明该请求为http请求 2 String url = "https://www.baidu.com";
3 //组装请求
4 HttpClient httpClient = new DefaultHttpClient();
5 HttpGet httpGet = new HttpGet(url);
6 //接收响应
7 HttpResponse response = httpClient.execute(httpGet);
8 HttpEntity entity = response.getEntity();
9 byte[] byteArray = EntityUtils.toByteArray(entity);
10 String result = new String(byteArray, "utf8");
11 System.out.println(result);
四.使用HTTP协议的优势
随着请求规模的扩展，基于TCP协议的RPC的实现，需要考虑多线程并发、锁、I/O等复杂的底层细节，在大流量高并发的压力下，任何一个小的错误都可能被无限放大，最终导致程序宕机。而对于基于HTTP协议的实现来说，很多成熟的开源web容易已经帮其处理好了这些事情，如Apache，Tomcat，Jboss等，开发人员可将更多的精力集中在业务实现上，而非处理底层细节。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
