Socket网络编程之数据发送与接收并行

数据发送与接收并行

1服务端代码：

package server;
 
import constants.TCPConstants;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Server {
    public static void main(String[]args) throws IOException {
        TCPServer tcpServer = new TCPServer(TCPConstants.PORT_SERVER);
        boolean isSucceed = tcpServer.start();
        if(!isSucceed){
            System.out.println("Start TCP server failed!");
            return;
        }
        UDPProvider.start(TCPConstants.PORT_SERVER);
 
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String str;
        do{
            str = bufferedReader.readLine();
            //将信息发送给所有客户端
            tcpServer.broadcast(str);
        }while (!"00bye00".equalsIgnoreCase(str));
 
        UDPProvider.stop();
        tcpServer.stop();
    }
}

package server;
 
import server.handle.ClientHandler;
 
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
 
public class TCPServer {
 
    private final int port;
    private ClientListener mListener;
    //客户端列表
    private List<ClientHandler> clientHandlerList = new ArrayList<>();
 
    public TCPServer(int port) {
        this.port = port;
    }
 
    public boolean start() {
        try {
            ClientListener listener = new ClientListener(port);
            mListener = listener;
            listener.start();
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
 
 
    public void stop() {
        if (mListener != null) {
            mListener.exit();
        }
        for (ClientHandler clientHandler : clientHandlerList) {
            clientHandler.exit();
        }
        clientHandlerList.clear();
    }
 
    public void broadcast(String str) {
        for (ClientHandler clientHandler : clientHandlerList) {
            clientHandler.send(str);
        }
    }
 
    private class ClientListener extends Thread {
        private ServerSocket server;
        private boolean done = false;
 
        private ClientListener(int port) throws IOException {
            server = new ServerSocket(port);
            System.out.println("服务器信息：" + server.getInetAddress() + " P: " + port);
        }
 
        @Override
        public void run() {
            super.run();
 
            System.out.println("服务器准备就绪~");
            //等待客户端连接
            do {
                //得到客户端
                Socket client;
                try {
                    client = server.accept();
                } catch (IOException e) {
                    continue;
                }
                try {
                    //客户端构建异步线程
                    ClientHandler clientHandler = new ClientHandler(client, new ClientHandler.CloseNotify() {
                        @Override
                        public void onSelfClosed(ClientHandler handler) {
                            clientHandlerList.remove(handler);
                        }
                    });
                    //读取数据数据并打印
                    clientHandler.readToPrint();
                    clientHandlerList.add(clientHandler);
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.print("客户端连接异常:"+ e.getMessage());
                }
            } while (!done);
 
            System.out.println("服务器已关闭! ");
        }
 
        void exit() {
            done = true;
            try {
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package server.handle;
 
import clink.net.qiu.clink.utils.CloseUtils;
 
import java.io.*;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
 * 客户端消息处理
 */
public class ClientHandler {
    private final Socket socket;
    private final ClientReadHandler readHandler;
    private final ClientWriteHandler writeHandler;
    private final CloseNotify closeNotify;
 
    public ClientHandler(Socket socket,CloseNotify closeNotify) throws IOException {
        this.socket = socket;
        this.closeNotify = closeNotify;
        this.readHandler = new ClientReadHandler(socket.getInputStream());
        this.writeHandler = new ClientWriteHandler(socket.getOutputStream());
        System.out.println("客户端已连接：" + socket.getInetAddress() +
                " P:" + socket.getPort());
    }
 
 
    public void exit() {
        readHandler.exit();
        writeHandler.exit();
        CloseUtils.close(socket);
        System.out.println("客户端已退出：" + socket.getInetAddress() +
                " P:" + socket.getPort());
    }
 
    public void send(String str) {
        writeHandler.send(str);
    }
 
    public void readToPrint() {
        readHandler.start();
    }
 
    private void exitBySelf() {
        exit();
        closeNotify.onSelfClosed(this);
    }
 
    public interface CloseNotify{
        void onSelfClosed(ClientHandler handler);
    }
 
    class ClientReadHandler extends Thread {
        private boolean done = false;
        private final InputStream inputStream;
 
        public ClientReadHandler(InputStream inputStream) {
            this.inputStream = inputStream;
            System.out.println("新客户端连接: " + socket.getInetAddress() +
                    " P:" + socket.getPort());
        }
 
        @Override
        public void run() {
            super.run();
            try {
                //得到输入流，用于接收数据
                BufferedReader socketInput = new BufferedReader(new InputStreamReader(inputStream));
 
                do {
                    //客户端拿到一条数据
                    String str = socketInput.readLine();
                    if (str == null) {
                        System.out.println("客户端已无法读取数据!");
                        //退出当前客户端
                        ClientHandler.this.exitBySelf();
                        break;
                    }
 
                    //打印到屏幕
                    System.out.println(str);
                } while (!done);
            } catch (Exception e) {
                if (!done) {
                    System.out.println("连接异常断开");
                    ClientHandler.this.exitBySelf();
                }
            } finally {
                //连接关闭
                CloseUtils.close(inputStream);
            }
        }
 
        void exit() {
            done = true;
            CloseUtils.close(inputStream);
        }
    }
 
 
    class ClientWriteHandler{
        private boolean done = false;
        private final PrintStream printStream;
        private final ExecutorService executorService;
 
        ClientWriteHandler(OutputStream outputStream){
            this.printStream = new PrintStream(outputStream);
            this.executorService = Executors.newSingleThreadExecutor();
        }
 
        public void send(String str) {
            executorService.execute(new WriteRunnable(str));
        }
 
        class WriteRunnable implements Runnable{
            private final String msg;
 
            WriteRunnable(String msg){
                this.msg = msg;
            }
 
            @Override
            public void run() {
                if(ClientWriteHandler.this.done){
                    return;
                }
                try {
                    ClientWriteHandler.this.printStream.println(msg);
                }catch (Exception e){
                    e.printStackTrace();
                    System.out.print("server send exception :"+e.getMessage());
                }
            }
        }
 
        public void exit(){
            System.out.println("close write!");
            done = true;
            CloseUtils.close(printStream);
            executorService.shutdownNow();
        }
    }
}

2.客户端代码：

package client;
 
import client.bean.ServerInfo;
 
import java.io.IOException;
 
public class Client {
    public static void main(String[] args){
        ServerInfo info = ClientSearcher.searchServer(10000);
        System.out.println("Server:"+info);
 
        if(info != null){
            try {
                TCPClient.linkWith(info);
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

package client;
 
import client.bean.ServerInfo;
import clink.net.qiu.clink.utils.CloseUtils;
 
import java.io.*;
import java.net.*;
 
public class TCPClient {
    public static void linkWith(ServerInfo info) throws IOException {
        Socket socket = new Socket();
        //超时时间
        socket.setSoTimeout(3000);
        //连接传输过来的地址，端口2000，超时时间3000ms
        socket.connect(new InetSocketAddress(Inet4Address.getByName(info.getAddress()), info.getPort()), 3000);
 
        System.out.println("已发起服务器连接，并进入后续流程～");
        System.out.println("客户端信息：" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
        System.out.println("服务器信息：" + socket.getInetAddress() + " P:" + socket.getPort());
 
        try {
            ReadHandler readHandler = new ReadHandler(socket.getInputStream());
            readHandler.start();
            //发送数据
            write(socket);
 
            //退出操作（读取退出）
            readHandler.exit();
        } catch (Exception e) {
 
        } finally {
            socket.close();
        }
 
        //释放资源
        socket.close();
        System.out.println("客户端已退出～");
    }
 
    private static void write(Socket client) throws IOException {
        //构建键盘输入流
        InputStream in = System.in;
        BufferedReader input = new BufferedReader(new InputStreamReader(in));
 
        //得到Socket输出流，并转换为打印流
        OutputStream outputStream = client.getOutputStream();
        PrintStream socketPrintStream = new PrintStream(outputStream);
 
        do {
            //键盘读取一行
            String str = input.readLine();
            //发送到服务器
            socketPrintStream.println(str);
 
            if ("00bye00".equalsIgnoreCase(str)) {
                break;
            }
        } while (true);
 
        //释放资源
        socketPrintStream.close();
    }
 
    static class ReadHandler extends Thread {
        private boolean done = false;
        private final InputStream inputStream;
 
        public ReadHandler(InputStream inputStream) {
            this.inputStream = inputStream;
        }
 
        @Override
        public void run() {
            super.run();
            try {
                //得到输入流，用于接收数据
                BufferedReader socketInput = new BufferedReader(new InputStreamReader(inputStream));
 
                do {
                    String str;
                    try {
                        //客户端拿到一条数据
                        str = socketInput.readLine();
                        if (str == null) {
                            System.out.println("连接已关闭，无法读取数据!");
                            break;
                        }
                    } catch (SocketTimeoutException e) {
                        continue;
                    }
                    //打印到屏幕
                    System.out.println(str);
                } while (!done);
            } catch (Exception e) {
                if (!done) {
                    System.out.println("连接异常断开:"+e.getMessage());
                }
            } finally {
                //连接关闭
                CloseUtils.close(inputStream);
            }
        }
 
        void exit() {
            done = true;
            CloseUtils.close(inputStream);
        }
    }
}