netty 使用说明

已于 2022-05-21 12:28:38 修改
阅读量456 收藏
点赞数
分类专栏： netty 文章标签： netty
于 2022-05-20 16:19:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/124885684
版权

netty 使用说明

        

                

                                 

相关jar包

           

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.77.Final</version>
        </dependency>

         

                   

                                 

启动器类

    

AbstractBootstrap

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
    private static final Entry<ChannelOption<?>, Object>[] EMPTY_OPTION_ARRAY = new Entry[0];
    private static final Entry<AttributeKey<?>, Object>[] EMPTY_ATTRIBUTE_ARRAY = new Entry[0];
    volatile EventLoopGroup group;
    private volatile ChannelFactory<? extends C> channelFactory;
    private volatile SocketAddress localAddress;
    private final Map<ChannelOption<?>, Object> options = new LinkedHashMap();
    private final Map<AttributeKey<?>, Object> attrs = new ConcurrentHashMap();
    private volatile ChannelHandler handler;


    AbstractBootstrap() {
    AbstractBootstrap(AbstractBootstrap<B, C> bootstrap) {


    public B group(EventLoopGroup group) {
    public B channel(Class<? extends C> channelClass) {
    public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
    public B handler(ChannelHandler handler) {
    public <T> B option(ChannelOption<T> option, T value) {
    public <T> B attr(AttributeKey<T> key, T value) {

    public B localAddress(SocketAddress localAddress) {
    public B localAddress(int inetPort) {
    public B localAddress(String inetHost, int inetPort) {
    public B localAddress(InetAddress inetHost, int inetPort) {

    public ChannelFuture bind() {
    public ChannelFuture bind(int inetPort) {
    public ChannelFuture bind(String inetHost, int inetPort) {
    public ChannelFuture bind(InetAddress inetHost, int inetPort) {
    public ChannelFuture bind(SocketAddress localAddress) {

    public B validate() {
    public ChannelFuture register() {

    public abstract B clone();
    public abstract AbstractBootstrapConfig<B, C> config();

    abstract void init(Channel var1) throws Exception;

    final ChannelHandler handler() {
    final SocketAddress localAddress() {
    final ChannelFuture initAndRegister() {
    final Map<AttributeKey<?>, Object> attrs() {
    final Map<ChannelOption<?>, Object> options() {
    final ChannelFactory<? extends C> channelFactory() {

    final Map<AttributeKey<?>, Object> attrs0() {
    final Map<ChannelOption<?>, Object> options0() {
    final Entry<ChannelOption<?>, Object>[] newOptionsArray() {
    final Entry<AttributeKey<?>, Object>[] newAttributesArray() {


    static Entry<ChannelOption<?>, Object>[] newOptionsArray(Map<ChannelOption<?>, Object> options) {
    static Entry<AttributeKey<?>, Object>[] newAttributesArray(Map<AttributeKey<?>, Object> attributes) {
    static <K, V> Map<K, V> copiedMap(Map<K, V> map) {
    static void setAttributes(Channel channel, Entry<AttributeKey<?>, Object>[] attrs) {
    static void setChannelOptions(Channel channel, Entry<ChannelOption<?>, Object>[] options, InternalLogger logger) {

    private B self() {
    private ChannelFuture doBind(final SocketAddress localAddress) {
    private static void setChannelOption(Channel channel, ChannelOption<?> option, Object value, InternalLogger logger) {
    private static void doBind0(final ChannelFuture regFuture, final Channel channel, final SocketAddress localAddress, final ChannelPromise promise) {

    public String toString() {


********
内部类：PendingRegistrationPromise

    static final class PendingRegistrationPromise extends DefaultChannelPromise {
        private volatile boolean registered;

        PendingRegistrationPromise(Channel channel) {
            super(channel);
        }

        void registered() {
        protected EventExecutor executor() {

           

Bootstrap：客户端启动器

public class Bootstrap extends AbstractBootstrap<Bootstrap, Channel> {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(Bootstrap.class);
    private static final AddressResolverGroup<?> DEFAULT_RESOLVER;
    private final BootstrapConfig config = new BootstrapConfig(this);
    private volatile AddressResolverGroup<SocketAddress> resolver;
    private volatile SocketAddress remoteAddress;

    public Bootstrap() {
    private Bootstrap(Bootstrap bootstrap) {


    public Bootstrap validate() {
    public Bootstrap clone() {
    public Bootstrap clone(EventLoopGroup group) {
    public Bootstrap resolver(AddressResolverGroup<?> resolver) {

    public Bootstrap remoteAddress(SocketAddress remoteAddress) {
    public Bootstrap remoteAddress(String inetHost, int inetPort) {
    public Bootstrap remoteAddress(InetAddress inetHost, int inetPort) {

    public ChannelFuture connect() {
    public ChannelFuture connect(String inetHost, int inetPort) {
    public ChannelFuture connect(InetAddress inetHost, int inetPort) {
    public ChannelFuture connect(SocketAddress remoteAddress) {
    public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {

    public final BootstrapConfig config() {

    void init(Channel channel) {

    final SocketAddress remoteAddress() {
    final AddressResolverGroup<?> resolver() {

    private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
    private ChannelFuture doResolveAndConnect0(final Channel channel, SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
    private static void doConnect(final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise connectPromise) {

    static {
        DEFAULT_RESOLVER = DefaultAddressResolverGroup.INSTANCE;
    }
}

        

ServerBootstrap：服务端启动器

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(ServerBootstrap.class);
    private final Map<ChannelOption<?>, Object> childOptions = new LinkedHashMap();
    private final Map<AttributeKey<?>, Object> childAttrs = new ConcurrentHashMap();
    private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);
    private volatile EventLoopGroup childGroup;
    private volatile ChannelHandler childHandler;

    public ServerBootstrap() {
    }


    public ServerBootstrap group(EventLoopGroup group) {
    public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {
    public <T> ServerBootstrap childAttr(AttributeKey<T> childKey, T value) {
    public ServerBootstrap childHandler(ChannelHandler childHandler) {

    public ServerBootstrap validate() {
    public ServerBootstrap clone() {

    public final ServerBootstrapConfig config() {

    final ChannelHandler childHandler() {
    final Map<ChannelOption<?>, Object> childOptions() {
    final Map<AttributeKey<?>, Object> childAttrs() {

    void init(Channel channel) {
    private ServerBootstrap(ServerBootstrap bootstrap) {


**********
内部类：ServerBootstrapAcceptor

    private static class ServerBootstrapAcceptor extends ChannelInboundHandlerAdapter {
        private final EventLoopGroup childGroup;
        private final ChannelHandler childHandler;
        private final Entry<ChannelOption<?>, Object>[] childOptions;
        private final Entry<AttributeKey<?>, Object>[] childAttrs;
        private final Runnable enableAutoReadTask;

        ServerBootstrapAcceptor(final Channel channel, EventLoopGroup childGroup, ChannelHandler childHandler, Entry<ChannelOption<?>, Object>[] childOptions, Entry<AttributeKey<?>, Object>[] childAttrs) {

        public void channelRead(ChannelHandlerContext ctx, Object msg) {
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        private static void forceClose(Channel child, Throwable t) {

         

                

                                 

线程组

      

                

           

EventExecutorGroup

public interface EventExecutorGroup extends ScheduledExecutorService, Iterable<EventExecutor> {

    boolean isShuttingDown();

    Future<?> terminationFuture();
    Future<?> shutdownGracefully();
    Future<?> shutdownGracefully(long var1, long var3, TimeUnit var5);

    EventExecutor next();
    Iterator<EventExecutor> iterator();

    Future<?> submit(Runnable var1);
    <T> Future<T> submit(Runnable var1, T var2);
    <T> Future<T> submit(Callable<T> var1);

    <V> ScheduledFuture<V> schedule(Callable<V> var1, long var2, TimeUnit var4);
    ScheduledFuture<?> schedule(Runnable var1, long var2, TimeUnit var4);
    ScheduledFuture<?> scheduleAtFixedRate(Runnable var1, long var2, long var4, TimeUnit var6);
    ScheduledFuture<?> scheduleWithFixedDelay(Runnable var1, long var2, long var4, TimeUnit var6);
}

          

EventLoopGroup

public interface EventLoopGroup extends EventExecutorGroup {

    EventLoop next();

    ChannelFuture register(Channel var1);
    ChannelFuture register(ChannelPromise var1);

}

          

NioEventLoopGroup

public class NioEventLoopGroup extends MultithreadEventLoopGroup {

    public NioEventLoopGroup() {
        this(0);
    }

    public NioEventLoopGroup(int nThreads) {
    public NioEventLoopGroup(ThreadFactory threadFactory) {

    public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory) {
    public NioEventLoopGroup(int nThreads, Executor executor) {
    public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory, SelectorProvider selectorProvider) {
    public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory) {
    public NioEventLoopGroup(int nThreads, Executor executor, SelectorProvider selectorProvider) {
    public NioEventLoopGroup(int nThreads, Executor executor, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory) {
    public NioEventLoopGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory) {
    public NioEventLoopGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory, RejectedExecutionHandler rejectedExecutionHandler) {
    public NioEventLoopGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory, RejectedExecutionHandler rejectedExecutionHandler, EventLoopTaskQueueFactory taskQueueFactory) {
    public NioEventLoopGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory, RejectedExecutionHandler rejectedExecutionHandler, EventLoopTaskQueueFactory taskQueueFactory, EventLoopTaskQueueFactory tailTaskQueueFactory) {


    public void setIoRatio(int ioRatio) {
    public void rebuildSelectors() {

    protected EventLoop newChild(Executor executor, Object... args) throws Exception {

         

                

                                 

channel 类型

    

常用channel类（4.1.77 oio不推荐使用）

                 

NioSocketChannel：tcp客户端
NioServerSocketChannel：tcp服务端

NioDatagramChannel：udp客户端、服务端

NioSctpChannel：sctp客户端
NioSctpServerChannel：sctp服务端

          

              

                                 

配置参数

   

ChannelOption

public class ChannelOption<T> extends AbstractConstant<ChannelOption<T>> {
    private static final ConstantPool<ChannelOption<Object>> pool = new ConstantPool<ChannelOption<Object>>() {
        protected ChannelOption<Object> newConstant(int id, String name) {
            return new ChannelOption(id, name);
        }
    };

    public static final ChannelOption<ByteBufAllocator> ALLOCATOR = valueOf("ALLOCATOR");
    public static final ChannelOption<RecvByteBufAllocator> RCVBUF_ALLOCATOR = valueOf("RCVBUF_ALLOCATOR");
    public static final ChannelOption<MessageSizeEstimator> MESSAGE_SIZE_ESTIMATOR = valueOf("MESSAGE_SIZE_ESTIMATOR");
    public static final ChannelOption<Integer> CONNECT_TIMEOUT_MILLIS = valueOf("CONNECT_TIMEOUT_MILLIS");

    public static final ChannelOption<Integer> MAX_MESSAGES_PER_WRITE = valueOf("MAX_MESSAGES_PER_WRITE");
    public static final ChannelOption<Integer> WRITE_SPIN_COUNT = valueOf("WRITE_SPIN_COUNT");

    public static final ChannelOption<WriteBufferWaterMark> WRITE_BUFFER_WATER_MARK = valueOf("WRITE_BUFFER_WATER_MARK");
    public static final ChannelOption<Boolean> ALLOW_HALF_CLOSURE = valueOf("ALLOW_HALF_CLOSURE");
    public static final ChannelOption<Boolean> AUTO_READ = valueOf("AUTO_READ");
    public static final ChannelOption<Boolean> AUTO_CLOSE = valueOf("AUTO_CLOSE");

    public static final ChannelOption<Boolean> SO_BROADCAST = valueOf("SO_BROADCAST");
    public static final ChannelOption<Boolean> SO_KEEPALIVE = valueOf("SO_KEEPALIVE");
    public static final ChannelOption<Integer> SO_SNDBUF = valueOf("SO_SNDBUF");
    public static final ChannelOption<Integer> SO_RCVBUF = valueOf("SO_RCVBUF");
    public static final ChannelOption<Boolean> SO_REUSEADDR = valueOf("SO_REUSEADDR");
    public static final ChannelOption<Integer> SO_LINGER = valueOf("SO_LINGER");
    public static final ChannelOption<Integer> SO_BACKLOG = valueOf("SO_BACKLOG");
    public static final ChannelOption<Integer> SO_TIMEOUT = valueOf("SO_TIMEOUT");

    public static final ChannelOption<Integer> IP_TOS = valueOf("IP_TOS");
    public static final ChannelOption<InetAddress> IP_MULTICAST_ADDR = valueOf("IP_MULTICAST_ADDR");
    public static final ChannelOption<NetworkInterface> IP_MULTICAST_IF = valueOf("IP_MULTICAST_IF");
    public static final ChannelOption<Integer> IP_MULTICAST_TTL = valueOf("IP_MULTICAST_TTL");
    public static final ChannelOption<Boolean> IP_MULTICAST_LOOP_DISABLED = valueOf("IP_MULTICAST_LOOP_DISABLED");

    public static final ChannelOption<Boolean> TCP_NODELAY = valueOf("TCP_NODELAY");
    public static final ChannelOption<Boolean> TCP_FASTOPEN_CONNECT = valueOf("TCP_FASTOPEN_CONNECT");
    public static final ChannelOption<Integer> TCP_FASTOPEN = valueOf(ChannelOption.class, "TCP_FASTOPEN");

    public static final ChannelOption<Boolean> SINGLE_EVENTEXECUTOR_PER_GROUP = valueOf("SINGLE_EVENTEXECUTOR_PER_GROUP");

    public static <T> ChannelOption<T> valueOf(String name) {
    public static <T> ChannelOption<T> valueOf(Class<?> firstNameComponent, String secondNameComponent) {

    public static boolean exists(String name) {

    public void validate(T value) {
    private ChannelOption(int id, String name) {

                

                           

                                 

channel pipeline

        

通过channel接口获取对应的channel pileline，添加自定义的handler

                

          

ChannelInitailizer

@Sharable
public abstract class ChannelInitializer<C extends Channel> extends ChannelInboundHandlerAdapter {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(ChannelInitializer.class);
    private final Set<ChannelHandlerContext> initMap = Collections.newSetFromMap(new ConcurrentHashMap());

    public ChannelInitializer() {
    }

    protected abstract void initChannel(C var1) throws Exception;
                            //channel初始化

    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

    public final void channelRegistered(ChannelHandlerContext ctx) throws Exception {

    private boolean initChannel(ChannelHandlerContext ctx) throws Exception {
    private void removeState(final ChannelHandlerContext ctx) {

         

Channel

public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparable<Channel> {

    ChannelId id();
    EventLoop eventLoop();

    Channel parent();
    ChannelConfig config();

    boolean isOpen();
    boolean isRegistered();
    boolean isActive();
    boolean isWritable();

    long bytesBeforeUnwritable();
    long bytesBeforeWritable();

    SocketAddress localAddress();
    SocketAddress remoteAddress();

    ChannelFuture closeFuture();
    ChannelMetadata metadata();

    Channel.Unsafe unsafe();

    ChannelPipeline pipeline();    //获取channel pipeline

    ByteBufAllocator alloc();

    Channel read();
    Channel flush();

********
内部接口：Unsafe

    public interface Unsafe {

        Handle recvBufAllocHandle();

        SocketAddress localAddress();
        SocketAddress remoteAddress();

        void register(EventLoop var1, ChannelPromise var2);
        void deregister(ChannelPromise var1);

        void bind(SocketAddress var1, ChannelPromise var2);
        void connect(SocketAddress var1, SocketAddress var2, ChannelPromise var3);
        void disconnect(ChannelPromise var1);

        void close(ChannelPromise var1);
        void closeForcibly();

        void beginRead();
        void write(Object var1, ChannelPromise var2);
        void flush();

        ChannelPromise voidPromise();

        ChannelOutboundBuffer outboundBuffer();
    }
}

          

ChannelPipeline

public interface ChannelPipeline extends ChannelInboundInvoker, ChannelOutboundInvoker, Iterable<Entry<String, ChannelHandler>> {

*******
add 操作

    ChannelPipeline addFirst(String var1, ChannelHandler var2);
    ChannelPipeline addFirst(EventExecutorGroup var1, String var2, ChannelHandler var3);

    ChannelPipeline addLast(String var1, ChannelHandler var2);
    ChannelPipeline addLast(EventExecutorGroup var1, String var2, ChannelHandler var3);

    ChannelPipeline addBefore(String var1, String var2, ChannelHandler var3);
    ChannelPipeline addBefore(EventExecutorGroup var1, String var2, String var3, ChannelHandler var4);

    ChannelPipeline addAfter(String var1, String var2, ChannelHandler var3);
    ChannelPipeline addAfter(EventExecutorGroup var1, String var2, String var3, ChannelHandler var4);

    ChannelPipeline addFirst(ChannelHandler... var1);
    ChannelPipeline addFirst(EventExecutorGroup var1, ChannelHandler... var2);

    ChannelPipeline addLast(ChannelHandler... var1);
    ChannelPipeline addLast(EventExecutorGroup var1, ChannelHandler... var2);


*******
remove 操作

    ChannelHandler remove(String var1);
    ChannelHandler removeFirst();
    ChannelHandler removeLast();

    ChannelPipeline remove(ChannelHandler var1);
    <T extends ChannelHandler> T remove(Class<T> var1);


*******
replace 操作

    ChannelPipeline replace(ChannelHandler var1, String var2, ChannelHandler var3);
    ChannelHandler replace(String var1, String var2, ChannelHandler var3);
    <T extends ChannelHandler> T replace(Class<T> var1, String var2, ChannelHandler var3);


*******
获取ChannelHandler

    ChannelHandler first();
    ChannelHandler last();
    ChannelHandler get(String var1);
    <T extends ChannelHandler> T get(Class<T> var1);

*******
获取ChannelHandlerContext

    ChannelHandlerContext firstContext();
    ChannelHandlerContext lastContext();

    ChannelHandlerContext context(ChannelHandler var1);
    ChannelHandlerContext context(String var1);
    ChannelHandlerContext context(Class<? extends ChannelHandler> var1);


*******
触发channel事件

    ChannelPipeline fireChannelRegistered();
    ChannelPipeline fireChannelUnregistered();

    ChannelPipeline fireChannelActive();
    ChannelPipeline fireChannelInactive();

    ChannelPipeline fireExceptionCaught(Throwable var1);
    ChannelPipeline fireUserEventTriggered(Object var1);

    ChannelPipeline fireChannelRead(Object var1);
    ChannelPipeline fireChannelReadComplete();
    ChannelPipeline fireChannelWritabilityChanged();


*******
其余操作

    Channel channel();      //获取pipeline对应的channel

    List<String> names();   //获取handler名称集合
    Map<String, ChannelHandler> toMap();  //获取handler及其对应的name

    ChannelPipeline flush(); //刷新pipeline
}

            

ChannelHandler

public interface ChannelHandler {

    void handlerAdded(ChannelHandlerContext var1) throws Exception;
    void handlerRemoved(ChannelHandlerContext var1) throws Exception;

    /** @deprecated */
    @Deprecated
    void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exception;

    @Inherited
    @Documented
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Sharable {
    }
}

          

ChannelHandlerContext

public interface ChannelHandlerContext extends AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker {

    String name();
    Channel channel();
    boolean isRemoved();

    EventExecutor executor();
    ChannelHandler handler();

    ByteBufAllocator alloc();
    ChannelPipeline pipeline();

    ChannelHandlerContext read();
    ChannelHandlerContext flush();

    ChannelHandlerContext fireChannelRegistered();
    ChannelHandlerContext fireChannelUnregistered();

    ChannelHandlerContext fireChannelActive();
    ChannelHandlerContext fireChannelInactive();

    ChannelHandlerContext fireExceptionCaught(Throwable var1);
    ChannelHandlerContext fireUserEventTriggered(Object var1);

    ChannelHandlerContext fireChannelRead(Object var1);
    ChannelHandlerContext fireChannelReadComplete();
    ChannelHandlerContext fireChannelWritabilityChanged();


    /** @deprecated */
    @Deprecated
    <T> Attribute<T> attr(AttributeKey<T> var1);

    /** @deprecated */
    @Deprecated
    <T> boolean hasAttr(AttributeKey<T> var1);
}

        

                  

o_瓜田李下_o
关注
专栏目录
【JAVA】Netty使用教程
大雨淅淅的博客
08-06 1351
Netty是一个功能强大、易于使用的网络编程框架，它提供了丰富的组件和API，帮助开发者快速构建高性能、高可靠性的网络应用程序。通过掌握Netty的核心组件和基本使用方法，开发者可以更加高效地进行网络编程，提升应用程序的性能和可靠性。当然，我可以继续扩展关于Netty的使用教程，特别是关于如何处理客户端连接、数据读写以及优雅关闭连接等高级主题。
netty3 中文使用手册
08-04
NULL 博文链接：https://wanxiaotao12-126-com.iteye.com/blog/2020768
Netty实际使用说明
wmburst
07-02 360
实时高并：毫秒之差、人数众多 系统设置 业务框架 方案一： 方案二： 说明： NettyHttp协议解析 在上述方案中浏览器不能直接和Netty建立链接，必须借助HTTP请求进行协议升级才能实现客户端于服务器简历Web Sockert通讯，其过程中如 如果想实现弹幕必须实现http服务 Http协议交互过程 协议交互本质是指协议两端（客户端、服务端）如何传输数据？如何交换数据？ 传输数据一般基于TCP/IP 实现，体现到开发语言上就是我们所熟悉的Socket 编程。 交换数据本质是指，两端（客户端、
【netty使用手册】
weixin_43664448的博客
01-10 979
netty 使用手册 前言 如今，我们使用通用应用程序或库彼此通信。例如，我们经常使用HTTP客户端库从web服务器检索信息，并通过web服务调用远程过程调用。然而，通用协议或其实现有时不能很好地扩展。这就像我们不使用通用HTTP服务器来交换巨大的文件、电子邮件和近乎实时的消息，如财务信息和多人游戏数据。所需要的是一个高度优化的协议实现，专门用于特定用途。例如，您可能希望实现一个HTTP服务器，该服务器针对基于AJAX的聊天应用程序、媒体流或大型文件传输进行了优化。您甚至可以设计和实现一个全新的协议，该协议
Netty相关概念说明
caijunliyanqing的专栏
01-25 237
1、BIO、NIO和AI 2、Buffer：与Channel进行交互，数据是从Channel读入缓冲区，从缓冲区写入Channel中的 flip方法 ： 反转此缓冲区，将position给limit，然后将position置为0，其实就是切换读写模式 clear方法 ：清除此缓冲区，将position置为0，把capacity的值给limit。 rewind方法 ： 重绕此缓冲区，将pos...
Netty使用说明
07-29
在"Netty使用说明"这个主题中，我们可以深入探讨以下几个关键知识点： 1. **Netty的基本概念**： - **Channel**: Netty中的基本数据传输单元，它可以是TCP连接、UDP套接字或者任何其他类型的I/O连接。 - **...
netty使用说明
bingjie1217的专栏
09-30 4883
(1).用Netty实现的简单HTTP服务器 netty是继mina之后一个非常受欢迎的nio网络框架（其实netty的主程就是mina的主程）。 httpserver启动和配置类 package test.netty; import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.CONTENT_TYPE; im
Netty应用说明笔记
12-19
在Java NIO框架的基础上，Netty为开发者提供了更高级别的抽象，减少了直接使用NIO所需的复杂性，比如Java多线程和网络编程。 使用Netty的主要原因包括： 1. 数据格式封装：Netty通过编码器和解码器实现了对多种...
netty基础说明-结构分析-网关了解
03-22
java-netty图，分析选择器 java-netty图，分析IO java-netty图，分析管道 java-netty图，分析缓存
netty文件传输服务端与客户端以及协议说明
08-08
通过netty编写文件传输的客户端与服务端，以及协议说明， 通用的netty传输协议 通过该协议进行文件传输 文件传输客户端与服务端 可以根据文件的最后更新时间来增量传输文件 源码开放，通过eclipse或者idea导入代码...
netty4中文用户手册
07-24
netty4中文用户手册，更新到2016年3月份，清晰，非扫描，下载后请好评
netty5.0权威指南
11-25
建maven 工程 加依赖 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>5.0.0.Alpha2</version> </dependency> <dependency> <groupId>org.jboss.marshalling</groupId> <artifactId>jboss-marshalling-serial</artifactId> <version>2.0.0.Beta2</version> </dependency>
Netty 4.x 用户手册
hellwhisper的专栏
03-16 2265
Netty 4.x 用户手册（简略翻译）
Netty学习手册（一、基本使用入门）
To build a better world !
06-09 1400
背景我们即将迎来一个万物互联的时代。而在这样的时代里，最大的机遇是什么呢？有人说是智能硬件的普及，有人说是人工智能的天下，有人说是大数据的时代……都没错。但我认为，万物互联，首先不是得让万物都连上网么？从大型机、到个人PC时代，再到智能手机的普及……每一次硬件的变革，都是设备体积的减小和芯片密度的增加。同时，每一次革新，连上网的设备数量都在呈指数级的增涨。
Netty——基本使用介绍
最新发布
2401_84003941的博客
04-17 661
客户端发送的ACK时（第三次握手），TCP内核模块把客户端连接从A队列移动到B队列，连接完成，应用程序的accept会返回。System.out.println(Thread.currentThread().getName() + “,服务器初始化通道…System.out.println(Thread.currentThread().getName() + “,客户端初始化管道…//进行网络通信（读写）.option(ChannelOption.SO_BACKLOG, 128) //设置TCP缓冲区。
Netty4.x 用户指南 - 前言
Geek_ymv的专栏
06-09 353
User guide for 4.x Preface The Problem Nowadays we use general purpose applications or libraries to communicate with each other. For example, we often use an HTTP client library to retrieve inf...
Netty基础入门和基本使用
qq_25046827的博客
10-25 1014
这样就会导致一个结果@Sharable共享实例不是线程层面安全的，因此@Sharable共享的业务处理器，如果需要操作的数据不仅仅是局部变量，则需要进行线程的同步控制，以保证操作是线程层面安全的。出站处理用到的ByteBuf缓冲区一般是要发送的消息，通常由Handler业务处理器所申请而分配的，在每一个出站Handler业务处理器的处理完成后，最后数据包回来到出站的最后一棒HeadHandler，在数据输出完成后，ByteBuf会被释放一次，如果计数器为0，将被彻底释放掉。
Netty入门与实战指南
以下是对Netty教程用户手册内容的详细说明： **1. 问题与解决方案** 1.1. Netty解决了传统网络编程中的一些挑战，如线程管理、缓冲区处理和协议编码解码的复杂性。 **2. 开始使用Netty** 2.1. 在开始之前，了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值