Java TCP Socket编程

1.TCP Socket在Java上的实现

Java 为 TCP 协议提供了两个类:Socket 类和 ServerSocket 类。一个 Socket 实例代表了TCP 连接的一端。一个 TCP 连接(TCP connection)是一条抽象的双向信道,两端分别由 IP地址和端口号确定。在开始通信之前,要建立一个 TCP 连接,这需要先由客户端 TCP 向服务器端 TCP 发送连接请求。ServerSocket 实例则监听 TCP 连接请求,并为每个请求创建新的 Socket 实例。也就是说,服务器端要同时处理 ServerSocket 实例和 Socket 实例,而客户端只需要使用 Socket 实例。每个Socket实例会关联一个InputStream和OutputStream对象，我们通过将字节写入套接字的OutputStream来发送数据，并通过从InputStream来接收数据。

2.TCP连接的建立步骤

  客户端向服务器端发送连接请求后，就被动地等待服务器的响应。典型的TCP客户端要经过下面三步操作： 

   1、创建一个Socket实例：构造函数向指定的远程主机和端口建立一个TCP连接；

   2.通过套接字的I/O流与服务端通信；

   3、使用Socket类的close方法关闭连接。

 

  服务端的工作是建立一个通信终端，并被动地等待客户端的连接。典型的TCP服务端执行如下两步操作：

     1、创建一个ServerSocket实例并指定本地端口，用来监听客户端在该端口发送的TCP连接请求；

     2、重复执行：

           1）调用ServerSocket的accept（）方法以获取客户端连接，并通过其返回值创建一个Socket实例；

           2）为返回的Socket实例开启新的线程，并使用返回的Socket实例的I/O流与客户端通信；

           3）通信完成后，使用Socket类的close（）方法关闭该客户端的套接字连接

       

3.TCP Demo

Demo1.基本的流发送示例：

服务端开启一个TCP服务器，参数为端口号

客户端启动一个TCP服务，参数为服务端的地址，发送的字符，端口号

import java.net.Socket;
import java.net.SocketException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TCPClient {

    public static void main(String[] args) throws IOException {

        if ((args.length < 2) || (args.length > 3))

            throw new IllegalArgumentException(
                    "Parameter(s):<Server> <Word> [<Port>]");

        String server = args[0]; // Server name or IP address
        /* Convert argument String to bytes using the default character encoding */
        byte[] senddata = args[1].getBytes();
        int servPort = (args.length == 3) ? Integer.parseInt(args[2]) : 7;
        /* Create socket that is connected to server onspecified port*/
        Socket socket = new Socket(server, servPort);
        System.out.println("Connected to server...sending echo string");

        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        out.write(senddata); // Send the encoded string to the server

        int totalBytesRcvd = 0; // Total bytes received so far
        byte[] recvdata = new byte[in.available()];
        int bytesRcvd; // Bytes received in last read
        while (totalBytesRcvd < recvdata.length) {
            if ((bytesRcvd = in.read(recvdata, totalBytesRcvd, recvdata.length
                    - totalBytesRcvd)) == -1)
                throw new SocketException("Connection closed prematurely");
            totalBytesRcvd += bytesRcvd;
        } // data array is full

        System.out.println("Received: " + new String(recvdata));

        socket.close(); // Close the socket and its streams
    }
}

import java.net.*; // for Socket, ServerSocket, andInetAddress
import java.io.*; // for IOException and Input/OutputStream

public class TCPServer {

    private static final int BUFSIZE = 32; // Size of receivebuffer

    public static void main(String[] args) throws IOException {

        if (args.length != 1) // Test for correct # of args
            throw new IllegalArgumentException("Parameter(s): <Port>");

        int servPort = Integer.parseInt(args[0]);

        /* Create a server socket to accept client connection requests */
        ServerSocket servSock = new ServerSocket(servPort);

        int recvMsgSize; // Size of received message
        byte[] receiveBuf = new byte[BUFSIZE]; // Receive buffer

        while (true) { // Run forever, accepting and servicing connections

            Socket clntSock = servSock.accept(); // Get client connection

            SocketAddress clientAddress = clntSock.getRemoteSocketAddress();

            System.out.println("Handling client at " + clientAddress);

            InputStream in = clntSock.getInputStream();
            OutputStream out = clntSock.getOutputStream();

            /* Receive until client closes connection, indicated by -1 return*/

            while ((recvMsgSize = in.read(receiveBuf)) != -1) {

                out.write(receiveBuf, 0, recvMsgSize);
            }
            clntSock.close(); // Close the socket. We are done with this client!
        }
        /* NOT REACHED */

    }
}

Demo2.

客户端从控制台输入字符串，发送到服务端

服务端受到客户端的字符串后，加上部分信息（echo字符串）返回到客户端

package zyb.org.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class Client {
    public static void main(String[] args) throws IOException {
        //客户端请求与本机在20006端口建立TCP连接 
        Socket client = new Socket("127.0.0.1", 20006);
        client.setSoTimeout(10000);
        //获取键盘输入 
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        //获取Socket的输出流，用来发送数据到服务端  
        PrintStream out = new PrintStream(client.getOutputStream());
        //获取Socket的输入流，用来接收从服务端发送过来的数据  
        BufferedReader buf =  new BufferedReader(new InputStreamReader(client.getInputStream()));
        boolean flag = true;
        while(flag){
            System.out.print("输入信息：");
            String str = input.readLine();
            //发送数据到服务端  
            out.println(str);
            if("bye".equals(str)){
                flag = false;
            }else{
                try{
                    //从服务器端接收数据有个时间限制（系统自设，也可以自己设置），超过了这个时间，便会抛出该异常
                    String echo = buf.readLine();
                    System.out.println(echo);
                }catch(SocketTimeoutException e){
                    System.out.println("Time out, No response");
                }
            }
        }
        input.close();
        if(client != null){
            //如果构造函数建立起了连接，则关闭套接字，如果没有建立起连接，自然不用关闭
            client.close();    //只关闭socket，其关联的输入输出流也会被关闭
        }
    }
}

package zyb.org.server;

import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws Exception{
        //服务端在20006端口监听客户端请求的TCP连接
        ServerSocket server = new ServerSocket(20006);
        Socket client = null;
        boolean f = true;
        while(f){
            //等待客户端的连接，如果没有获取连接
            client = server.accept();
            System.out.println("与客户端连接成功！");
            //为每个客户端连接开启一个线程
            new Thread(new ServerThread(client)).start();
        }
        server.close();
    }
}

package zyb.org.server;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

/**
 * 该类为多线程类，用于服务端
 */
public class ServerThread implements Runnable {

    private Socket client = null;
    public ServerThread(Socket client){
        this.client = client;
    }
    
    @Override
    public void run() {
        try{
            //获取Socket的输出流，用来向客户端发送数据
            PrintStream out = new PrintStream(client.getOutputStream());
            //获取Socket的输入流，用来接收从客户端发送过来的数据
            BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream()));
            boolean flag =true;
            while(flag){
                //接收从客户端发送过来的数据
                String str =  buf.readLine();
                if(str == null || "".equals(str)){
                    flag = false;
                }else{
                    if("bye".equals(str)){
                        flag = false;
                    }else{
                        //将接收到的字符串前面加上echo，发送到对应的客户端
                        out.println("echo:" + str);
                    }
                }
            }
            out.close();
            client.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

 

参考文章：

【Java TCP/IP Socket】TCP Socket（含代码）  http://blog.csdn.net/ns_code/article/details/14105457

《Java TCP/IP Socket 编程》