Java的Socket實現(xiàn)長連接以及數(shù)據(jù)的發(fā)送和接收方式

更新時間：2023年09月28日 10:14:42 作者：誰把我名字用了!

這篇文章主要介紹了Java的Socket實現(xiàn)長連接以及數(shù)據(jù)的發(fā)送和接收方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

Socket實現(xiàn)長連接以及數(shù)據(jù)的發(fā)送和接收

既然是長連接就免不了心跳檢測，這里使用了一種比較簡單的做法：服務(wù)端對當(dāng)前線程計時，重要的話說三遍，服務(wù)端、服務(wù)端、服務(wù)端！

如果超時沒有收到任何數(shù)據(jù)就關(guān)閉該線程對應(yīng)的Socket。

代碼復(fù)制粘貼即可運行。

發(fā)送時：將String轉(zhuǎn)byte[]
接收時：將byte[]轉(zhuǎn)String

效果圖

客戶端代碼

 
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class SocketClient
{
    public static void main(String[] args)
    {
        try
        {
            Socket socket = new Socket("localhost", 8888);
            //得到一個輸出流，用于向服務(wù)器發(fā)送數(shù)據(jù)
            OutputStream outputStream = socket.getOutputStream();
            System.out.println("請輸入16進(jìn)制數(shù)據(jù):");
            Scanner sc = new Scanner(System.in);
            while (true)
            {
                String data = sc.nextLine();
                if ("exit".equals(data))
                {
                    return;
                }
                byte[] byteArray = HexStrToByteArray(data);
                outputStream.write(byteArray);
                //刷新緩沖
                outputStream.flush();
                //得到一個輸入流，用于接收服務(wù)器響應(yīng)的數(shù)據(jù)
                InputStream inputStream = socket.getInputStream();
                byte[] bytes = new byte[1]; // 一次讀取一個byte
                String info = "";
                while (true)
                {
                    if (inputStream.available() > 0)
                    {
                        inputStream.read(bytes);
                        String hexStr = ByteArrayToHexStr(bytes);
                        info += HexStrToStr(hexStr);
                        //已經(jīng)讀完
                        if (inputStream.available() == 0)
                        {
                            System.out.println("收到來自服務(wù)端的信息:" + info);
                            break;
                        }
                    }
                }
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
    /**
     * 16進(jìn)制Str轉(zhuǎn)byte[]
     *
     * @param hexStr
     * @return
     */
    public static byte[] HexStrToByteArray(String hexStr)
    {
        if (hexStr == null)
        {
            return null;
        }
        if (hexStr.length() == 0)
        {
            return new byte[0];
        }
        byte[] byteArray = new byte[hexStr.length() / 2];
        for (int i = 0; i < byteArray.length; i++)
        {
            String subStr = hexStr.substring(2 * i, 2 * i + 2);
            byteArray[i] = ((byte) Integer.parseInt(subStr, 16));
        }
        return byteArray;
    }
    /**
     * byte[]轉(zhuǎn)16進(jìn)制Str
     *
     * @param byteArray
     */
    public static String ByteArrayToHexStr(byte[] byteArray)
    {
        if (byteArray == null)
        {
            return null;
        }
        char[] hexArray = "0123456789ABCDEF".toCharArray();
        char[] hexChars = new char[byteArray.length * 2];
        for (int i = 0; i < byteArray.length; i++)
        {
            int temp = byteArray[i] & 0xFF;
            hexChars[i * 2] = hexArray[temp >>> 4];
            hexChars[i * 2 + 1] = hexArray[temp & 0x0F];
        }
        return new String(hexChars);
    }
    /**
     * 16進(jìn)制的Str轉(zhuǎn)Str
     *
     * @param hexStr
     * @return
     */
    public static String HexStrToStr(String hexStr)
    {
        //能被16整除,肯定可以被2整除
        byte[] array = new byte[hexStr.length() / 2];
        try
        {
            for (int i = 0; i < array.length; i++)
            {
                array[i] = (byte) (0xff & Integer.parseInt(hexStr.substring(i * 2, i * 2 + 2), 16));
            }
            hexStr = new String(array, "UTF-8");
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return "";
        }
        return hexStr;
    }
}

服務(wù)端代碼

使用InputStream對象的available()方法判斷客戶端的內(nèi)容是否發(fā)送完畢

dataInputStream.available()

官方解釋：

返回此輸入流下一個方法調(diào)用可以不受阻塞地從此輸入流讀取（或跳過）的估計字節(jié)數(shù)。

下一個調(diào)用可能是同一個線程，也可能是另一個線程。

一次讀取或跳過此估計數(shù)個字節(jié)不會受阻塞，但讀取或跳過的字節(jié)數(shù)可能小于該數(shù)。

用我的大白話就是：返回剩余未讀長度

 
import java.io.*;
import java.net.Socket;
/**
 * 長連接
 */
public class ServerThread extends Thread
{
    //16進(jìn)制數(shù)字字符集
    public static final String HEXSTRING = "0123456789ABCDEF";
    //心跳超時時間
    private static final int TIMEOUT = 60 * 1000;
    private Socket m_socket;
    //接收到數(shù)據(jù)的最新時間
    private long m_lastReceiveTime = System.currentTimeMillis();
    //該線程是否正在運行
    private boolean m_isRuning = false;
    public ServerThread(Socket socket)
    {
        this.m_socket = socket;
    }
    @Override
    public void start()
    {
        if (m_isRuning)
        {
            System.out.println(">>>線程" + this.getId() + "啟動失敗,該線程正在執(zhí)行");
            return;
        }
        else
        {
            m_isRuning = true;
            super.start();
        }
    }
    @Override
    public void run()
    {
        //字節(jié)輸入流
        InputStream inputStream = null;
        //字節(jié)輸出流
        OutputStream outputStream = null;
        try
        {
            inputStream = m_socket.getInputStream();
            outputStream = m_socket.getOutputStream();
            String info = "";
            //按byte讀
            byte[] bytes = new byte[1];
            while (m_isRuning)
            {
                //檢測心跳
                if (System.currentTimeMillis() - m_lastReceiveTime > TIMEOUT)
                {
                    m_isRuning = false;
                    //跳出,執(zhí)行finally塊
                    break;
                }
                //返回下次調(diào)用可以不受阻塞地從此流讀取或跳過的估計字節(jié)數(shù),如果等于0則表示已經(jīng)讀完
                if (inputStream.available() > 0)
                {
                    //重置接收到數(shù)據(jù)的最新時間
                    m_lastReceiveTime = System.currentTimeMillis();
                    inputStream.read(bytes);
                    String tempStr = ByteArrayToHexStr(bytes) ;
                    info += tempStr;
                    //已經(jīng)讀完
                    if (inputStream.available() == 0)
                    {
                        System.out.println(">>>線程" + this.getId() + "收到:" + info);
                        String responseStr = "Hello";
                        //響應(yīng)內(nèi)容
                        String hexStr = StrToHexStr(responseStr);
                        hexStr = hexStr.replaceAll("0[x|X]|,","");
                        byte[] byteArray = HexStrToByteArray(hexStr);
                        outputStream.write(byteArray);
                        outputStream.flush();
                        //重置,不然每次收到的數(shù)據(jù)都會累加起來
                        info = "";
                        System.out.println(">>>線程" + this.getId() + "回應(yīng):" + responseStr);
                    }
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        //關(guān)閉資源
        finally
        {
            System.out.println(">>>線程" + this.getId() + "的連接已斷開\n");
            try
            {
                if (outputStream != null)
                    outputStream.close();
                if (inputStream != null)
                    inputStream.close();
                if (m_socket != null)
                    m_socket.close();
                m_isRuning = false;
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
    /**
     * byte[]轉(zhuǎn)16進(jìn)制Str
     *
     * @param byteArray
     */
    public static String ByteArrayToHexStr(byte[] byteArray)
    {
        if (byteArray == null)
        {
            return null;
        }
        char[] hexArray = HEXSTRING.toCharArray();
        char[] hexChars = new char[byteArray.length * 2];
        for (int i = 0; i < byteArray.length; i++)
        {
            int temp = byteArray[i] & 0xFF;
            hexChars[i * 2] = hexArray[temp >>> 4];
            hexChars[i * 2 + 1] = hexArray[temp & 0x0F];
        }
        return new String(hexChars);
    }
    /**
     * Str轉(zhuǎn)16進(jìn)制Str
     *
     * @param str
     * @return
     */
    public static String StrToHexStr(String str)
    {
        //根據(jù)默認(rèn)編碼獲取字節(jié)數(shù)組
        byte[] bytes = str.getBytes();
        StringBuilder stringBuilder = new StringBuilder(bytes.length * 2);
        //將字節(jié)數(shù)組中每個字節(jié)拆解成2位16進(jìn)制整數(shù)
        for (int i = 0; i < bytes.length; i++)
        {
            stringBuilder.append("0x");
            stringBuilder.append(HEXSTRING.charAt((bytes[i] & 0xf0) >> 4));
            stringBuilder.append(HEXSTRING.charAt((bytes[i] & 0x0f) >> 0));
            //去掉末尾的逗號
            if (i != bytes.length - 1)
            {
                stringBuilder.append(",");
            }
        }
        return stringBuilder.toString();
    }
    /**
     * 16進(jìn)制Str轉(zhuǎn)byte[]
     *
     * @param hexStr 不帶空格、不帶0x、不帶逗號的16進(jìn)制Str,如:06EEF7F1
     * @return
     */
    public static byte[] HexStrToByteArray(String hexStr)
    {
        byte[] byteArray = new byte[hexStr.length() / 2];
        for (int i = 0; i < byteArray.length; i++)
        {
            String subStr = hexStr.substring(2 * i, 2 * i + 2);
            byteArray[i] = ((byte) Integer.parseInt(subStr, 16));
        }
        return byteArray;
    }
}

開啟服務(wù)端

 
import java.net.ServerSocket;
import java.net.Socket;
public class MySocketServer
{
    public static void main(String[] args)
    {
        try
        {
            System.out.println(">>>服務(wù)啟動,等待終端的連接\n");
            ServerSocket server = new ServerSocket(8888);
            int count = 0;
            while (true)
            {
                //開啟監(jiān)聽
                Socket socket = server.accept();
                count++;
                System.out.println(">>>開啟第" + count + "次長連接...");
                ServerThread thread = new ServerThread(socket);
                thread.start();
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}