數據發送與接收並行
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);
}
}
}