又坏又迷人
又坏又迷人

Netty入门学习总结

Netty 概述

原生 NIO 存在的问题

  1. NIO 的类库与 API 繁杂，需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、Bytebuffer 等。
  2. 要求熟悉 Java 多线程编程和网络编程。
  3. 开发工作量和难度大，例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等。

什么是 Netty

  • Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠的网络 I/O 程序。
  • Netty 可以快速、简单的开发一个网络应用，相当于简化和流程化了 NIO 的开发过程。
  • Netty 是目前最流行的 NIO 框架，在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，Elasticsearch、Dubbo 框架内部都采用了 Netty。

Netty 作为业界最流行的 nio 框架之一，它的健壮性、功能、性能、可定制性、可扩展性都是首屈一指的。

优点：

  1. API 使用简单，开发门槛低。
  2. 功能强大，预置了多种编解码功能，支持多种主流协议。
  3. 定制能力强，通过 channelHandler 对通信框架进行灵活扩展。
  4. 高性能。
  5. 成熟，稳定，修复了所有的 NIO BUG.
  6. 社区活跃。
  7. 经历了大规模的商业应用考验，质量得到验证。

线程模型介绍

目前存在的线程模型有：

  • 传统阻塞 I/O 服务模型。
  • Reactor 模式。

  • 根据 Reactor 的数量和处理资源线程池的数量不同，有三种不同实现：

    • 单 Reactor 单线程。
    • 单 Reactor 多线程。
    • 主从 Reactor 多线程。
  • Netty 线程模式主要基于主从 Reactor 多线程模型做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor。

传统阻塞 I/O 服务模型

Netty入门学习总结_第1张图片

模型特点

  1. 采用阻塞 I/O 获取输入的数据。
  2. 每个连接都需要独立的线程完成数据的输入、业务处理、数据返回。

    问题分析

  3. 当并发数很大时，会创建大量的线程，占用很大的系统资源。
  4. 连接创建后，如果当前线程暂时没有数据可读，该线程会阻塞在 Read 操作上，造成线程资源浪费。

    解决方案

  5. 基于I/O复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞所有连接，当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
  6. 基于线程池复用线程资源：不必为每一个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。

Reactor 模式

Netty入门学习总结_第2张图片

  1. Reactor 模式，通过一个或多个输入同时传递给服务器处理的模式（基于事件驱动）。
  2. 服务器端程序处理传入的多个请求，并将它们同步分派到相应的处理线程。
  3. Reactor 模式使用了 I/O 复用监听事件，受到事件后分发给某个线程（进程），网络服务高并发处理的关键。

核心组成

  1. Reactor：在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序对 I/O 事件作出反应。
  2. Handlers：处理程序执行 I/O 事件要完成的实际事件。Reactor 通过调用适当的处理程序来响应 I/O 事件，处理程序非阻塞操作。

单 Reactor 单线程

Netty入门学习总结_第3张图片

  • select 是 I/O 复用模型介绍的标准网络编程 API，可以实现应用程序通过一个阻塞对象监听多路连接请求。
  • Reactor 对象通过 Select 监控客户端请求事件，收到事件后通过 Dispatch 进行分发。
  • 如果建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个 Handler 对象处理连接完成后的后续业务处理。
  • 如果不是建立连接事件，则 Reactor 会分发给调用连接对应的 Handler 来响应。
  • Handler 会完成 Read—>业务处理—>Send 的完整业务流程。

优缺点：

  • 优点：模型简单，无多线程、进程通信、竞争的问题，全部由一个线程完成。
  • 缺点：性能问题，只有一个线程无法发挥出多核 CPU 的性能，Handler 在处理某连接业务时，整个进程无法处理其他连接事件，容易导致性能瓶颈。
  • 缺点：可靠性问题，线程意外中止，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部信息，节点故障。
  • 使用场景：客户端数量有限，业务处理快捷（例如 Redis 在业务处理的时间复杂度为 O(1)的情况）。

单 Reactor 多线程

Netty入门学习总结_第4张图片

  • Reactor 通过 select 监控客户端请求事件，收到事件后，通过 dispatch 进行分发。
  • 如果是建立连接的请求，则由 Acceptor 通过 accept 处理连接请求，同时创建一个 handler 处理完成连接后的后续请求。
  • 如果不是连接请求，则由 Reactor 分发调用连接对应的 handler 来处理。
  • Handler 只负责响应事件，不做具体的业务处理，通过 read 读取数据后，会分发给后面的 worker 线程池中的某个线程处理业务。
  • Worker 线程池会分配独立的线程处理真正的业务，并将结果返回给 Handler。
  • Handler 收到响应后，通过 send 方法将结果反馈给 Client。

优缺点：

  • 优点：可以充分的利用多核 CPU 的处理能力。
  • 缺点：多线程数据共享、访问操作比较复杂，Reactor 处理所有的事件的监听和响应，因为 Reactor 在单线程中运行，在高并发场景容易出现性能瓶颈。

主从 Reactor 多线程

Netty入门学习总结_第5张图片

  • Reactor 主线程 MainReactor 对象通过 select 监听连接事件，收到事件后，通过 Acceptor 处理连接事件。
  • 当 Acceptor 处理连接事件后，MainReactor 将创建好的连接分配给 SubReactor。
  • SubReactor 将连接加入到连接队列进行监听，并创建 Handler 进行各种事件处理。
  • 当有新事件发生时，SubReactor 调用对应的 Handler 进行处理。
  • Handler 通过 read 读取数据，分发给后面的 Worker 线程池处理。
  • Worker 线程池会分配独立的 Worker 线程进行业务处理，并将结果返回。
  • Handler 收到响应结果后，通过 send 方法将结果返回给 Client。

优缺点:

  • 优点：父线程和子线程的职责明确，父线程只需要接收新连接，子线程完成后续业务处理。
  • 优点：父线程与子线程的数据交互简单，Reactor 主线程是需要把新连接传给子线程，子线程无需返回数据。
  • 缺点：编程复杂度较高。

Reactor 模式小结

单 Reactor 单线程：前台接待员和服务员是同一个人，全程为顾客服务。

单 Reactor 多线程：一个前台接待员，多个服务员。

主从 Reactor 多线程：多个前台接待员，多个服务员。

  1. 响应快，虽然 Reactor 本身是同步的，但不必为单个同步事件所阻塞。
  2. 最大程度的避免了复杂的多线程及同步问题，避免了多线程/进程的切换开销。
  3. 扩展性好，可以方便的通过增加 Reactor 势力个数充分利用 CPU 资源。
  4. 复用性好，Reactor 模型本身与具体事件处理逻辑无关，具有很高的复用性。

Netty 模型

Netty入门学习总结_第6张图片

服务端端包含 1 个 Boss NioEventLoopGroup 和 1 个 Worker NioEventLoopGroup。

NioEventLoopGroup 相当于 1 个事件循环组，这个组里包含多个事件循环 NioEventLoop，每个 NioEventLoop 包含 1 个 Selector 和 1 个事件循环线程。

每个 Boss NioEventLoop 循环执行的任务包含 3 步：

  1. 轮训 Accept 事件。
  2. 处理 Accept I/O 事件，与 Client 建立连接，生成 NioSocketChannel，并将 NioSocketChannel 注册到某个 Worker NioEventLoop 的 Selector 上。
  3. 处理任务队列中的任务，runAllTasks。任务队列中的任务包括用户调用 eventloop.execute 或 schedule 执行的任务，或者其它线程提交到该 eventloop 的任务。

每个 Worker NioEventLoop 循环执行的任务包含 3 步：

  1. 轮询 read、write 事件。
  2. 处理 I/O 事件，即 read、write 事件，在 NioSocketChannel 可读、可写事件发生时进行处理。
  3. 处理任务队列中的任务，runAllTasks。
  4. 每个 Worker NioEventLoop 处理业务时，会使用 PipeLine(管道)，pipeline 中包含了 channel，即通过 pipeline 可以获取对应通道，通道中维护了很多处理器。

Netty 简单通讯代码案例

/**
 * @author jack
 */
public class SimpleServer {

    public static void main(String[] args) {
        //创建bossGroup , 只负责连接请求
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        //创建workerGroup , 负责客户端业务处理
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        //创建服务端启动对象,配置参数.
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        try {
            serverBootstrap.group(bossGroup, workerGroup)//设置线程组
                    .channel(NioServerSocketChannel.class)//使用NioSocketChannel作为服务端的通道实现
                    .option(ChannelOption.SO_BACKLOG, 128)//设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持活动连接状态
                    .childHandler(new ChannelInitializer() {//创建一个通道测试对象
                        //给pipeline设置处理器
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyServerHandler()); //自定义handler
                        }
                    });//workerGroup的EventLoop对应的管道设置处理器

            System.out.println("服务端准备就绪...");

            //绑定一个端口并且同步,生成了一个channelFuture对象
            ChannelFuture cf = serverBootstrap.bind(6667).sync();
            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

}
/**
 * 服务端自定义handler
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 读取实际数据(这里我们可以读取客户端发送的消息)
     *
     * @param ctx 上下文对象,含有管道pipeline,通道channel ,地址
     * @param msg 客户端发送的内容
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送: " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址为:" + ctx.channel().remoteAddress());
    }

    /**
     * 读取完成后
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("你好,客户端", CharsetUtil.UTF_8));
    }


    /**
     * 处理异常,一般是关闭通道
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

/**
 * @author jack
 */
public class SimpleClient {

    public static void main(String[] args) {
        //客户端需要一个事件循环组
        NioEventLoopGroup clientLoopGroup = new NioEventLoopGroup();
        //创建客户端启动对象
        Bootstrap bootstrap = new Bootstrap();
        try {
            bootstrap.group(clientLoopGroup)//设置线程组
                    .channel(NioSocketChannel.class)//设置客户端通道实现类
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyClientHandler());//加入自定义处理器
                        }
                    });

            System.out.println("客户端已准备就绪");
            //连接服务器
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 6667).sync();
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            clientLoopGroup.shutdownGracefully();
        }
    }

}
/**
 * 客户端自定义handler
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 通道准备就绪时调用
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("你好,服务端!", CharsetUtil.UTF_8));
    }

    /**
     * 获取客户端回复
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务端回复: " + buf.toString(CharsetUtil.UTF_8));
    }

    /**
     * 处理异常,一般是关闭通道
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}

运行结果

Netty入门学习总结_第7张图片

Netty入门学习总结_第8张图片

任务队列中的 task 有 3 种使用场景

  1. 用户自定义的普通任务

     ctx.channel().eventLoop().execute(() -> System.out.println("任务逻辑"));

  2. 用户自定义的定时任务

    ctx.channel().eventLoop().schedule(() -> System.out.println("任务逻辑..."), 60, TimeUnit.SECONDS);
  3. 非当前 reactor 线程调用 channel 的各种方法

    例如在推送系统的业务线程里面，根据用户的标识，找到对应的 channel 引用，然后调用 write 类方法向该用户推送消息，就会进入到这种场景。最终的 write 会提交到任务队列中后被异步消费。

Netty 模型小结

  1. Netty 抽象出两组线程池：BossGroup 专门负责接收客户端的连接；WorkerGroup 专门负责网络的读写。
  2. NioEventLoop 表示一个不断循环的执行任务的线程，每个 NioEventLoop 都有一个 selector，用于监听绑定在其上的 socket 的网络通道。
  3. NioEventLoop 内部采用串行化设计，从消息读取->处理->编码->发送始终由 I/O 线程 NioEventLoop 负责。
  4. NioEventLoopGroup 下包含多个 NioEventLoop。
  5. 每个 NioEventLoop 中包含一个 Selector，一个 taskQueue。
  6. 每个 NioEventLoop 的 Selector 可以注册监听多个 NioChannel。
  7. 每个 NioChannel 只会绑定唯一的 NioEventLoop。
  8. 每个 NioChannel 都会绑定一个自己的 ChannelPipeLine。

Netty 核心组件

BootStrap、ServerBootStrap

一个 Netty 应用通常由一个 BootStrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中的 BootStrap 类是客户端程序的启动引导类，ServerBootStrap 是服务端启动引导类。

常用方法：

方法 含义
public ServerBootstrap group(EventLoopGroup parentGroup , EventLoopGroup childGroup) 作用于服务器端，用来设置两个 EventLoop
public B group(EventLoopGroup group) 作用于客户端，用来设置一个 EventLoopGroup
public B channel(Class channelClass) 用来设置一个服务端的通道实现
public B option(ChannelOption option, T value) 用来给 ServerChannel 添加配置
public ServerBootStrap childOption (ChannelOption childOption, T value) 用来给接收到的通道添加配置
public ServerBootstrap childHandler (ChannelHandler childHandler) 用来设置业务处理类（自定义 handler）
public B handler(ChannelHandler handler) Handler 则在服务器端本身 bossGroup 中使用
public ChannelFuture bind(int inetPort) 用于服务端，设置占用的端口号
public ChannelFuture connect (String inetHost,int inetPort) 该方法用于客户端，用来连接服务器

Future、ChannelFuture

Netty 中所有操作都是异步的，不能立即得知消息是否被正确处理，但可以过一会等它执行完成或直接注册一个监听器，具体实现通过 Future 和 ChannelFuture，它们可以注册一个监听，当操作执行成功或失败时，监听会自动触发注册的监听事件。

常用方法：

方法 含义
Channel channel() 返回当前正在进行 I/O 操作的通道
ChannelFuture sync() 等待异步操作执行完毕

Channel

  1. Channel 是 Netty 网络通信组件，能够用于执行网络 I/O 操作。
  2. 通过 Channel 可获得当前网络连接的通道状态、配置参数（比如缓冲区大小）。
  3. Channel 提供异步的网络 I/O 操作（建立连接，读写，绑定端口），异步调用意味着任何 I/O 调用都将立即返回，但不保证在调用结束时所请求的 I/O 操作已完成。
  4. 调用立即返回一个 ChannelFuture 实例，通过注册监听器，可以在 I/O 操作成功、失败或取消时回调通知调用方。
  5. 支持关联 I/O 操作与对应的处理程序。
  6. 不同协议、不同的阻塞类型的连接是不同的，Channel 类型与之对应。

常用的 Channel 类型有：

方法 含义
NioSocketChannel 异步的客户端 TCP Socket 连接
NioServerSocketChannel 异步的服务端 TCP Socket 连接
NioDatagramChannel 异步的 UDP 连接
NioStcpChannel 异步的客户端 Sctp 连接
NioSctpServerChannel 异步的服务端 Sctp 连接

Selector

  • Netty 基于 Selector 对象实现 I/O 多路复用，通过 Selector 一个线程可以监听多个连接的 Channel 事件。
  • 当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询（select）这些 Channel 中是否有就绪的 I/O 事件（可读、可写、完成网络连接等），这样程序就可以简单地使用一个线程高效地管理多个 Channel。

ChannelHandler

  • ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline（业务处理链）中的下一个处理程序。
  • ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承他的子类。

Netty入门学习总结_第9张图片

  • ChannelInboundHandler ： 用于处理 Channel 入站 I/O 事件。
  • ChannelOutBoundHandler：用于处理 Channel 出站 I/O 操作。

适配器：

  • ChannelInboundHandlerAdapter：用于处理出站 I/O 操作。
  • ChanneInboundHandlerAdapter：用于处理入站 I/O 操作。
  • ChannelDuplexHandler：用于处理入站和出站事件。
以客户端应用程序为例：如果事件运动方向是客户端服务器，我们称之为“出站”，即客户端发送的数据会通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 Handler 处理，反之称为“入站”。

Pipeline、ChannelPipeline

ChannelPipeline 是一个重点：

  1. ChannelPipeline 是一个 Handler 的集合，它负责处理和拦截 Inbound 或者 outbound 的事件和操作。
  2. ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的 ChannelHandler 如何相互交互。
  3. 在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应，它们的组成关系如下：

Netty入门学习总结_第10张图片

  1. 一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联了一个 ChannelHandler。
  2. 入站事件和出站事件在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 Handeler，出站事件会从链表 tail 往前传递到最前一个出站的 Handler，两种类型的 Handler 互不干扰。

常用方法：

方法 含义
ChannelPipeline addFirst(ChannelHandler... handlers) 把一个业务处理类，放到链表中头结点的位置
ChannelPipeline addLast(ChannelHandler... handlers) 把一个业务处理类，放到链表中尾结点的位置

ChannelHandlerContext

  • 保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象。
  • 即 ChannelHandlerContext 中包含一个具体的事件处理器 ChannelHandler，同时 ChannelHandlerContext 中也绑定了对应的 pipeline 和 Channel 的信息，方便对 ChannelHandler 进行调用。

常用方法：

方法 含义
ChannelFuture close() 关闭通道
ChannelOutboundInvoker flush() 刷新
ChannelFuture writeAndFlush(Object msg) 将数据写入到 ChannelPipeline 中当前 ChannelHandler 的下一个 ChannelHandler 开始处理（出站）

ChannelOption

  1. Netty 在创建 Channel 实例后，一般需要通过 ChannelOption 参数来配置 channel 的相关属性。

  2. ChannelOption 参数如下：

    • ChannelOption.SO_BACKLOG：对应 TCP/IP 协议 listen 函数中的 backlog 参数，用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接，多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定了队列的大小。
    • ChannelOption.SO_KEEPALIVE：一直保持连接活动状态。

EventLoopGroup、以及实现类 NioEventLoopGroup

  1. EventLoopGroup 本质上是一个接口(interface)，继承了 EventExecutorGroup，通过继承关系分析，可以发现 EventLoopGroup 的实现子类是 MultithreadEventLoopGroup 下的 NioEventLoopGroup。
  2. EventLoopGroup 是一组 EventLoop 的抽象，Netty 为了更好的利用多核 CPU 资源，一般会有多个 EventLoop 同时工作，每个 EventLoop 维护了一个 selector 实例。
  3. EventLoopGroup 提供next接口，可以从组里按照一定规则获取其中一个 EventLoop 来处理任务。在 Netty 服务器端编程中，我们一般都需要提供两个 EventLoopGroup，例如 BossEventLoopGroup 和 WorkerEventLoopGroup。
  4. 通常一个服务端口（ServerSocketChannel）对应一个 Selector 和一个 EventLoop 线程。BossEventLoopGroup 负责接收客户端连接并将 SocketChannel 交给 WorkerEventLoopGroup 进行 I/O 处理。

Netty入门学习总结_第11张图片

  1. BossEventLoopGroup 通常是一个单线程的 EventLoop，EventLoop 维护了一个注册了 ServerSocketChannel 的 Selector 实例。BossEventLoopGroup 不断轮询 Selector 将连接事件分离出来。
  2. 通常是 OP_ACCEPT 事件，然后将接收的 SocketChannel 交给 WorkerEventLoopGroup。
  3. WorkerEventLoopGroup 会由 next 选择其中一个 EventLoop 将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 I/O 事件进行处理。

Unpooled

  1. Unpolled 类是 Netty 提供的专门用于操作缓冲区(即 Netty 的数据容器)的工具类。
  2. 通过给定的数据和字符编码返回一个 ByteBuf 对象：常用方法：public static ByteBuf copierBuffer(CharSequence string, Charset charset)。
ByteBuf buffer = Unpooled.buffer(10);
ByteBuf buf =Unpooled.copiedBuffer("你好", CharsetUtil.UTF_8);

在 Netty 的 buffer 中，读取 buffer 中的数据不需要通过 flip()方法进行状态切换，其底层维护了 readerIndex 和 writerIndex

  • 0 ——> readerIndex ：已读区域。
  • readerIndex ——> writerIndex：未读但可读区域。
  • writerIndex ——> capacity：可写区域。
  1. 每调用一次 byteBuf.readByte()读取数据，byteBuf 的 readerIndex 便减少 1；调用 byteBuf.getByte()则不会引起 readerIndex 的变化。
  2. public abstract CharSequence getCharSequence(int index, int length, Charset charset) ：的作用是按照某一个范围进行数据的读取，index 表示起始位置，length 表示读取长度，charset 表示字符编码格式。

Netty 实现群聊系统

  1. 服务器端：检测用户上线、离线、转发客户端消息。
  2. 客户端：通过 channel 可以无阻塞发送消息给其他客户，同时可以接收其他客户端发送的消息（服务器转发得到）。

Server 端

public class Server {

    private static final int port = 6667;

    public static void main(String[] args) {
        run();
    }

    /**
     * 处理客户端请求
     */
    public static void run() {
        //创建两个线程组
        NioEventLoopGroup bossLoopGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerLoopGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();
        try {
            serverBootstrap.group(bossLoopGroup, workerLoopGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline()
                                    //增加解码器
                                    .addLast("decoder", new StringDecoder())
                                    //增加编码器
                                    .addLast("encoder", new StringEncoder())
                                    //加入自定义业务处理器
                                    .addLast(new ServerHandler());

                        }
                    });
            ChannelFuture future = serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerLoopGroup.shutdownGracefully();
            bossLoopGroup.shutdownGracefully();
        }

    }

}

ServerHandler

public class ServerHandler extends SimpleChannelInboundHandler {

    /**
     * 定义一个channel 组,管理所有的channel , GlobalEventExecutor.INSTANCE是全局事件执行器,单例模式
     */
    private static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


    /**
     * 连接建立调用,将当前channel加入channelGroup
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        //提示其他客户端当前客户端已上线
        channels.writeAndFlush("[客户端]" + channel.remoteAddress() + "加入聊天!\n");

        channels.add(channel);
    }

    /**
     * 表示channel处于活动状态,提示上线
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + ":已上线!");
    }

    /**
     * 非活动状态提示 离线
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + ":已离线!");
    }

    /**
     * 断开连接
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        //提示其他客户端当前客户端已断开连接
        channels.writeAndFlush("[客户端]" + channel.remoteAddress() + "断开连接!\n");
    }

    /**
     * 读取客户端消息并转发
     * @param channelHandlerContext
     * @param msg
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, String msg) throws Exception {
        Channel channel = channelHandlerContext.channel();
        channels.forEach(ch -> {
            if (channel != ch) {
                ch.writeAndFlush("[客户]: " + channel.remoteAddress() + sdf.format(new Date()) +" 说:" + msg + "\n");
            } else {
                ch.writeAndFlush(sdf.format(new Date())+" 你说:" + msg + "\n");
            }
        });
    }

    /**
     * 异常关闭
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

Client 端

public class Client {

    private static final String HOST = "127.0.0.1";
    private static final int PORT = 6667;


    public static void main(String[] args) {
        run();
    }

    public static void run() {
        NioEventLoopGroup clientLoopGroup = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap();
        try {
            bootstrap.group(clientLoopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline()
                                    //增加解码器
                                    .addLast("decoder", new StringDecoder())
                                    //增加编码器
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new ClientHandler());
                        }
                    });

            ChannelFuture future = bootstrap.connect(HOST, PORT).sync();
            Channel channel = future.channel();
            System.out.println("客户端:" + channel.localAddress() + " 准备就绪");
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                String msg = scanner.nextLine();
                //通过channel发送到服务器端
                channel.writeAndFlush(msg + "\r\n");
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            clientLoopGroup.shutdownGracefully();
        }
    }
}

ClientHandler

public class ClientHandler extends SimpleChannelInboundHandler {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, String msg) throws Exception {
        System.out.println(msg.trim());
    }
}

运行结果

Netty入门学习总结_第12张图片

Netty入门学习总结_第13张图片

Netty 心跳监测机制案例

客户端同用上面的即可。记得端口对应

Server 端

public class Server {

    public static void main(String[] args) {
        //创建两个线程组
        NioEventLoopGroup bossLoopGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerLoopGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossLoopGroup, workerLoopGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))//在bossLoopGroup 增加日志处理器
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            // 加入 IdleStateHandler
                            // 第一个参数 多长时间没读 就发送心跳监测包看是否连接
                            // 第二个参数 多长时间没写 就发送心跳监测包看是否连接
                            // 第三个参数 多长时间没有读写 就发送心跳监测包看是否连接
                            // 第四个参数 时间单位
                            //当 触发后 会传递给管道中的下一个handler来处理,调用下一个handler的userEventTriggered
                            pipeline.addLast(new IdleStateHandler(3,5,7, TimeUnit.SECONDS));
                            //加入空闲检测处理的handler
                            pipeline.addLast(new ServerHandler());
                        }
                    });
            ChannelFuture future = serverBootstrap.bind(7000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workerLoopGroup.shutdownGracefully();
            bossLoopGroup.shutdownGracefully();
        }
    }

}

ServerHandler

public class ServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * @param ctx 上下文
     * @param evt 事件
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent){
            //将evt转型
            IdleStateEvent event = (IdleStateEvent) evt;
            SocketAddress socketAddress = ctx.channel().remoteAddress();
            switch (event.state()){
                case READER_IDLE:
                    System.out.println(socketAddress + "发生读空闲");
                    break;
                case WRITER_IDLE:
                    System.out.println(socketAddress + "发生写空闲");
                    break;
                case ALL_IDLE:
                    System.out.println(socketAddress + "发生读写空闲");
                    break;
            }

        }
    }
}

运行结果

Netty入门学习总结_第14张图片

WebSocket

Http 短连接和长连接

  • Http 短连接即 TCP 短连接，即客户端和服务器通过“三次握手”建立连接后，进行一次 HTTP 操作以后，便断开连接。因此，浏览器每打开一个 web 资源，便创建了一个新的 http 会话。
  • Http 长连接即 TCP 长连接，即客户端和服务器建立连接后保持一定的时间，即使用户在进行某次操作后将浏览器（或客户端）关闭，但只要在保持时间内又一次访问该服务器，则默认使用已经创建好的连接。
  • Http1.0 默认支持短连接，Http1.1 默认支持长连接。

Http 连接无状态

  • Http 协议无状态是指协议对于事务处理没有记忆性，即某一次打开一个服务器的网页和上一次打开这个服务器的网页之间没有关系。

WebSocket 简介

  • WebSocket 是一种可以在单个 TCP 连接上实现全双工通信的通信协议，HTTP 协议只能实现客户端请求，服务端响应的单向通信，而 webSocket 则可以实现服务端主动向客户端推送消息。
  • WebSocket 复用了 HTTP 的握手通道，客户端和服务器的数据交换则遵照升级后的协议进行：WebSocket 相关的业务处理器可以将 HTTP 协议升级为 ws 协议，其核心功能之一为保持稳定的长连接。

代码案例

  • 实现基于 webSocket 的长连接全双工交互。
  • 改变 HTTP 协议多次请求的约束，实现长连接，服务器可以发送消息给浏览器。
  • 客户端和服务器会相互感知。若服务器关闭，客户端会感知；同样客户端关闭，服务器也会感知。

Server 端

public class Server {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try{
            ServerBootstrap serverBootstrap = new ServerBootstrap();

            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline pipeline = ch.pipeline();

                            //因为基于http协议，故使用http的编解码器
                            pipeline.addLast(new HttpServerCodec());
                            //过程中以块的方式写，添加 ChunkedWriteHandler 处理器
                            pipeline.addLast(new ChunkedWriteHandler());
                            /**
                             * 说明
                             * 1、http数据在传输过程中是分段的，HttpObjectAggregator 可以将多个数据段整合起来
                             * 2、因此，当浏览器发送大量数据时，就会发出多次http请求
                             * */
                            pipeline.addLast(new HttpObjectAggregator(8192));
                            /**
                             * 说明
                             * 1、对于 WebSocket，它的数据以 帧（Frame）的形式传递
                             * 2、可以看到 WebSocketFrame 下面有6个子类
                             * 3、浏览器请求时 ws://localhost:7000/xxx 表示请求的uri
                             * 4、WebSocketServerProtocolHandler 会把 http 协议升级为ws协议
                             *      即保持长连接----------核心功能
                             * 5、如何升级——通过状态玛切换101
                             */
                            pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));

                            //自定义的 handler 处理业务逻辑
                            pipeline.addLast(new TextWebSocketFrameHandler());
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

}

Handler

public class TextWebSocketFrameHandler extends SimpleChannelInboundHandler {


    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, TextWebSocketFrame textWebSocketFrame) throws Exception {
        System.out.println("服务器收到消息:" + textWebSocketFrame.text());
        //回复消息
        channelHandlerContext.channel().writeAndFlush(new TextWebSocketFrame("服务器时间:" + LocalDateTime.now() + " " + textWebSocketFrame.text()));
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerAdded 被调用:" + ctx.channel().id().asLongText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved 被调用:" + ctx.channel().id().asLongText());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常发生"+cause.getMessage());
        ctx.close();
    }
}

HTML



  
    
    Title

运行结果

Netty入门学习总结_第15张图片

Netty入门学习总结_第16张图片

编码和解码

  1. 数据在网络中是以二进制字节码的形式流动，而我们在接收或发送的数据形式则各种各样（文本、图片、音视频等），因此需要在发送端对数据进行编码，在接收端对收到的数据解码；
  2. codec(编解码器)的组成部分——Encoder(编码器)负责将业务数据转换为二进制字节码；Decoder(解码器)负责将二进制字节码转换为业务数据。
  3. Netty 编码机制——StringEncoder / StringDecoder负责字符串数据对象的编解码；ObjectEncoder / ObjectDecoder负责 java 对象的编解码。

  4. Netty 自带的 ObjectEncoder 和 ObjectDecoder 可以用于实现 POJO 对象或其他业务对象的编解码，其底层使用的仍是 java 的序列化技术，存在以下问题：

    • 无法实现客户端与服务器端的跨语言。
    • 序列化体积过大，是二进制字节码的 5 倍多。
    • 序列化性能相对较低。

ProtoBuf 概述

  • ProtoBuf 是 Google 发布的开源项目，全称 Google Protocol Buffers，ProtoBuf 是一种平台无关、语言无关的、可扩展且轻便高效的序列化数据结构的协议，适合用于数据存储和 RPC(远程过程调用)数据交换格式。
  • ProtoBuf 是以Message的方式来管理数据的。
  • 所谓“平台无关、语言无关”，即客户端和服务器可以使用不同的编程语言进行开发。
  • ProtoBuf 具有更高的性能和可靠性。
  • 使用 ProtoBuf 编译器可以自动生成代码，ProtoBuf 是把类的定义使用.proto文件描述出来，在通过 proto.exe 将.proto 文件编译为.java 文件。

Netty入门学习总结_第17张图片

ProtoBuf 使用

第一步：idea 加入插件 protoc

Netty入门学习总结_第18张图片

第二步：加入 maven 依赖


  com.google.protobuf
  protobuf-java
  3.6.1

第三步：编写 proto 文件

syntax = "proto2";  //版本
option java_outer_classname = "StudentPOJO"; //生成的外部类名称，同时文件名
//protobuf以message的形式管理数据
message Student{ //会在 studentPOJO 外部类生成一个内部类 Student，它是真正发送的POJO对象
  required int32 id = 1; //表示 Student 类中有一个属性 名字为id,类型为 int32(protoType)，1表示属性的序号
  required string name = 2;
}

根据网上教程安装 protobuf。生成 StudnetPOJO 文件，这里就不展示代码了，比较长。

Server 端

public class Server {

    public static void main(String[] args) throws InterruptedException {

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();

            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline pipeline = ch.pipeline();
                            //在pipeline中加入ProtoBufferDecoder
                            //指定对哪一种对象进行解码
                            pipeline.addLast("decoder", new ProtobufDecoder(StudentPOJO.Student.getDefaultInstance()));
                            pipeline.addLast(new ServerHandler());
                        }
                    });
            ChannelFuture cf = serverBootstrap.bind(6668).sync();
            //给 cf 添加监听器，监听感兴趣的事件
            cf.addListener((ChannelFutureListener) future -> {
                if (cf.isSuccess()) {
                    System.out.println("绑定端口 6668 成功");
                } else {
                    System.out.println(cf.cause());
                }
            });
            cf.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}

ServerHandler

public class ServerHandler extends SimpleChannelInboundHandler {

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello，客户端~", CharsetUtil.UTF_8));
    }

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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, StudentPOJO.Student msg) throws Exception {
      System.out.println("客户端发送: id = " + msg.getId() + " 名字 = " + msg.getName());
    }

}

Client 端

public class ClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        //发送一个 student 对象到服务器
        StudentPOJO.Student student = StudentPOJO.Student.newBuilder().setId(1000).setName("Jack").build();
        ctx.writeAndFlush(student);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务器回送消息：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器端地址：" + ctx.channel().remoteAddress());
    }

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

ClientHandler

public class Client {

    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventExecutors)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //在pipeline中加入ProtoBufferEncoder
                            ChannelPipeline pipeline = ch.pipeline();
                            //编码
                            pipeline.addLast("encoder", new ProtobufEncoder());
                            pipeline.addLast(new ClientHandler());

                        }
                    });
            System.out.println("客户端已准备就绪");
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }

}

运行结果

Netty入门学习总结_第19张图片

Netty入门学习总结_第20张图片

handler 调用机制

  • ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如：实现 ChannelInboundHandler 接口（或 ChannelInboundHandlerAdapter），可以接收入站事件和数据，这些数据将被业务逻辑处理；当给客户端回送响应时，也可以通过 ChannelInboundHandler 冲刷数据。业务逻辑通常写在一个或多个 ChannelInboundHandler 中。
  • ChannelOutboundHandler 与之类似，只不过是用来处理出站数据的。
  • ChannelPipeline 提供了 ChannelHandler 链的容器（pipeline.addLast()可以将一系列的 handler 以链表的形式添加），以客户端应用程序为例，如果事件运动方向为客户端->服务器，称之为“出站”，即客户端发送给服务器的数据通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 handler 处理。反之则称为“入站”。

编码解码器

  1. 当 Netty 发送或者接受一个消息的时候，就将会发生一次数据转换。入站消息会被解码：从字节码转换到另一种格式（比如 Java）。如果是出站消息，它会被编码成字节。
  2. Netty 提供一系列使用的编解码器，它们都实现了 CHannelInboundHandler 或者 ChannelOutboundHandler 接口。在这些类中，channelRead 方法已经被重写。

    以入站为例，对于每个从入站 Channel 读取的消息，这个方法会被调用。随后，他将调用由解码器所提供的 decode()方法进行解码，并将已经解码的字节转发给 ChannelPipeline 中的下一个 ChannelInboundHandler。

消息入站后，会经过 ChannelPipeline 中的一系列 ChannelHandler 处理，这些 handler 中有 Netty 已经实现的，也有我们重新实现的自定义 handler，但它们都需要实现 ChannelInboundHandler 接口；即消息入站后所经过的 handler 链是由一系列 ChannelInboundHandler 组成的，其中第一个经过的 handler 就是解码器 Decoder；消息出站与入站类似，但消息出站需要经过一系列 ChannelOutboundHandler 的实现类，最后一个经过的 handler 是编码器 Encoder。

解码器 — ByteToMessageDecoder

Netty入门学习总结_第21张图片

由于不知道远程节点是否会发送一个完整的信息，TCP 可能出现粘包和拆包的问题。ByteToMessageDecoder 的作用就是对入站的数据进行缓冲，直至数据准备好被处理。

ByteToMessageDecoder 示例分析：

public class ToIntgerDecoder extends ByteToMessageDecoder{
        @Override
        protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception{
                if (in.readableBytes() >= 4) {
                         out.add(in.readint());
                }
        }
} 
 
在此实例中，假设通过 Socket 发送了 8 字节数据，每次入站从 ByteBuf 中读取个 4 字节，将其解码为一个 int，并加入一个 List 中。当没有更多的元素可以被添加到该 List 中时，代表此次发送的数据已发送完成，List 中的所有内容会被发送给下一个 ChannelInboundHandler。Int 在被添加到 List 中时，会被自动装箱为 Intger，调用 readInt()方法前必须验证所输入的 ByteBuf 是否有足够的数据。
 
 
Netty入门学习总结_第22张图片
 
 
代码示例：
 
 
     
  
  • 使用自定义的编码解码器
    •  
  
  • 客户端可以发送一个 Long 类型的数据给服务器。
    •  
 
 
 
Server 端
 
 
public class Server {

    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();

        try {
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ServerInitializer()); //自定义初始化类
            ChannelFuture future = serverBootstrap.bind(7000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}
 
 
ServerInitializer 自定义初始化类
 
 
public class ServerInitializer extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        //入站的handler解码
        pipeline.addLast(new ByteToLongDecoder()).addLast(new ServerInboundHandler());
    }
}
 
 
ByteToLongDecoder 自定义解码器
 
 
public class ByteToLongDecoder extends ByteToMessageDecoder {

    /**
     * @param channelHandlerContext 上下文对象
     * @param byteBuf               入站的ByteBuf
     * @param list                  List集合,将解码后的数据传给下一个Handler
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List list) throws Exception {
        // Long 大于 8个字节
        if (byteBuf.readableBytes() >= 8) {
            list.add(byteBuf.readLong());
        }
    }
} 
 
ServerInboundHandler 自定义 handler，处理业务
 
 
public class ServerInboundHandler extends SimpleChannelInboundHandler {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Long aLong) throws Exception {

        System.out.println("从客户端读取:" + aLong);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
 
 
Client 端
 
 
public class Client {

    public static void main(String[] args) {
        NioEventLoopGroup clientLoopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(clientLoopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ClientInitializer());//自定义初始化类
            ChannelFuture future = bootstrap.connect("127.0.0.1", 7000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            clientLoopGroup.shutdownGracefully();
        }
    }
}
 
 
ClientInitializer 客户端自定义初始化类
 
 
public class ClientInitializer extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        //出站,数据进行编码
        pipeline.addLast(new LongToByteEncoder()).addLast(new ClientHandler());
    }
}
 
 
LongToByteEncoder 编码器
 
 
public class LongToByteEncoder extends MessageToByteEncoder {

    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, Long aLong, ByteBuf byteBuf) throws Exception {
        System.out.println("开始编码,msg = " + aLong);
        byteBuf.writeLong(aLong);
    }
}
 
 
ClientHandler 自定义 handler，处理逻辑
 
 
public class ClientHandler extends SimpleChannelInboundHandler {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("服务器的ip : " + ctx.channel().remoteAddress());
        System.out.println("收到服务器数据 : " + msg);
    }

    /**
     * 发送数据
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client发送数据");
        ctx.writeAndFlush(12345678L);
    }

}
 
 
运行结果
 
 
Netty入门学习总结_第23张图片
 
 
Netty入门学习总结_第24张图片
 
 
其他解码器
 
 
     
  
  1. LineBasedFrameDecoder：它使用行尾控制字符（\n 或\r\n）作为分割符来解析数据；
    2.  
  
  2. DelimiterBasedFrameDecoder：使用自定义的特殊字符作为分隔符；
    3.  
  
  3. HttpObjectDecoder：一个 HTTP 数据的解码器；
    4.  
  
  4. LengthFieldBasedFrameDecoder：通过指定长度来标识整包信息，这样就可以自动的处理粘包和半包信息
    5.  
 
 
 
TCP 粘包和拆包基本介绍
 
 
     
  
  • TCP 是面向连接，面向流，提供高可靠性服务。在消息收发过程中，需要在发送端和接收端建立对应的 Socket，发送端不会一有数据就进行发送，而是将多次间隔较小的，数据量较小的数据合并成一定长度的数据包整体发送。这样可以提高效率，但会给接收方分辨单个数据消息增加难度，因为面向流的通信是没有消息保护边界的。
    •  
  
  • TCP 粘包与拆包，是指发送端在发送多个数据消息时出现的不同情形。由于数据在发送前需要先转换为二进制字节码，当多个数据消息的字节码被合并成一个数据包发送时，称为粘包；当某个数据消息的字节码被划分到几个数据包内发送时，称为拆包。粘包和拆包可能使接收端解码数据包时出现错误。
    •  
  
  • TCP 粘包和拆包的解决方案：使用自定义协议+编解码器解决，只要接收端能够知道每次读取数据的长度，就可以按位读取，避免出现读取错误。我们需要做的就是使接收端知道每次读取数据的长度。
    •  
 
 
 
Netty入门学习总结_第25张图片
 
 
TCP 粘包拆包代码演示
 
 
Server 端
 
 
public class Server {

    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();

        try {
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ServerInitializer()); //自定义初始化类
            ChannelFuture future = serverBootstrap.bind(7000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}
 
 
ServerInitializer
 
 
public class ServerInitializer extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new ServerHandler());
    }
}
 
 
ServerHandler
 
 
public class ServerHandler extends SimpleChannelInboundHandler {

    private int count;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf buf) throws Exception {
        byte[] buffer = new byte[buf.readableBytes()];
        buf.readBytes(buffer);

        //将buffer转换成字符串
        String str = new String(buffer, CharsetUtil.UTF_8);
        System.out.println("服务端接收到数据:" + str);
        System.out.println("服务端接收次数:" + ++count);

        ByteBuf byteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString(), CharsetUtil.UTF_8);
        ctx.writeAndFlush(byteBuf);

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
 
 
Client 端
 
 
public class Client {

    public static void main(String[] args) {
        NioEventLoopGroup clientLoopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(clientLoopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ClientInitializer());//自定义初始化类
            ChannelFuture future = bootstrap.connect("127.0.0.1", 7000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            clientLoopGroup.shutdownGracefully();
        }
    }
}
 
 
ClientInitializer
 
 
public class ClientInitializer extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new ClientHandler());
    }
}
 
 
ClientHandler
 
 
public class ClientHandler extends SimpleChannelInboundHandler {

    private int count;

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
        byte[] bytes = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(bytes);
        String str = new String(bytes, CharsetUtil.UTF_8);
        System.out.println("客户端接收到数据: " + str);
        System.out.println("客户端接收次数:" + ++count);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发送十条数据
        for (int i = 0; i < 10; i++) {
            ByteBuf byteBuf = Unpooled.copiedBuffer("hello,server" + i, CharsetUtil.UTF_8);
            ctx.writeAndFlush(byteBuf);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
 
 
运行结果
 
 
可以看到在第一个客户端没有发生问题，启动第二个客户端后就发生了拆包问题。
 
 
Netty入门学习总结_第26张图片
 
 
自定义协议解决粘包拆包
 
 
     
  
  1. 要求客户端发送 5 个 message 对象，客户端每次发送一个 message 对象。
    2.  
  
  2. 服务器端每次接收一个 message，分 5 次进行解码，每读取一个 message，会回送一个 message 对象给客户端。
    3.  
 
 
 
使用自定义协议+编解码器实现具体功能：
 
 
具体代码
 
 
客户端与服务器主程序与之前相同
 
 
MessageProtocol 自定义协议
 
 
public class MessageProtocol {

    private int length;  //关键
    private byte[] context;

    public int getLength() {
        return length;
    }

    public byte[] getContext() {
        return context;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public void setContext(byte[] context) {
        this.context = context;
    }
 
 
MessageEncoder 自定义编码器
 
 
public class MessageEncoder extends MessageToByteEncoder {
    @Override
    protected void encode(ChannelHandlerContext ctx, MessageProtocol msg, ByteBuf out) throws Exception {
        System.out.println("MessageEncoder encode方法被调用");
        out.writeInt(msg.getLength());
        out.writeBytes(msg.getContext());

    }
}
 
 
MessageDecoder.自定义解码器
 
 

public class MessageDecoder extends ReplayingDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception {
        System.out.println("MessageDecoder decode方法被调用");
        //将得到的二进制字节码转换为 MessageProtocol 数据包
        int length = in.readInt();
        byte[] content = new byte[length];

        in.readBytes(content);

        //封装成MessageProtocol对象，放入out中交给下一个handler处理
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLength(length);
        messageProtocol.setContext(content);

        out.add(messageProtocol);
    }
} 
 
在 ServerInitializer 和 ClientInitializer 中增加 addList()编解码器
 
 
ServerHandler
 
 
public class ServerHandler extends SimpleChannelInboundHandler {
    private int count;


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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {

        //接收数据并处理
        int len = msg.getLength();
        byte[] context = msg.getContext();

        System.out.println("服务端接收到信息如下");
        System.out.println("数据长度："+len);
        System.out.println("内容："+new String(context, CharsetUtil.UTF_8));

        System.out.println("服务器接收到协议包数量 = "+(++this.count));

        //回复消息
        String response = UUID.randomUUID().toString();
        int responseLen = response.getBytes("utf-8").length;
        byte[] responseBytes = response.getBytes("utf-8");
        //构建一个协议包
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLength(responseLen);
        messageProtocol.setContext(responseBytes);

        ctx.writeAndFlush(messageProtocol);
    }
}
 
 
ClientHandler
 
 
public class ClientHandler extends SimpleChannelInboundHandler {
    private int count;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端循环发送10条数据

        for (int i=0;i<5;i++){
            String mes = "今天下雨，出门带伞";
            byte[] content = mes.getBytes(Charset.forName("utf-8"));

            int length = mes.getBytes(Charset.forName("utf-8")).length;

            //创建协议包
            MessageProtocol messageProtocol = new MessageProtocol();
            messageProtocol.setLength(length);
            messageProtocol.setContext(content);

            ctx.writeAndFlush(messageProtocol);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常消息 = "+cause.getMessage());
        ctx.close();
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {
        int len = msg.getLength();
        byte[] msgContext = msg.getContext();

        System.out.println("客户端接收的消息如下：");
        System.out.println("消息长度 = "+len);
        System.out.println("消息内容 = "+new String(msgContext, CharsetUtil.UTF_8));

        System.out.println("客户端接收消息的数量 = "+(++this.count));
    }
}
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,netty)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • ztree设置禁用节点
                                    3213213333332132
JavaScriptztreejsonsetDisabledNodeAjax
                                    
    ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 
 
 
$(function(){            	
                showTree();
	            setDisabledNode();

});
                   
        
    
                                
    • 
                                
  • JVM patch by Taobao
                                    bookjovi
javaHotSpot
                                    
    在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。 
  
7050685：jsdbproc64.sh has a typo in the package name 
7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 
7060619：C1 should respect inline and
    
                                
    • 
                                
  • 将session存储到数据库中
                                    dcj3sjt126com
sqlPHPsession
                                    
    CREATE TABLE sessions (
  id CHAR(32) NOT NULL,
  data TEXT,
  last_accessed TIMESTAMP NOT NULL,
  PRIMARY KEY (id)
); 
  
<?php
/**
 * Created by PhpStorm.
 * User: michaeldu
 * Date
    
                                
    • 
                                
  • Vector
                                    171815164
vector
                                    
    public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) {
		for (int i = 0; i < cart.size(); i++) {
			if (cart.get(i).getId().equals(id)) {
				cart.remove(i);
				
    
                                
    • 
                                
  • 各连接池配置参数比较
                                    g21121
连接池
                                    
            排版真心费劲，大家凑合看下吧，见谅~ 
      
  
Druid 
DBCP 
C3P0 
Proxool   
数据库用户名称 Username Username User     
数据库密码 Password Password Password     
驱动名
    
                                
    • 
                                
  • [简单]mybatis insert语句添加动态字段
                                    53873039oycg
mybatis
                                    
          mysql数据库,id自增,配置如下： 
      
<insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id"
		parameterType=&
    
                                
    • 
                                
  • struts2拦截器配置
                                    云端月影
struts2拦截器
                                    
    struts2拦截器interceptor的三种配置方法 
方法1. 普通配置法 
 
<struts> 
    <package name="struts2" extends="struts-default"> 
        &
    
                                
    • 
                                
  • IE中页面不居中，火狐谷歌等正常
                                    aijuans
IE中页面不居中
                                    
    问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
    
                                
    • 
                                
  • String,int,Integer,char 几个类型常见转换
                                    antonyup_2006
htmlsql.net
                                    
    如何将字串 String 转换成整数 int? 
int i = Integer.valueOf(my_str).intValue(); 
 
int i=Integer.parseInt(str); 
 
如何将字串 String 转换成Integer ? 
Integer integer=Integer.valueOf(str); 
 
如何将整数 int 转换成字串 String ? 
1.
    
                                
    • 
                                
  • PL/SQL的游标类型
                                    百合不是茶
显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
                                    
    游标是oracle中的一个结果集,用于存放查询的结果; 
  
PL/SQL中游标的声明; 
1,声明游标

2,打开游标(默认是关闭的);

3,提取数据

4,关闭游标
 
  
  
注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标 
  
隐式游标:主要是对DML数据的操作隐
    
                                
    • 
                                
  • JUnit4中@AfterClass @BeforeClass @after @before的区别对比
                                    bijian1013
JUnit4单元测试
                                    
    一.基础知识 
JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
    
                                
    • 
                                
  • 精通Oracle10编程SQL(12)开发包
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *开发包
 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数）
 */
--包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成
--建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等
--在包规
    
                                
    • 
                                
  • 【EhCache二】ehcache.xml配置详解
                                    bit1129
ehcache.xml
                                    
    在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ 
ehcache.xml ： http://ehcache.org/ehcache.xml 
ehcache.xsd ： http://ehcache.org/ehcache.xsd 
ehcache配置文件的根元素是ehcahe 
  ehcac
    
                                
    • 
                                
  • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
                                    白糖_
javaeclipsespringtomcatWeb
                                    
    今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： 
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
 随后启动
    
                                
    • 
                                
  • angular.element
                                    boyitech
AngularJSAngularJS APIangular.element
                                    
    angular.element 
描述:      包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）       如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
    
                                
    • 
                                
  • java-给定两个已排序序列，找出共同的元素。
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class CommonItemInTwoSortedArray {

	/**
	 * 题目：给定两个已排序序列，找出共同的元素。
	 * 1.定义两个指针分别指向序列的开始。
	 * 如果指向的两个元素
    
                                
    • 
                                
  • sftp 异常，有遇到的吗？求解
                                    Chen.H
javajcraftauthjschjschexception
                                    
    com.jcraft.jsch.JSchException: Auth cancel 
 at com.jcraft.jsch.Session.connect(Session.java:460) 
 at com.jcraft.jsch.Session.connect(Session.java:154) 
 at cn.vivame.util.ftp.SftpServerAccess.connec
    
                                
    • 
                                
  • [生物智能与人工智能]神经元中的电化学结构代表什么?
                                    comsci
人工智能
                                    
         我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色.... 
 
     我们可以尝试一下...在某些神经
    
                                
    • 
                                
  • 通过LAC和CID获取经纬度信息
                                    dai_lm
laccid
                                    
    方法1： 
用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 
 
方法2： 
发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
    
                                
    • 
                                
  • JAVA的困难分析
                                    datamachine
java
                                    
    前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。 
  
-----------------------------------------------------------------------------------------
    
                                
    • 
                                
  • 小学5年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    money 钱 
paper 纸 
speak 讲，说 
tell 告诉 
  
remember 记得，想起 
knock 敲，击，打 
question 问题 
number 数字，号码 
  
learn 学会，学习 
street 街道 
carry 搬运，携带 
send 发送，邮寄，发射 
  
must 必须 
light 灯，光线，轻的 
front 
    
                                
    • 
                                
  • linux下面没有tree命令
                                    dcj3sjt126com
linux
                                    
    centos p安装 
yum -y install tree 
  
mac os安装 
brew install tree 
  首先来看tree的用法  
tree  中文解释：tree
功能说明：以树状图列出目录的内容。
语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
    
                                
    • 
                                
  • Map迭代方式，Map迭代，Map循环
                                    蕃薯耀
Map循环Map迭代Map迭代方式
                                    
    Map迭代方式，Map迭代，Map循环 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年
    
                                
    • 
                                
  • Spring Cache注解+Redis
                                    hanqunfeng
spring
                                    
    Spring3.1 Cache注解  
依赖jar包： 
<!-- redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			
    
                                
    • 
                                
  • Guava中针对集合的 filter和过滤功能
                                    jackyrong
filter
                                    
    在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： 
 
   

@Test
public void whenFilterWithIterables_thenFiltered() {
    List<String> names = Lists.newArrayList("John"
    
                                
    • 
                                
  • 学习编程那点事
                                    lampcy
编程androidPHPhtml5
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • 架构师之流处理---------bytebuffer的mark,limit和flip
                                    nannan408
ByteBuffer
                                    
    1.前言。 
  如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 
2.例子. 
 

例子代码:
     String str = "helloWorld";  
        ByteBuffer buff  = ByteBuffer.wrap(str.getBytes());  
        Sy
    
                                
    • 
                                
  • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1
                                    Everyday都不同
$转义el表达式
                                    
    最近在做Highcharts的过程中，在写js时，出现了以下异常： 
  
严重: Servlet.service() for servlet jsp threw exception 
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, 
    
                                
    • 
                                
  • 用Java实现发送邮件到163
                                    tntxia
java实现
                                    
    /*

 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。

 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。

 此篇仅介绍用
    
                                
    • 
                                
  • 探索实体类存在的真正意义
                                    java小叶檀
POJO
                                    
    一. 实体类简述   
 实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 
POJO（Plain Old Java Objects）简单的Java对象 
  
它的一般格式就是 
public class A{
      private String id;
      public Str
    
                                
    •