First, each client is also a client server do?
No. If this is the case, the device must be set to the server and client at the same time, but this can only realize the transmission of messages between two devices. If you want to implement multi-client, it will be very complicated.
Second, more than two devices how interactive data?
We need to agree on a rule as a sign of a complete transmission of information.
Process is a client -> server -> forwarded to the client
Thread the relationship between the three, client, server
Fourth, analog internet server by tcp server, data forwarding
server:
package net.qiujuer.lesson.sample.server;
import net.qiujuer.lesson.sample.server.handle.ClientHandler;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TCPServer implements ClientHandler.ClientHandlerCallback {
private final int port;
private ClientListener mListener;
private List<ClientHandler> clientHandlerList = new ArrayList<>();
private final ExecutorService forwardingThreadPollExecutor;
public TCPServer(int port) {
this.port = port;
this.forwardingThreadPollExecutor = Executors.newSingleThreadExecutor();
}
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();
}
synchronized (TCPServer.this) {
for (ClientHandler clientHandler : clientHandlerList) {
clientHandler.exit();
}
clientHandlerList.clear();
}
//停止线程池
forwardingThreadPollExecutor.shutdownNow();
}
public synchronized void broadcast(String str) {
for (ClientHandler clientHandler : clientHandlerList) {
clientHandler.send(str);
}
}
@Override
public synchronized void onSelfClosed(ClientHandler handler) {
clientHandlerList.remove(handler);
}
//onNewMessageArrived()方法在调用它的线程执行。比如连续给服务器发送了3条消息，按理说这里应该收到三条消息，然后把消息进行转发
//一旦在onNewMessageArrived()进行了阻塞，就会导致后面两条消息接收的延迟。所以，尽量不阻塞主干的线程。需要使用异步操作。
@Override
public void onNewMessageArrived(final ClientHandler handler,final String msg) {
//打印到屏幕
System.out.print("Received-"+handler.getClientInfo()+":"+msg);
//异步提交转发任务
forwardingThreadPollExecutor.execute(new Runnable() {
@Override
public void run() {
synchronized (TCPServer.this){
for(ClientHandler clientHandler:clientHandlerList){
if(clientHandler.equals(handler)){
//跳过自己
continue;
}
//对其它客户端发送消息
//这个发送操作其实也是在其它客户端对应的线程池中进行的，所以循环不会导致它的阻塞
clientHandler.send(msg);
}
}
}
});
}
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:" + server.getLocalPort());
}
@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,TCPServer.this);
// 读取数据并打印
clientHandler.readToPrint();
//添加同步处理
synchronized (TCPServer.this) {
clientHandlerList.add(clientHandler);
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("客户端连接异常：" + e.getMessage());
}
} while (!done);
System.out.println("服务器已关闭！");
}
void exit() {
done = true;
try {
server.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package net.qiujuer.lesson.sample.server.handle;
import net.qiujuer.library.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 ClientHandlerCallback clientHandlerCallback;
private final String clientInfo;
public ClientHandler(Socket socket, ClientHandlerCallback clientHandlerCallback) throws IOException {
this.socket = socket;
this.readHandler = new ClientReadHandler(socket.getInputStream());
this.writeHandler = new ClientWriteHandler(socket.getOutputStream());
this.clientHandlerCallback = clientHandlerCallback;
this.clientInfo = "A["+socket.getInetAddress().getHostAddress()+
"] P["+socket.getPort()+"]";
System.out.println("新客户端连接：" + clientInfo);
}
public String getClientInfo(){
return clientInfo;
}
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();
clientHandlerCallback.onSelfClosed(this);
}
public interface ClientHandlerCallback {
//自身关闭通知
void onSelfClosed(ClientHandler handler);
//收到消息时通知
void onNewMessageArrived(ClientHandler handler,String msg);
}
class ClientReadHandler extends Thread {
private boolean done = false;
private final InputStream inputStream;
ClientReadHandler(InputStream inputStream) {
this.inputStream = inputStream;
}
@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);
//onNewMessageArrived()方法在调用它的线程执行。比如连续给服务器发送了3条消息，按理说这里应该收到三条消息，然后把消息进行转发
//一旦在onNewMessageArrived()进行了阻塞，就会导致后面两条消息接收的延迟。所以，尽量不阻塞主干的线程。
clientHandlerCallback.onNewMessageArrived(ClientHandler.this,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();
}
void exit() {
done = true;
CloseUtils.close(printStream);
executorService.shutdownNow();
}
void send(String str) {
if(done) {
return;
}
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();
}
}
}
}
}
Client:
package net.qiujuer.lesson.sample.client;
import net.qiujuer.lesson.sample.client.bean.ServerInfo;
import net.qiujuer.library.clink.utils.CloseUtils;
import java.io.*;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
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) {
System.out.println("异常关闭");
}
// 释放资源
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;
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();
} catch (SocketTimeoutException e) {
continue;
}
if (str == null) {
System.out.println("连接已关闭，无法读取数据！");
break;
}
// 打印到屏幕
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);
}
}
}
operation result:
Open a server and three clients, from a client (port: 58288) to send a message, when the message server receives the information will be forwarded to both the server connected to the client two (port: 58289 ) and tris (port: 58290) on.
Also two client will be forwarded to a server and the server sends a message back to the server three.
When a message is sent from the server, a client, two, three simultaneously receive the message
