Java EE——网络编程套接字TCP

ServerSocket API

是专门用来创建TCP服务器的API

构造方法

构造方法	说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口

方法

方法	说明
Socket accept()	开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()	关闭此套接字

Socket API

即在服务器中使用，也在客户端中使用

构造方法

构造方法	说明
Socket(String host, int port)	创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

方法

方法	说明
InetAddress getInetAddress()	返回套接字所连接的IP地址和端口
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

TCP版本回显服务器/客户端

回显服务器

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpEchoServer {
    private ServerSocket listenSocket = null;//专门负责看有没有客户端连接，有了连接后，就把客户端相关信息给clientSocket

    public TcpEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        ExecutorService service = Executors.newCachedThreadPool();
        System.out.println("服务器启动！");
        while(true){
            //接收连接
            Socket clientSocket = listenSocket.accept();
            //每个客户端连接后都分配一个新的线程，以解决多客户端问题
//            Thread t = new Thread(() -> {
//                try {
//                    processConnection(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            t.start();
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d]客户端上线！",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        System.out.println();
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()){

            while (true){
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    System.out.printf("[%s:%d]客户端下线！",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    System.out.println();
                    break;
                }
                String request = scanner.next();
                String response = process(request);
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                printWriter.flush();//刷新缓冲区

                System.out.printf("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),clientSocket.getPort(),
                        request,response);
                System.out.println();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

回显客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        socket = new Socket(serverIp,serverPort);//和服务器建立连接
    }

    public void start(){
        Scanner scanner = new Scanner(System.in);
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            while(true){
                //从控制台读取数据，构造成请求
                System.out.print("-> ");
                String request = scanner.next();
                //发送请求给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();//刷新缓冲区
                //从服务器读取响应
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                //把响应显示到控制台上
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1",9090);
        tcpEchoClient.start();
    }
}

我们也可以通过继承实现和UDP一样的翻译服务器，在这里就不做演示了