TCP的socket连接

package newtest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

public class TcpServer
{
    //用于检测所有Channel状态的selector
    private Selector selector = null;
    //定义编码格式
    private Charset charset = Charset.forName("UTF-8");

    public void init()throws IOException
    {
        selector = Selector.open();
        //通过open方法来打开一个未绑定的ServerSocketChannel实例
        ServerSocketChannel server  = ServerSocketChannel.open();
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1", 8899);
        //将该ServerSocketChannel绑定到指定IP地址
        server.socket().bind(isa);
        //设置ServerSocket以非阻塞方式工作
        server.configureBlocking(false);
        //将Server注册到指定Selector对象
        server.register(selector, SelectionKey.OP_ACCEPT);

        while(selector.select() > 0)
        {
            //依次处理Selector上的每个已选择的SelectionKey
            for(SelectionKey sk : selector.selectedKeys())
            {
                //从selector上的已选择Key集中删除正在处理的SelectionKey
                selector.selectedKeys().remove(sk);
                //如果sk对应的通道包含客户端的连接请求
                if(sk.isAcceptable())
                {
                    //调用accept方法接受连接，产生服务器端对应的SocketChannel
                    SocketChannel sc = server.accept();
                    //设置非阻塞方式工作
                    sc.configureBlocking(false);
                    //将该SocketChnnel也注册到selector
                    sc.register(selector, SelectionKey.OP_READ);
                    //将sk对应的Channel设置成准备接受其它请求
                    sk.interestOps(SelectionKey.OP_ACCEPT);
                }
                //如果sk对应的通道有数据需要读取
                if(sk.isReadable())
                {
                    //获取该SelectionKey对应的Channel,该Channnel中有可读的数据
                    SocketChannel sc = (SocketChannel)sk.channel();
                    //定义准备执行读取数据的ByteBuffer
                    ByteBuffer buff = ByteBuffer.allocate(1024);
                    String content =  "";
                    //开始读数据
                    try
                    {
                        while(sc.read(buff) > 0)
                        {
                            buff.flip();
                            content += charset.decode(buff);
                        }
                        //打印从该sk对应的Channel里读到的数据
                        System.out.println("消息：" + content);
                        //将sk对应的Channel设置成准备下一次读取
                        sk.interestOps(SelectionKey.OP_READ);
                    }
                    //如果捕捉到该sk对应的Channel出现了异常，即表明该Channel对应的Client出现了问题
                    //所以从Selector中取消sk的注册
                    catch(IOException ex)
                    {
                        //从Selector中删除指定的SelectionKey
                        sk.cancel();
                        if(sk.channel() != null)
                        {
                            sk.channel().close();
                        }
                    }
//                    throw new IOException();
                    //如果content的长度大于0，即聊天信息不为空
                    if(content.length() > 0)
                    {
                        //遍历该selector里注册的所有selectionKey
                        for(SelectionKey key : selector.keys())
                        {
                            //获取该channel是SocketChannel对象
                            Channel targetChannel = key.channel();
                            if(targetChannel instanceof SocketChannel)
                            {
                                //将读到的内容写入该Channel中
                                SocketChannel dest = (SocketChannel)targetChannel;
                                dest.write(charset.encode(content));
                            }
                        }
                    }
                }
            }
        }
    }

    public static void main(String[] args)throws IOException
    {
        System.out.println("===========TCP的server端启动=============");
        new TcpServer().init();
    }
}

package com.springboot.springbootswagger.client;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class TcpClient {
    // initialize socket and input output streams
    private Socket socket            = null;
    private DataInputStream  input   = null;
    private DataOutputStream out     = null;

    // constructor to put ip address and port
    public TcpClient(String address, int port)
    {
        // establish a connection
        try
        {
            socket = new Socket(address, port);
            System.out.println("Connected");

            // takes input from terminal
            input  = new DataInputStream(System.in);


            out    = new DataOutputStream(socket.getOutputStream());
        }
        catch(UnknownHostException u)
        {
            System.out.println(u.toString());
        }
        catch(IOException i)
        {
            System.out.println(i);
        }

        // 待读入的String
        String line = "";

        // 一直读到Over字符停止
        while (!line.equals("Over"))
        {
            try
            {
                line = input.readLine();
                out.writeUTF(line);
            }
            catch(IOException i)
            {
                System.out.println(i);
            }
        }

        // 关闭连接
        try
        {
            input.close();
            out.close();
            socket.close();
        }
        catch(IOException i)
        {
            System.out.println(i);
        }
    }

    public static void main(String args[])
    {
        TcpClient client = new TcpClient("127.0.0.1", 8899);
    }
}