我可以从io客户端发送数据(仅使用套接字而不是套接字通道),但是无法从nio服务器发送数据(使用套接字通道)。 问题是什么?

通过I / O流和字节缓冲区进行读/写的方式之间有区别吗?

public class Server {

    // this is equivalent to the server socket in the non nio world
    ServerSocketChannel serverSocketChannel;

    // this is the multiplexer which multiplexes the messages received from
    // different clients
    Selector selector;

    public Server() {
        try {

            // get a selector
            selector = Selector.open();

            // get a server socket channel
            serverSocketChannel = ServerSocketChannel.open();

            // we force the socket to be Non-blocking.
            // if it is set to "true" then this socket acts as a normal
            // (blocking) server socket
            serverSocketChannel.configureBlocking(false);

            // port and ip address where the server listens for connections
            InetSocketAddress add = new InetSocketAddress(
                InetAddress.getLocalHost(), 9999);

            // bind the server socket to the ip/port
            serverSocketChannel.socket().bind(add);

            // register the serverSocketChannel (for incoming connection events)
            // to the selector.
            // The "SelectionKey.OP_ACCEPT" parameter tells the selector that
            // this serverSocketChannel registers
            // itself for incoming (acceptable) connections
            SelectionKey key = serverSocketChannel.register(selector,
                SelectionKey.OP_ACCEPT);
            System.out.println("serverSocketChannel's registered key is : "
                + key.channel().toString());

            System.out.println();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.startListening();
    }

    private void startListening() {

        System.out.println("Server is listening on: "
            + serverSocketChannel.socket().getInetAddress()
                .getHostAddress() + ":"
            + serverSocketChannel.socket().getLocalPort());

        while (true) {
            try {

                // this line blocks until some events has occurred in the
                // underlying socket
                selector.select();

                // get the selected keys set
                Set selectedKeys = selector.selectedKeys();

                Iterator iterator = selectedKeys.iterator();

                while (iterator.hasNext()) {

                    SelectionKey key = (SelectionKey) iterator.next();

                    iterator.remove();

                    // a client has asked for a new connection
                    if (key.isAcceptable()) {
                        // only ServerSocketsChannels registered for OP_ACCEPT
                        // are excepted to receive an
                        // "acceptable" key

                        System.out.println("Key ready to perform accept() : "
                            + key.channel().toString());

                        // as usual the accept returns the plain socket towards
                        // the client
                        SocketChannel client = serverSocketChannel.accept();

                        // set the client socket to be non blocking
                        client.configureBlocking(false);

                        // register the client socket with the same selector to
                        // which we have registered the
                        // serverSocketChannel
                        client.register(selector, SelectionKey.OP_READ);
                        // client.register(selector, SelectionKey.OP_WRITE);
                        continue;
                    }

                    // the client has sent something to be read by this server
                    if (key.isReadable()) {

                        System.out.println("Key ready to perform read() : "
                            + key.channel().toString());

                        // get the underlying socket
                        SocketChannel client = (SocketChannel) key.channel();
                        ByteBuffer bb = ByteBuffer.allocate(10000);

                        // read the msg sent by the client
                        client.read(bb);

                        // display the message
                        bb.flip();
                        byte[] array = new byte[bb.limit()];
                        bb.get(array);
                        System.out.println(new String(array));

                        // send the message

                        ByteBuffer bb1 = ByteBuffer.allocate(10000);

                        String s = "server data";
                        byte[] array1 = new byte[bb1.limit()];
                        array1 = s.getBytes();
                        bb1.put(array1);
                        client.write(bb1);

                    }

                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    void write() {

    }


}

public class Client {
    static String IP = "192.168.123.105"; // server IP address
    public static void main(String[] args) throws UnknownHostException,
        IOException {
        // TODO Auto-generated method stub

        String msg;
        Socket socket = new Socket(IP, 9999);

        System.out.println("client: complete making socket");
        Scanner scan = new Scanner(System.in);
        System.out.println("client: input data to send");

        while (true) {
            // read
            System.out.print(">>>");
            msg = scan.nextLine();

            OutputStream out = socket.getOutputStream();
            DataOutputStream dou = new DataOutputStream(out);
            dou.writeUTF(msg);

            // write from server

            InputStream in = socket.getInputStream();
            DataInputStream din = new DataInputStream(in);
            String remsg = din.readUTF();
            System.out.println("client: data from server" + remsg);

            if (remsg.equalsIgnoreCase("END")) {
                System.out.println("SOCKET END");
                socket.close();
                break;

            }
        }
    }
}

#1楼 票数:-1

我解决了问题!

这是关于如何从客户端的输入流中读取的问题

我更改了部分客户代码

  InputStream in = socket.getInputStream();
        DataInputStream din = new DataInputStream(in);
        String remsg = din.readUTF();
        System.out.println("client: data from server" + remsg);

ByteBuffer bb1 = ByteBuffer.allocate(10000);
            byte[] array1 = new byte[bb1.limit()];
            InputStream in = socket.getInputStream();
            in.read(array1);
            String remsg=new String(array1);

并在服务器代码中添加了OP_WRITE / isWritable()这样

if (key.isReadable()) {

                    System.out.println("Key ready to perform read() : "
                            + key.channel().toString());

                    // get the underlying socket
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer bb = ByteBuffer.allocate(1024);

                    // read the msg sent by the client
                    client.read(bb);

                    // display the message
                    bb.flip();
                    byte[] array = new byte[bb.limit()];
                    bb.get(array);
                    System.out.println(new String(array));

                    client.register(selector, SelectionKey.OP_WRITE);


                    continue;
                }



 if(key.isWritable()){

                    SocketChannel client = (SocketChannel) key.channel();
                      ByteBuffer bb1 = ByteBuffer.allocate(10000);

                        String s = "server data";
                        byte[] array1 = new byte[bb1.limit()];
                        array1 = s.getBytes();
                        bb1.put(array1);
                        bb1.flip();
                        client.write(bb1);
                    }

  ask by Hyemi Min translate from so

未解决问题?本站智能推荐:

1回复

为什么我的NIO客户端到服务器的连接断开?

我目前有使用NIO Java库以非阻塞模式编写的台式机服务器。 您可以在此处找到完整的服务器项目。 我还创建了一个用于测试目的的非阻塞NIO客户端。 您可以在这里找到该项目。 最后,该服务器应该用于android即时消息传递应用程序。 我将客户端和服务器都基于发送“数据包”进行通信的想
2回复

Java Nio的简单客户端-服务器示例

请您给我看一个使用java nio进行通信的客户端和服务器的本地主机的小例子吗? 我需要了解它如何工作。 例如1)客户端需要连接,客户端连接客户端发送“你好,我是客户端”。 2)服务器接受,服务器从客户端接收消息,服务器响应“你好,我是服务器” 3)客户端发送“你好服务器” 4)服务器发送
1回复

JAVA NIO服务器-不接收客户端空白消息/部分消息

我使用带有服务器套接字通道和套接字通道的NIO包构建了服务器和客户端。 基本设置有效。 但是,当我尝试使用执行程序服务在单独的线程中移动处理每个连接的代码时,我开始收到一些奇怪的错误,其中我得到了部分消息或有时是空白消息。 这是我的代码,我将选择密钥传递给具有执行程序服务的线程
1回复

C ++客户端连接到非阻塞Java NIO服务器

我想知道如何在可能的情况下执行在C ++中创建/模拟Java服务器套接字的任务? 我是C ++的新手,但我精通Java。 我的服务器(用Java编写)需要从所有两个Java / C ++客户端接收数据(使用JSON字符串传输数据),但是我不确定如何在C ++中与NIO服务器建立连接。
1回复

配置服务器使用netty 4具有20,000个客户端的连接

我正在使用netty 4.0编写TCP服务器,这可能会同时加载20k客户端。 但是我的服务器无法承受许多这样的联系。 这是我的代码。 我应该像这样对3处理程序EventExecutorGroup使用3吗? 我用nthread(= 1000)表示workerGroup是否足以进行20
1回复

java-nio:从与选择不同的线程发送

我经常听到,有一个线程负责与客户端的所有通信,这被认为是“好的设计”。 但是,现在有多个线程可以与其他服务器通信以处理客户端请求。 当前设计将排队响应以发送给选择线程。 然后选择线程使响应出队,并将其发送到适当的客户端。 这太愚蠢了,imo。 我有30个线程准备好将响应发送
1回复

Netty-阻止操作在完成之前不接受客户端请求

[问题]:我有一个Netty Server,它将通过TCP侦听客户端,并处理请求并发回响应。 问题在于处理部分需要时间,因为它需要应用程序用户的验证。 客户端一个接一个地发送多个请求,并且服务器似乎直到上一个请求完成才接受该客户端的请求。 我已经复制了一个场景,客户端将一个接一个地发送
1回复

NIO选择器线程,按预期处理通道,但如何确保通道在使用后正确关闭?

所以我在ServerRunnable类中有以下代码: 我的acceptConnection()方法接受一个连接,并向它添加一个CommunicationState对象(一个状态机),它包含ByteBuffer ,当前通道状态,客户端当前在通信过程中等等... 此服务器在进程中间切换通