一个socket服务端长连接的编写需求

0 0

一个socket服务端长连接的编写需求5

现在正在写一个socket服务端，需求是：
1。客户只有一个，他的需求是当他发送一个报文到我的server端
2。我收到报文处理完后，不断开此连接一直等待，他也不会断开此连接。
3。客户端以后只用这一个连接想我发送消息。
请问这个服务端程序怎么写，我第一次写socket程序，还没入门，希望同学们帮我下。

问题补充：用java实现

企业应用 Socket

2013年10月24日 20:27

javaliuliu
2
0 0 4

nio

服务端：
public class NIOServer {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        int port = 8888;
        // 打开选择器
        Selector selector = Selector.open();
        // 打开服务器套接字通道
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 检索与此通道关联的服务器套接字
        ServerSocket serverSocket = ssc.socket();
        // 将 ServerSocket 绑定到特定地址（IP 地址和端口号）
        serverSocket.bind(new InetSocketAddress(port));
        System.out.println("server listen on port:" + port);

        // 调整通道的阻塞模式
        ssc.configureBlocking(false);
        // 向给定的选择器注册此通道，返回一个选择键。SelectionKey.OP_ACCEPT--用于套接字接受操作的操作集位
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // timeout:为正，则在等待某个通道准备就绪时最多阻塞 timeout 毫秒；如果为零，则无限期地阻塞；必须为非负数
            // int nKeys=selector.select(1000);或selector.select();
            int nKeys = selector.select(1000);
            if (nKeys == 0) {
                continue;
            }
            //System.out.println(nKeys);
            if (nKeys > 0) {

                for (SelectionKey key : selector.selectedKeys()) {

                    /*
                     * 测试此键的通道是否已准备好接受新的套接字连接-- 如果此键的通道不支持套接字接受操作，则此方法始终返回 false
                     */
                    if (key.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel sc = server.accept();
                        if (sc == null) {
                            continue;
                        }
                        sc.configureBlocking(false);
                        sc.register(selector, SelectionKey.OP_READ);
                    } else if (key.isReadable()) {
                        // 分配一个新的字节缓冲区
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        SocketChannel sc = (SocketChannel) key.channel();
                        int readBytes = 0;
                        String message = null;
                        try {
                            int ret;
                            try {
                                while ((ret = sc.read(buffer)) > 0) {
                                    readBytes += ret;
                                }
                            } catch (Exception e) {
                                sc.close();
                                readBytes = 0;
                                // ignore
                            } finally {
                                // 反转此缓冲区。首先对当前位置设置限制，然后将该位置设置为零
                                buffer.flip();
                            }

                            if (readBytes > 0) {
                                message = Charset.forName("UTF-8").decode(buffer).toString();
                                buffer = null;
                            }
                        } finally {
                            if (buffer != null) buffer.clear();
                        }

                        if (readBytes > 0) {
                            System.out.println("message from client:" + message);
                            if ("quit".equalsIgnoreCase(message.trim())) {
                                sc.close();
                                selector.close();
                                System.out.println("Server has been shutdown!");
                                System.exit(0);
                            }
                            String outMessage = "server response:" + message.toUpperCase();
                            sc.write(Charset.forName("UTF-8").encode(outMessage));
                        }else{
                            InetSocketAddress address1 = (InetSocketAddress)sc.socket().getRemoteSocketAddress();
                            System.out.print("IP地址："+address1.getAddress()+"端口："+address1.getPort());
                            System.out.println("远程强制断开！");
                        }

                    }
                }
                selector.selectedKeys().clear();
            }

        }
    }
}

客户端：
public class NIOClient {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // 连接端口
        int port = 8888;
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);

        // 指定连接地址及连接端口
        SocketAddress target = new InetSocketAddress("127.0.0.1", port);
        channel.connect(target);
        Selector selector = Selector.open();
        // 用于套接字连接操作的操作集位
        channel.register(selector, SelectionKey.OP_CONNECT);
        BufferedReader systemIn = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            if (channel.isConnected()) {
                String command = systemIn.readLine();
                channel.write(Charset.forName("UTF-8").encode(command));

                if (command == null || "quit".equalsIgnoreCase(command.trim())) {
                    systemIn.close();
                    channel.close();
                    selector.close();
                    System.out.println("Client quit !");
                    System.exit(0);
                }
            }
            int nKeys = selector.select();
            if (nKeys > 0) {
                for (SelectionKey key : selector.selectedKeys()) {
                    if (key.isConnectable()) {
                        SocketChannel sc = (SocketChannel) key.channel();
                        sc.configureBlocking(false);
                        sc.register(selector, SelectionKey.OP_READ);
                        sc.finishConnect();
                    } else if (key.isReadable()) {
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        SocketChannel sc = (SocketChannel) key.channel();
                        int readBytes = 0;
                        try {
                            int ret = 0;
                            try {
                                while ((ret = sc.read(buffer)) > 0) {
                                    readBytes += ret;
                                }
                            } finally {
                                buffer.flip();
                            }
                            if (readBytes > 0) {
                                System.out.println(Charset.forName("UTF-8").decode(buffer)
                                        .toString());
                                buffer = null;
                            }
                        } finally {
                            if (buffer != null) {
                                buffer.clear();
                            }
                        }
                    }
                }
                selector.selectedKeys().clear();
            }
        }
    }

}