Socket的几种实现

最新推荐文章于 2024-05-05 15:49:43 发布
最新推荐文章于 2024-05-05 15:49:43 发布
阅读量2.3k 收藏 38
点赞数 2
分类专栏： 笔记 文章标签： Socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zheng_junming/article/details/79644647
版权

基于TCP协议的网络编程

TCP/IP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket，从而在通信的两端之间形成网络虚拟链路。一旦建立了虚拟的网络链路，两端的成员就可以通过虚拟链路进行通信。Java是对基于TCP协议的网络通信提供了良好的封装，Java使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。

使用ServerSocket创建TCP服务器端

​ Java中能接收其他通信实体连接请求的类是ServerSocket，ServerSocket对象用于监听来自客户端Socket连接，如果没有连接，它将一直处于等待状态。

​ 接收客户端Socket的请求时，服务器端也对应产生一个Socket：Socket socket = serverSocket.accept();

使用Socket进行通信

创建连接到主机、1205端口的Socket：Socket socket = new Socket("127.0.0.1", 1205);

Socket提供了两个方法获取输入流和输出流

  1. InputStream getInputStream()：返回该Socket对象对应的输入流，让程序通过该输入流从Socket中取出数据。
  2. OutputStream getOutputStream()：返回该Socket对象对应的输出流，让程序通过该输出流向Socket中输出数据。

传统BIO实现的Socket通信

服务器端

/**
 * @author 小铭
 * Description: BIO实现Socket通信服务器端
 */
public class Server {
    public static void main(String[] args) throws IOException {
        // 用于监听1205端口的Socket连接请求
        ServerSocket serverSocket = new ServerSocket(1205);
        // 进行端口监听
        Socket socket = serverSocket.accept();
        // 从Socket中读取信息
        InputStreamReader inputStreamReader = new InputStreamReader(socket.getInputStream());
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String line;
		
        PrintStream printStream = new PrintStream(socket.getOutputStream(), true);
        while (true) {
            line = bufferedReader.readLine();
            if (line == null) {
                break;
            }
            System.out.println("接收到客户端的信息：" + line);
            // 向Socket中写入信息
            printStream.println("已接收到客户端的信息");
        }
        // 关闭资源
        printStream.flush();
        printStream.close();
        bufferedReader.close();
        inputStreamReader.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

/**
 * @author 小铭
 * Description: BIO实现Socket通信客户端
 */
public class Client {
    public static void main(String[] args) throws IOException {
        // 服务器ip和地址
        Socket socket = new Socket("127.0.0.1", 1205);
        // 向Socket写入信息，即发信息发至服务器
        PrintStream printStream = new PrintStream(socket.getOutputStream());
        printStream.println("我是客户端");
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        System.out.println("收到服务器的数据：" + bufferedReader.readLine());
        printStream.close();
        bufferedReader.close();
        socket.close();
    }
}

传统BIO实现的Socke通信最大的问题就是一个客户端接入，服务器就为它分配一条线程，降低了系统的性能，所以有了伪异步IO

伪异步IO实现Socket通信

维护了一个线程池，线程池的资源占用是可控的，可以支持客户端并发访问。

服务器端启动类

public class TimeServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(1205);
            Socket socket;
            // 创建一个线程池
            TimeServerHandlerExecutePool pool = new TimeServerHandlerExecutePool(50, 10000);
            while (true) {
                socket = serverSocket.accept();
                pool.execute(new TimeServerHandler(socket));
            }
        } finally {
            if (serverSocket != null) {
                System.out.println("The time server close");
                serverSocket.close();
            }
        }
    }
}

线程池

public class TimeServerHandlerExecutePool {
    private ExecutorService executorService;

    TimeServerHandlerExecutePool(int maxPoolSize, int queueSize) {
        executorService = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), maxPoolSize, 120L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(queueSize));
    }

    public void execute(Runnable task) {
        executorService.execute(task);
    }
}

服务器端业务逻辑

public class TimeServerHandler implements Runnable {
    private Socket socket;

    TimeServerHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        BufferedReader bufferedReader = null;
        PrintWriter printWriter = null;

        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            printWriter = new PrintWriter(this.socket.getOutputStream());
            String currentTime;
            String body;
            while (true) {
                body = bufferedReader.readLine();
                if (body == null) {
                    break;
                }
                System.out.println("The time server receive order: " + body);
                currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAO ORDER";
                printWriter.println(currentTime);
            }
        } catch (IOException e) {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
            if (printWriter != null) {
                printWriter.close();
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }
}

客户端

public class TimeClient {
    public static void main(String[] args) {
        int port = 1205;

        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }

        Socket socket = null;
        BufferedReader bufferedReader = null;
        PrintWriter printWriter = null;

        try {
            socket = new Socket("127.0.0.1", port);
            printWriter = new PrintWriter(socket.getOutputStream(), true);
            bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            printWriter.println("QUERY TIME ORDER");
            System.out.println("Send succeed");
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println("Now is : " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (printWriter != null) {
                printWriter.close();
            }

            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }
}

NIO实现Socket通信

NIO的知识可以直接看之前的笔记。

服务器端启动类

/**
 * @author 小铭
 * Date: 2018/3/19
 * Description: <p>NIO实现Socket服务器端</p>
 */
public class TimeServer {
    public static void main(String[] args) {
        MultiplexerTimeServer timeServer = new MultiplexerTimeServer(1205);
        new Thread(timeServer, "NIO-MultiplexerTimeServer-001").start();
    }
}

服务器端业务逻辑

/**
 * @author 小铭
 * Date: 2018/3/19
 * Description: <p>NIO实现Socket通信服务器端业务逻辑</p>
 */
public class MultiplexerTimeServer implements Runnable {

    private Selector selector;

    private volatile boolean stop;

    MultiplexerTimeServer(int port) {
        try {
            // 创建Selector
            selector = Selector.open();
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 设为非阻塞
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.socket().bind(new InetSocketAddress(port), 1024);
            // 设置监听
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    @Override
    public void run() {
        while (!stop) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                SelectionKey key;
                while (iterator.hasNext()) {
                    key = iterator.next();
                    iterator.remove();
                    try {
                        handleInput(key);
                    } catch (Exception e) {
                        if (key != null) {
                            key.cancel();
                            if (key.channel() != null) {
                                key.channel().close();
                            }
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (selector != null) {
            try {
                selector.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void handleInput(SelectionKey key) throws IOException {
        if (key.isValid()) {
            if (key.isAcceptable()) {
                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                SocketChannel socketChannel = serverSocketChannel.accept();
                socketChannel.configureBlocking(false);
                socketChannel.register(selector, SelectionKey.OP_READ);
            }
            if (key.isReadable()) {
                // 读取数据
                SocketChannel socketChannel = (SocketChannel) key.channel();
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                int readBytes = socketChannel.read(byteBuffer);
                if (readBytes > 0) {
                    byteBuffer.flip();
                    byte[] bytes = new byte[byteBuffer.remaining()];
                    byteBuffer.get(bytes);
                    String body = new String(bytes, "UTF-8");
                    System.out.println("The time server receive order: " + body);
                    String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
                    doWrite(socketChannel, currentTime);
                } else if (readBytes < 0) {
                    key.cancel();
                    socketChannel.close();
                }
            }
        }
    }

    private void doWrite(SocketChannel socketChannel, String currentTime) throws IOException {
        if (currentTime != null && currentTime.trim().length() > 0) {
            byte[] bytes = currentTime.getBytes();
            ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
            buffer.put(bytes);
            buffer.flip();
            socketChannel.write(buffer);
        }
    }
}

客户端启动类

/**
 * @author 小铭
 * Date: 2018/3/19
 * Description: <p>NIO实现Socket通信客户端</p>
 */
public class TimeClient {
    public static void main(String[] args) {
        new Thread(new TimeClientHandle("127.0.0.1", 1205), "TimeClient-001").start();
    }
}

客户端业务逻辑

/**
 * @author 小铭
 * Date: 2018/3/19
 * Description: <p>NIO实现Socket客户端业务逻辑</p>
 */
public class TimeClientHandle implements Runnable {

    private String host;
    private int port;
    private Selector selector;
    private SocketChannel socketChannel;
    private volatile boolean stop;

    TimeClientHandle(String host, int port) {
        this.host = host;
        this.port = port;
        try {
            selector = Selector.open();
            socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    @Override
    public void run() {
        try {
            doConnect();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
        while (!stop) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                SelectionKey key;
                while (iterator.hasNext()) {
                    key = iterator.next();
                    iterator.remove();
                    try {
                        handleInput(key);
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();
                        if (key.channel() != null) {
                            key.channel().close();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }

    private void handleInput(SelectionKey key) throws IOException {
        if (key.isValid()) {
            SocketChannel socketChannel = (SocketChannel) key.channel();
            if (key.isConnectable()) {
                if (socketChannel.finishConnect()) {
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    doWrite(socketChannel);
                } else {
                    System.exit(1);
                }
            }
            if (key.isReadable()) {
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                int readBytes = socketChannel.read(buffer);
                if (readBytes > 0) {
                    buffer.flip();
                    byte[] bytes = new byte[buffer.remaining()];
                    buffer.get(bytes);
                    String body = new String(bytes, "UTF-8");
                    System.out.println("Now is : " + body);
                    this.stop = true;
                } else if (readBytes < 0) {
                    key.cancel();
                    socketChannel.close();
                }
            }
        }
    }

    private void doConnect() throws IOException {
        if (socketChannel.connect(new InetSocketAddress(host, port))) {
            socketChannel.register(selector, SelectionKey.OP_READ);
            doWrite(socketChannel);
        } else {
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
        }
    }

    private void doWrite(SocketChannel socketChannel) throws IOException{
        byte[] req = "QUERY TIME ORDER".getBytes();
        ByteBuffer buffer = ByteBuffer.allocate(req.length);
        buffer.put(req);
        buffer.flip();
        socketChannel.write(buffer);
        if (!buffer.hasRemaining()) {
            System.out.println("Send order 2 server succeed.");
        }
    }
}

AIO实现Socket通信

服务器端启动类

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>AIO实现Socket通信服务器端启动类</p>
 */
public class TimeServer {
    public static void main(String[] args) {
        AsyncTimeServerHandler timeServerHandler = new AsyncTimeServerHandler(1205);
        new Thread(timeServerHandler, "AIO-AsyncTimeServerHandler-001").start();
    }
}

服务器端业务逻辑

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>AIO实现Socke通信服务器端业务逻辑</p>
 */
public class AsyncTimeServerHandler implements Runnable {
    CountDownLatch latch;
    AsynchronousServerSocketChannel serverSocketChannel;

    AsyncTimeServerHandler(int port) {
        try {
            serverSocketChannel = AsynchronousServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(port));
            System.out.println("The time server is start in port: " + port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        latch = new CountDownLatch(1);
        doAccept();
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void doAccept() {
        serverSocketChannel.accept(this, new AcceptCompletionHandler());
    }
}

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>AIO实现Socke通信服务器端业务逻辑</p>
 */
public class AcceptCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, AsyncTimeServerHandler> {

    @Override
    public void completed(AsynchronousSocketChannel result, AsyncTimeServerHandler attachment) {
        attachment.serverSocketChannel.accept(attachment, this);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        result.read(buffer, buffer, new ReadCompletionHandler(result));
    }

    @Override
    public void failed(Throwable exc, AsyncTimeServerHandler attachment) {
        exc.printStackTrace();
        attachment.latch.countDown();
    }
}

/**
 * @author 小铭
 * Date: 2018/3/19
 * Description: <p>AIO实现Socke通信服务器端业务逻辑</p>
 */
public class ReadCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {

    private AsynchronousSocketChannel channel;

    ReadCompletionHandler(AsynchronousSocketChannel channel) {
        if (this.channel == null) {
            this.channel = channel;
        }
    }

    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        attachment.flip();
        byte[] body = new byte[attachment.remaining()];
        attachment.get(body);
        try {
            String req = new String(body, "UTF-8");
            System.out.println("The time server receive order : " + req);
            String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(req) ?
                    new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
            doWrite(currentTime);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    private void doWrite(String currentTime) {
        if (currentTime != null && currentTime.trim().length() > 0) {
            byte[] bytes = currentTime.getBytes();
            ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
            buffer.put(bytes);
            buffer.flip();
            channel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {

                @Override
                public void completed(Integer result, ByteBuffer attachment) {
                    if (buffer.hasRemaining()) {
                        channel.write(buffer, buffer, this);
                    }
                }

                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    try {
                        channel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        try {
            this.channel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端启动类

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>AIO实现Socket通信客户端启动类</p>
 */
public class TimeClient {
    public static void main(String[] args) {
        new Thread(new AsyncTimeClientHandler("127.0.0.1", 1205), "AIO-AsyncTimeClientHanler-001").start();
    }
}

客户端业务逻辑

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>AIO实现Socke通信客户端业务逻辑</p>
 */
public class AsyncTimeClientHandler implements CompletionHandler<Void, AsyncTimeClientHandler>, Runnable {

    private AsynchronousSocketChannel socketChannel;
    private String host;
    private int port;
    private CountDownLatch latch;

    AsyncTimeClientHandler(String host, int port) {
        this.host = host;
        this.port = port;
        try {
            socketChannel = AsynchronousSocketChannel.open();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        latch = new CountDownLatch(1);
        socketChannel.connect(new InetSocketAddress(host, port), this, this);
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void completed(Void result, AsyncTimeClientHandler attachment) {
        byte[] req = "QUERY TIME ORDER".getBytes();
        ByteBuffer buffer = ByteBuffer.allocate(req.length);
        buffer.put(req);
        buffer.flip();
        socketChannel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (buffer.hasRemaining()) {
                    socketChannel.write(buffer, buffer, this);
                } else {
                    ByteBuffer readBuffer = ByteBuffer.allocate(1204);
                    socketChannel.read(readBuffer, readBuffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            attachment.flip();
                            byte[] bytes = new byte[attachment.remaining()];
                            attachment.get(bytes);
                            String body;
                            try {
                                body = new String(bytes, "UTF-8");
                                System.out.println("Now is : " + body);
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            } finally {
                                latch.countDown();
                            }
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            try {
                                socketChannel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            } finally {
                                latch.countDown();
                            }
                        }
                    });
                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                try {
                    socketChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }
        });
    }

    @Override
    public void failed(Throwable exc, AsyncTimeClientHandler attachment) {
        exc.printStackTrace();
        try {
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            latch.countDown();
        }
    }
}

Netty实现Socket通信

Netty是一个强大的NIO框架

服务器端配置启动类

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>使用Netty进行Socket通信服务器端</p>
 */
public class TimeServer {
    private void  bind(int port) throws Exception {
        // 配置服务器端的NIO线程组
        // 用于接受客户端的连接
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // 用户进行SocketChannel的网络读写
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) {
                            socketChannel.pipeline().addLast(new TimeServerHandler());
                        }
                    });
            // 绑定端口，同步等待成功
            ChannelFuture future = bootstrap.bind(port).sync();

            // 等待服务器端监听端口关闭
            future.channel().closeFuture().sync();
        } finally {
            // 释放线程组资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new TimeServer().bind(1205);
    }
}

服务器端业务逻辑

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>Netty实现Socket通信服务器端业务逻辑</p>
 * <p>以下的ChannelInboundHandlerAdapter是netty4下的类，如果使用netty5（已被舍弃迭代）需要继承ChannelHandlerAdapter，代码内容不变。</p>
 */
public class TimeServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("the time server receive order : " + body);
        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ?
                new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

客户端配置启动类

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>Netty实现Socket通信客户端</p>
 */
public class TimeClient {
    private void connect(int port, String host) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) {
                            socketChannel.pipeline().addLast(new TimeClientHandler());
                        }
                    });
            ChannelFuture future = bootstrap.connect(host, port).sync();
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new TimeClient().connect(1205, "127.0.0.1");
    }
}

客户端业务逻辑

/**
 * @author 小铭
 * Date: 2018/3/20
 * Description: <p>Netty实现Socket通信客户端业务逻辑</p>
 */
public class TimeClientHandler extends ChannelInboundHandlerAdapter {

    private static final Logger LOGGER = Logger.getLogger(TimeClientHandler.class.getName());
    private final ByteBuf buf;

    TimeClientHandler() {
        byte[] req = "QUERY TIME ORDER".getBytes();
        buf = Unpooled.buffer(req.length);
        buf.writeBytes(req);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.writeAndFlush(buf);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        try {
            String body = new String(req, "UTF-8");
            System.out.println("Now is : " + body);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        LOGGER.warning("Unexpected exception from downstream : " + cause.getMessage());
        ctx.close();
    }
}

参考书籍：Netty权威指南。

ming-world
关注
  • 2
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
三种SOCKET通信方式
06-08
三种不同的方法进行端对端通信,主要有SOCKET, TCP,UDP通信原理
socket简易聊天代码实现
01-08
Socket提供了一种在不同计算机间传输数据的机制，它允许程序通过网络发送和接收数据。本示例将详细介绍如何使用Python的socket库来实现一个简单的TCP聊天应用，包括服务端（tcp_server.py）和客户端（tcp_client.py...
一、Socket通信
最新发布
一只小鲤鱼~的博客
05-05 1201
Socket（套接字）是操作系统中I/O系统的延伸部分，它可以使进程和机器之间的通信成为可能。Socket实际上是一个通信端点，它包含了一个 IP 地址和一个端口号。IP 地址标识了主机，而端口号标识了主机上的进程。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。
socket的实现
weixin_35749440的博客
01-09 160
好的。 Socket 是一种用于进行网络通信的技术，它允许程序通过网络发送数据或者从网络接收数据。 Socket 的实现主要分为两个部分：服务端和客户端。 服务端程序运行在一台计算机上，等待客户端的连接。当客户端连接到服务端后，服务端会为客户端开辟一个 socket，并通过该 socket 与客户端进行通信。 客户端程序运行在另一台计算机上，向服务端发起连接。当连接建立后，客户端也会为服务端开辟一...
socket实现
runshui27的博客
06-19 181
https://blog.csdn.net/qq_30866297/article/details/51290769
socket原理及实现
qq_34214088的博客
03-24 1112
本文摘抄自：https://blog.csdn.net/pashanhu6402/article/details/96428887 https://blog.csdn.net/liuyueyue0921/article/details/47830517 https://blog.csdn.net/weixin_38534337/article/details/84316251 1、什么是TCP/IP、UDP？ TCP/IP（Transmission Control Protocol/Internet Pro
ios socket 编程的几种方式
08-21
在iOS开发中，Socket编程是实现设备间网络通信的基础，它允许应用程序通过网络发送和接收数据。本示例代码库“iOSSnippet-master”提供了使用不同iOS Socket API进行编程的方法。以下是对这些方法的详细说明： 1. *...
socket编程使用的几种类型实现
05-12
本篇文章将详细讨论在标题和描述中提及的几种Socket编程实现方式，并结合`MyServer`这个压缩包文件中的示例，深入理解它们的工作原理和应用场景。 1. **Select模型** Select函数是最早的多路复用I/O机制，它允许...
android socket聊天室功能实现
08-30
在Android应用开发中，Socket通信是一种常见的网络编程技术，它允许设备之间进行双向通信，尤其适合需要实时数据交换的场景，如聊天室功能。本文将详细介绍如何在Android中使用Socket实现聊天室功能。 首先，我们...
PHP实现Socket服务器的代码
10-30
PHP作为一种动态、灵活的脚本语言，同样支持Socket通信，可以用于创建服务器端应用程序。 首先，我们需要了解几个关键的函数： 1. `socket_create`: 这个函数用于创建一个新的Socket，参数分别是地址族（AF_INET...
使用socket的3种方式通信
04-27
现在在写一个类似qq的即时通讯工具，使用到socket，所以自己归类整理一下，如果需要用socket的资料，这个对你绝对有帮助
Socket通信的实现
lxy1740的博客
03-02 397
使用Socket通信需要在AndroidManifest中声明以下权限： <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> 其次是不能在主线程中访问...
Android开发入门——Socket编程
hare_Lee的专栏
10-27 558
http://www.linuxidc.com/Linux/2011-03/33600.htm  基于2410 LCD 驱动  http://www.linuxidc.com/Linux/2010-02/24667p3.htm  makefile 编写 1、 Socket通信模型如下：     应用程序通过套接字可以进行通信，可以使用udp协议或者使用tcp协议,当客户端和服务器
简析socket的实现
顶嵌专栏
04-22 420
先介绍一下Socket的来源。Socket本来是加利福尼亚大学伯克利分校为BSD操作系统（UNIX的一种）开发的进程间通信机制，它既可用于同一计算机之上的进程间通信，也可用于网络环境不同计算机之间的进程间通信。  本文并不详细讨论socket的具体用法，而是首先从使用socket的角度出发，来简单探讨一下在Linux环境中，socket函数是如何从应用程序空间进入内核，并被内核所支持的。 
socket简单的实现
Program Apes
10-26 144
socket应用场景 会员到期提醒 站内信 中奖信息 数据可视化 需要实时更新的场景 … 实现socket socket.io 麻烦，兼容性较好 websocket 使用方便，h5新增，低版本浏览器兼容性差 1. socket.io node环境服务端代码 安装：npm install socket.io const express = require('express') const app = express() // 把socket服务和node服务结合 const server =
socket编程实现
weixin_48651223的博客
08-09 125
socket编程实现
java【网络编程TCP/IP Socket[类] 套接字 ServerSocket[类] C/S B/S】详细讲解
qq_43436117的博客
02-20 737
【网络编程】 1.网络编程入门 1.1软件结构 C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。 B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。 两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。 1.2 网络通信协议 **网络通信协议：**通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信
Java Socket实现网络通信与文件传输
Socket可以分为三种类型： 1. 流套接字（Stream Sockets）：这是最常见的类型，对应TCP协议，提供面向连接、无差错、顺序一致且无重复的数据传输。流套接字在连接建立后，双方可以进行连续的数据交换。 2. 数据报...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值