Netty实现带UI客户端服务器聊天功能

最近有点闲，用Netty这个异步框架写了个聊天功能，也算是对Java语言的一个回顾：

      现有的例子总是使用回调去处理读写，但有时候我们确需要接受来自外界的输入，比如UI界面的消息输入，此时我们就需要提取Channel或者ChannelHandlerContext来进行消息的传输。

      Client端的代码比较简单，提取Connect后的Channel直接进行write就可以写入消息：

public class NettyClient {

private String clientName = "beyondwu";
public static final int BUFFER_SIZE = 1024;
public static final int HISTORY_LIST_SIZE = 30;
private Bootstrap bootstrap;
private ChannelPipeline chanPipeline;
private Channel socketChannel;

private ClientMessageHandler msgHandler;
private List<String> historyMessage;
private List<ClientObserver> observerList;

public NettyClient() {
historyMessage = new ArrayList<String>();
observerList = new ArrayList<ClientObserver>();
}

public void clientInit() {
EventLoopGroup group;
// Configure the client.
group = new NioEventLoopGroup();
msgHandler = new ClientMessageHandler(this);
try {
bootstrap = new Bootstrap();
// msgHandler = new ClientMessageHandler();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
chanPipeline = socketChannel.pipeline();
chanPipeline.addLast(msgHandler);
}
});
// socketChannel = bootstrap.connect(serverIP, serverPort).sync().channel();
} catch (Exception e1) {
e1.printStackTrace();
}

}

public String getMessages() {
String messages;
Iterator<String> iter = historyMessage.iterator();
messages = "";
while (iter.hasNext()) {
messages += iter.next();
messages += "\r\n";
}
return messages;
}

public int connServer(String IP, Integer port) {
// Start the client.
ChannelFuture chanFuture;
try {
chanFuture = bootstrap.connect(IP, port).sync();
socketChannel = chanFuture.channel();
// Wait until the connection is closed.
System.out.println("connect");
} catch (InterruptedException e) {
e.printStackTrace();
}
return 1;
}

public void sendMsg(String msg) {
String newMessage;
//Send to Server
ByteBuf sendMsg = Unpooled.buffer(BUFFER_SIZE);
sendMsg.writeBytes(msg.getBytes());
System.out.println("Going to Send: " + msg);
socketChannel.writeAndFlush(sendMsg);
newMessage = clientName + ": " + msg;
updateMsg(newMessage);
}

public void updateMsg(String msg) {
if (historyMessage.size() > HISTORY_LIST_SIZE)
historyMessage.remove(0);
historyMessage.add(msg);
notifyObserver();
}

public void register(ClientObserver observer) {
observerList.add(observer);
}

public void notifyObserver() {
Iterator<ClientObserver> iter = observerList.iterator();
while (iter.hasNext()) {
iter.next().update();//获得各Observer
}
}
}     对于服务器端，由于需要对连接进行监听，所以特定开了两个线程，一个线程负责连接，一个负责数据的读写，这样保证消息不会阻塞。另外采用了BlockingQueue进行消息的阻塞读取，这样等待来自UI的数据传输。

class BindThread extends Thread {
NettyServer ntyServer;

public BindThread(NettyServer server) {
this.ntyServer = server;
}

public void run() {
try {
ntyServer.serverInit();
} catch (SSLException e) {
e.printStackTrace();
} catch (CertificateException e) {
e.printStackTrace();
}
}
}

public class MessageWritenThread implements Runnable, ServerObserver {
ServerUI frontServer;
NettyServer nettyServer;

public MessageWritenThread(ServerUI server) {
frontServer = server;
nettyServer = new NettyServer();
nettyServer.registerObserver(this);
new BindThread(nettyServer).start();
//new Thread(this).start();
}

@Override
public void run() {
//nettyServer.serverInit();
while (true) {
String sendMsg = "";
try {
System.out.println("now send msg: " + sendMsg);
sendMsg = frontServer.getSendBuffer().take();
System.out.println("after now send msg: " + sendMsg);
nettyServer.sendMsg(sendMsg);
} catch (InterruptedException e) {
e.printStackTrace();
}
//nettyServer.(sendMsg);
}
}

@Override
public void update() {//can delegate
frontServer.getContentArea().setText(nettyServer.getMessages());
}
}

界面如下：



有些细节就没有更多的时间去考虑了，主要为了练习其中的部分api的使用。更多代码请访问我的github：https://github.com/wcwu/NettyChat