最近有點閒，用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
        }
    }
}
 

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());
    }
}
 

介面如下：