Socket 相关资料（随笔）

由于项目上的 http 请求量较大，项目上性能跟不上。于是考虑把 短连接的 http 换成 长连接的tcp 形式 试试效果。

先 研究了一下 长连接方式。就是要用到 socket 方面的知识。

package com.bkc.bpmp.common.utils;

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

/**
 * 搭建服务器端

a)、创建ServerSocket对象绑定监听端口。

b)、通过accept()方法监听客户端的请求。

c)、建立连接后，通过输入输出流读取客户端发送的请求信息。

d)、通过输出流向客户端发送请求信息。

e)、关闭相关资源。
 * @author ppnie
 *
 */
public class SocketService
{
    // 搭建服务器端
    public static void main(String[] args)
        throws IOException
    {
        SocketService socketService = new SocketService();
        // 1、a)创建一个服务器端Socket，即SocketService
        socketService.oneServer();
    }
    
    public void oneServer()
    {
        try
        {
            ServerSocket server = null;
            try
            {
                server = new ServerSocket(5209);
                // b)指定绑定的端口，并监听此端口。
                System.out.println("服务器启动成功");
                // 创建一个ServerSocket在端口5209监听客户请求
            }
            catch (Exception e)
            {
                System.out.println("没有启动监听：" + e);
                // 出错，打印出错信息
            }
            Socket socket = null;
            try
            {
                socket = server.accept();
                // 2、调用accept()方法开始监听，等待客户端的连接
                // 使用accept()阻塞等待客户请求，有客户
                // 请求到来则产生一个Socket对象，并继续执行
            }
            catch (Exception e)
            {
                System.out.println("Error." + e);
                // 出错，打印出错信息
            }
            // 3、获取输入流，并读取客户端信息
            String line;
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 由Socket对象得到输入流，并构造相应的BufferedReader对象
            PrintWriter writer = new PrintWriter(socket.getOutputStream());
            // 由Socket对象得到输出流，并构造PrintWriter对象
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            // 由系统标准输入设备构造BufferedReader对象
            System.out.println("Client:" + in.readLine());
            // 在标准输出上打印从客户端读入的字符串
            line = br.readLine();
            // 从标准输入读入一字符串
            // 4、获取输出流，响应客户端的请求
            while (!line.equals("end"))
            {
                // 如果该字符串为 "bye"，则停止循环
                writer.println(line);
                // 向客户端输出该字符串
                writer.flush();
                // 刷新输出流，使Client马上收到该字符串
                System.out.println("Server:" + line);
                // 在系统标准输出上打印读入的字符串
                System.out.println("Client:" + in.readLine());
                // 从Client读入一字符串，并打印到标准输出上
                line = br.readLine();
                // 从系统标准输入读入一字符串
            } // 继续循环
            
            // 5、关闭资源
            writer.close(); // 关闭Socket输出流
            in.close(); // 关闭Socket输入流
            socket.close(); // 关闭Socket
            server.close(); // 关闭ServerSocket
        }
        catch (Exception e)
        {// 出错，打印出错信息
            System.out.println("Error." + e);
        }
    }
}


package com.bkc.bpmp.common.utils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class SocketClient
{
    // 搭建客户端
    public static void main(String[] args)
        throws IOException
    {
        try
        {
            // 1、创建客户端Socket，指定服务器地址和端口
            // Socket socket=new Socket("127.0.0.1",5200);
            Socket socket = new Socket("192.168.1.99", 5209);
            System.out.println("客户端启动成功");
            // 2、获取输出流，向服务器端发送信息
            // 向本机的52000端口发出客户请求
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            // 由系统标准输入设备构造BufferedReader对象
            PrintWriter write = new PrintWriter(socket.getOutputStream());
            // 由Socket对象得到输出流，并构造PrintWriter对象
            // 3、获取输入流，并读取服务器端的响应信息
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 由Socket对象得到输入流，并构造相应的BufferedReader对象
            String readline;
            readline = br.readLine(); // 从系统标准输入读入一字符串
            while (!readline.equals("end"))
            {
                // 若从标准输入读入的字符串为 "end"则停止循环
                write.println(readline);
                // 将从系统标准输入读入的字符串输出到Server
                write.flush();
                // 刷新输出流，使Server马上收到该字符串
                System.out.println("Client:" + readline);
                // 在系统标准输出上打印读入的字符串
                System.out.println("Server:" + in.readLine());
                // 从Server读入一字符串，并打印到标准输出上
                readline = br.readLine(); // 从系统标准输入读入一字符串
            } // 继续循环
              // 4、关闭资源
            write.close(); // 关闭Socket输出流
            in.close(); // 关闭Socket输入流
            socket.close(); // 关闭Socket
        }
        catch (Exception e)
        {
            System.out.println("can not listen to:" + e);// 出错，打印出错信息
        }
    }
    
}

这是一个简单的 用java 实现 socket 客户端与服务端的 代码。

但是这样的例子，并不能实际运用与项目之中。在实际项目中需要考虑到 套接字的连接什么时候关闭，流什么时候关闭，参数的传入与信息的响应都需要得到结果。

若是这里使用的方法同 http 的话，应该是 一个请求一个对应的响应结果，若是长连接，应该如何把多线程与长连接 结合起来呢？

现在的项目是 使用C++ 服务端 和 java 客户端  来使用 socket 进行通信。

C++ 与 Java 之间的通信还涉及到了一个 网络字节码 不一致的问题。以及 还有一个 自定义协议 的问题

假设 自定义协议 为  

java 客户端代码（至于这里的BytePtr ，就是  网络字节码 的转码）

public class BytePtr {

    public static byte[] toLH(short n) {  
        byte[] b = new byte[2];  
        b[0] = (byte) (n & 0xff);  
        b[1] = (byte) (n >> 8 & 0xff);  
        return b;  
      }
    
    public   static   byte [] toLH( int  n) {  
        byte [] b =  new   byte [ 4 ];  
        b[0 ] = ( byte ) (n &  0xff );  
        b[1 ] = ( byte ) (n >>  8  &  0xff );  
        b[2 ] = ( byte ) (n >>  16  &  0xff );  
        b[3 ] = ( byte ) (n >>  24  &  0xff );  
        return  b;  
      }  
    
    public static byte[] addBytes(byte[] data1, byte[] data2) {  
        byte[] data3 = new byte[data1.length + data2.length];  
        System.arraycopy(data1, 0, data3, 0, data1.length);  
        System.arraycopy(data2, 0, data3, data1.length, data2.length);  
        return data3;  
      
    }
}

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

public class ChatClient
{
    
    public static void main(String[] args)
    {
        try
        {
            Socket client = new Socket("192.168.1.108", 10008);
            OutputStream out = client.getOutputStream();
            DataOutputStream outs = new DataOutputStream(out);
            Scanner scaner = new Scanner(System.in);
            genProtocol(outs, scaner.next());
            parseProtocol(client);
            
            outs.close();
            out.close();
            client.close();
        }
        catch (UnknownHostException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
    
    /**
     * 构造协议
     *
     * @param out
     * @param msg
     * @throws IOException
     */
    private static void genProtocol(DataOutputStream out, String msg)
        throws IOException
    {
        short type = 10001; // 消息类型
        byte[] bytes = msg.getBytes(); // 消息内容
        int totalLen = bytes.length; // 消息长度
        out.write((BytePtr.addBytes(BytePtr.addBytes(BytePtr.toLH(type), BytePtr.toLH(totalLen)), bytes))); // 写入消息内容
        out.flush();
    }
    
    private static void parseProtocol(Socket client)
        throws IOException
    {
        InputStream is = client.getInputStream();
        DataInputStream dis = new DataInputStream(is); // 读取Java标准数据类型的输入流
        
        // 协议解析
        
        int totalLen = dis.readInt(); // 读取消息长度
        byte[] data = new byte[totalLen]; // 定义存放消息内容的字节数组
        int len = is.read(data);
        String text = new String(data, 0, len);
        System.out.println("发来的内容是:" + text);
        
        is.close();
        dis.close();
    }
    
}

哦，这里还提到 一个工具 Wireshark，用来抓取包，来查看一下网络字节码到底传送的是一些什么

 

哦，还有  提到的 netty  技术，至于怎么用，还是先看看再说。

至于 有一些电子书之类的，可以 到脚本之家 去下载。

最最重要的一点，下载的电子书、视频、源码 之类的，一定要看啊。