JavaはTCP通信を実現します

9607 ワード

TCP（Transyssion Control Protocol）は、転送制御プロトコルである。は、接続に向けた信頼性の高い、バイトストリームベースのトランスポート層通信プロトコルである。UDPと違ってTCPは信頼できるパイプのような接続を提供しています。
JavaにおけるTCPは主にServerSocketとSocketの2つのクラスに関する。前者はサービスエンドのエンティティと考えられ、接続を受けるために用いられる。後者は接続のパッケージと考えられ、パイプのようなデータを伝送する。
以下はサービスとクライアントを実現します。
サービス:

public class TCPService {
    public static final String SERVICE_IP = "127.0.0.1";

    public static final int SERVICE_PORT = 10101;

    public static final char END_CHAR = '#';

    public static void main(String[] args) {
        TCPService service = new TCPService();
        //     
        service.startService(SERVICE_IP,SERVICE_PORT);
    }

    private void startService(String serverIP, int serverPort){
        try {
            //       
            InetAddress serverAddress = InetAddress.getByName(serverIP);
            //     
            try(ServerSocket service = new ServerSocket(serverPort, 10, serverAddress)){
                while (true) {
                    StringBuilder receiveMsg = new StringBuilder();
                    //      ，        ，        
                    try(Socket connect = service.accept()){
                        //     
                        InputStream in = connect.getInputStream();
                        
                        //     ，       ，         
                        for (int c = in.read(); c != END_CHAR; c = in.read()) {
                            if(c ==-1)
                                break;
                            receiveMsg.append((char)c);
                        }
                        
                        //      
                        String response = "Hello world " + receiveMsg.toString() + END_CHAR;
                        
                        //     ，                 
                        OutputStream out = connect.getOutputStream();
                        out.write(response.getBytes());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

クライアント

public class TCPClient {

    public static void main(String[] args) {
        TCPClient client = new TCPClient();
        SimpleDateFormat format = new SimpleDateFormat("hh-MM-ss");
        Scanner scanner = new Scanner(System.in);
        while(true){
            String msg = scanner.nextLine();
            if("#".equals(msg))
                break;
            //       
            System.out.println("send time : " + format.format(new Date()));
            System.out.println(client.sendAndReceive(TCPService.SERVICE_IP,TCPService.SERVICE_PORT,msg));
            System.out.println("receive time : " + format.format(new Date()));
        }
    }

    private String sendAndReceive(String ip, int port, String msg){
        //      ，            ，            ，    
        msg = msg+TCPService.END_CHAR;
        StringBuilder receiveMsg = new StringBuilder();
        //      ，         
        try (Socket client = new Socket(ip, port)){
            //         ，     
            OutputStream out = client.getOutputStream();
            out.write(msg.getBytes());

            //         ，           
            InputStream in = client.getInputStream();
            for (int c = in.read(); c != TCPService.END_CHAR; c = in.read()) {
                if(c==-1)
                    break;
                receiveMsg.append((char)c);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return receiveMsg.toString();
    }
}

コード構造の観点から見ると、UDP通信サービスはクライアントコードと同じであり、DatagramPacketオブジェクトに依存して情報を送受信する。TCP通信では、サービス側にエンティティがあるだけで、クライアントはソケットを介して情報を送受信すればよく、Socketを終了するように送信します。
上の点に注意したいのですが、入力ストリームを読むときは、必ず読み出しフロー終了の判断をしなければなりません。つまり、-1を読んで、判断をしないと、エラーが発生します。もし一つの接続が成功したら、何の情報も発生していないか、または情報の中にエンド文字がないと、コネクションがオフになります。TCP接続は双方向ですので、他端がずっと入力ストリームからフロー終了フラグまで読んでしまうと、すぐにOOMにつながるので、終端符まで読む時は、即時にループを飛び出す必要があります。終端符は接続が中断された時のみ発行されますが、入力待ちの場合は発生しませんので、応答待ちの時に文字が読み終わったために、サービスエンドやクライアントが接続を事前に中断する心配はありません。
また、ソケットとServerSocketは、jdk 1.7以降にAutoCloseインターフェースを実現しているので、try-with-resource構造を使用することができます。前のUDPのDatagramPacketも同じです。
これは簡単なブロッキング型サーバモデルです。コードを解析すると、一度の要求時間が長すぎると、後続の要求の実行に影響があることが分かります。サービス端末の出力にsleepを追加して、二つのクライアントを起動して、それぞれメッセージを送ります。logを観察して、サービス端末は5 s遅延します。結果は以下の通りです。

   1：
send time : 06-04-06
Hello world 1
receive time : 06-04-11
   2：
send time : 06-04-08
Hello world 2
receive time : 06-04-16

クライアント1が先に送信され、クライアント2が送信されると、クライアント2の要求はサーバの処理が完了するのを待ってから処理されることがわかる。
これにより、サーバーが長時間の処理を要求された場合、後続の要求をブロックすることが予想され、このようなタイプのサーバが攻撃されやすい理由である。このような状況に対応するために、私たちは要求を受けた時に、サブスレッドを呼び出して処理してもいいです。サーバは要求を受け付けた状態です。

public class TCPService1 {
    public static final String SERVICE_IP = "127.0.0.1";

    public static final int SERVICE_PORT = 10101;

    public static final char END_CHAR = '#';

    public static void main(String[] args) {
        TCPService1 service1 = new TCPService1();
        service1.startService();
    }

    private void startService(){
        try {
            InetAddress address = InetAddress.getByName(SERVICE_IP);
            Socket connect = null;
            ExecutorService pool = Executors.newFixedThreadPool(5);
            try (ServerSocket service = new ServerSocket(SERVICE_PORT,5,address)){
                while(true){
                    connect = service.accept();
                    //      
                    ServiceTask serviceTask = new ServiceTask(connect);
                    //         
                    pool.execute(serviceTask);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(connect!=null)
                    connect.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class ServiceTask implements Runnable{
        private Socket socket;

        ServiceTask(Socket socket){
            this.socket = socket;
        }
        @Override
        public void run() {
            try {
                StringBuilder receiveMsg = new StringBuilder();
                InputStream in = socket.getInputStream();
                for (int c = in.read(); c != END_CHAR; c = in.read()) {
                    if(c ==-1)
                        break;
                    receiveMsg.append((char)c);
                }
                String response = "Hello world " + receiveMsg.toString() + END_CHAR;
                Thread.currentThread().sleep(5000);
                OutputStream out = socket.getOutputStream();
                out.write(response.getBytes());
            }catch (Exception e){
                e.printStackTrace();
            }finally {
               if(socket!=null)
                   try {
                       socket.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
            }
        }
    }
}

このサーバーでは、スレッドプールのやり方を採用しています。要求するたびに、スレッドプールにタスクを追加します。実際の運行状況は以下の通りです。

   1
send time : 03-04-59
Hello world 1
receive time : 03-04-04
   2
send time : 03-04-01
Hello world 2
receive time : 03-04-06

各クライアントは、情報を送信した後に応答を得ることができ、列に並ぶ必要がない。しかし、このようなタイプのサーバーはリアルタイム応答を保証できません。要求が多すぎると、サーバリソースが消耗されたり、サーバに最大スレッド数が制限されたりします。余分な要求は依然としてブロックされます。
第二のサーバーモデルでは、ストリームを読み込む時にユーザー定義の終端符を入れて、forループを採用していますが、一度に入力ストリームから一つのデータを読むと、効率が低くなります。バッファリングの方法が使えます。しかし、この方法では自定の終端符を判断できません。流れが終わると判断できます。クライアントがデータを送信した後、出力ストリームを閉じます。

OutputStream out = client.getOutputStream();
out.write(msg.getBytes());
client.shutdownOutput();
InputStream in = client.getInputStream();
int len;
byte[] buffer = new byte[1024];
while((len = in.read(buffer))!=-1)
       receiveMsg.append(new String(buffer,0,len));

TCP通信は双方向なので、片端を単独で閉じることができますが、直接に入力または出力ストリームをオフにすることはできません。このようにすると、ソケット全体がオフになります。
最後に関連するいくつかの種類を簡単に紹介します。
1.Socketにはこのような構造方法がたくさんありますが、目的は一つしかなく、サービス端末へのリンクを作成して、データを送受信することです。

Socket(InetAddress address, int port)  //  InetAddress       
Socket(InetAddress address, int port, InetAddress localAddr, int localPort) //                      
Socket(String host, int port) //            
Socket(String host, int port, InetAddress localAddr, int localPort)

上の構造は二つの種類に分けられています。一つはサービス端末の住所とポートのみを指定しています。他のクラスは、第1クラスに加えて、クライアントのアドレスとポート番号も指定されている。最初のクラスは、クライアントのアドレスとして、クライアントポートとして利用可能なポートをランダムに選択します。
常用方法：

OutputStream getOutputStream()//     
InputStream getInputStream() //     
void connect(SocketAddress endpoint) //      
void connect(SocketAddress endpoint, int timeout)//      ，       
//              
InetAddress getLocalAddress()
int getLocalPort()
SocketAddress getLocalSocketAddress()
//             
int getPort()
InetAddress getInetAddress()
SocketAddress getRemoteSocketAddress()

2.ServerSocketの構造方法

ServerSocket(int port) //       ，  tcp   50，           ，       
ServerSocket(int port, int backlog) //         
ServerSocket(int port, int backlog, InetAddress bindAddr) //

常用方法：

Socket accept() //         ，     
void bind(SocketAddress endpoint) //                
void bind(SocketAddress endpoint, int backlog)
//         
InetAddress getInetAddress()
int getLocalPort()
SocketAddress getLocalSocketAddress()

Wrapping Text Inside Pr Tags

jqueryは広告バースライド効果を実現します。