netty 使用说明

已于 2022-05-21 12:28:38 修改
阅读量452 收藏
点赞数
分类专栏： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中文之美：每日成语【瓜田李下】
iOS逆向与安全
07-23 48
7月22日，清华大学刑法学教授@劳东燕2004 发文：人大女博士生实名举报的这次事件，当事的女孩很勇敢，学校的回应也特别快。希望这次的事件能成为一个转机，改变高校乃至整个社会对性骚扰的乡愿氛围，并促进反性骚扰常态机制的建立。更希望下一次遇到这类事件，受害一方的学生在校内就能获得正常渠道的救济，而不是需要冒二次伤害的风险，将自己置于舆论的风口，才有获得救济的可能。另外，我比较担心，这样的事件会不会给女生今后的考研或考博带来不利的影响。中文之美，美在诗词歌赋，美在绝句华章，也美在对事物名称的雅致表达。
Netty使用说明
07-29
在"Netty使用说明"这个主题中，我们可以深入探讨以下几个关键知识点： 1. **Netty的基本概念**： - **Channel**: Netty中的基本数据传输单元，它可以是TCP连接、UDP套接字或者任何其他类型的I/O连接。 - **...
netty服务器，客户端初体验
liuerchong的博客
03-29 254
一，首先引入依赖 <dependencies> <!-- Netty依赖包 https://mvnrepository.com/artifact/io.netty/netty-all --> <dependency> <groupId>io.netty</groupId&...
netty 空闲监听
linhaihai0202的专栏
08-24 273
环境 dk8 netty <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.20.Final</version> </dependency> 代码 Client.java package com.lhh.demo.netty.chartgroup...
springboot集成netty实战
nandao158的博客
07-03 9942
今天我们分享springboot集成netty的过程： 1、jar包依赖，Netty服务端和客户端依赖的jar包一样： <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.28.Final</version> </dependency> <!-- 序列
Netty编解码（MessagePack实现）
吃四碗饭的嘤嘤怪的博客
10-26 6040
MessagePack是一个高效的二进制序列化框架，它像JSON一样支持不同语言间的数据交换，但是它性能更快，序列化后码流更小。 MessagePack特点： 1.编解码高效，性能高； 2.序列化后的码流小； 3.支持跨语言。 实现： 首先需要的jar: &lt;dependency&gt; &lt;groupId&gt;io.netty&l...
Netty 实战入门（一）
qq_22074337的博客
03-25 3924
一、Netty 简介 Netty是 一个异步事件驱动的网络应用程序框架(基于 java NIO)，用于快速开发可维护的高性能协议服务器和客户端。 二、优点 设计方面 对各种传输协议提供统一的 API（使用阻塞和非阻塞套接字时候使用的是同一个 API，只是需要设置的参数不一样）。 基于一个灵活、可扩展的事件模型来实现关注点清晰分离。 高度可定制的线程模型——单线程、一个或多个线程池。 真正的无数据报套接字（UDP）的支持（since 3.1）。 易用性 完善的 Javadoc 文档和示例代码。
Netty应用说明笔记
12-19
在Java NIO框架的基础上，Netty为开发者提供了更高级别的抽象，减少了直接使用NIO所需的复杂性，比如Java多线程和网络编程。 使用Netty的主要原因包括： 1. 数据格式封装：Netty通过编码器和解码器实现了对多种...
Netty数据转发工具
04-13
Netty是一款高性能、异步事件驱动的网络应用框架，它为Java开发人员提供了构建高性能、可扩展的网络应用程序的强大工具。在"Netty数据转发工具"的场景中，描述提到的"Netty实现端口数据转发：3000进4000出"意味着...
Netty:Netty基本使用封装
05-09
NettyNetty基本使用二次开发,封装Netty服务端和客户端的使用使用说明若格式有问题可在idea中查看一、基本消息传输协议及编解码1.所有传输的基本业务数据由于业务设计是通过二进制字节数组进行传输,在本工程中若...
netty4.1开发jar和api说明
08-25
- **异步事件驱动**：Netty 使用非阻塞I/O模型，通过EventLoop（事件循环）和Channel（通道）提供高效率的数据传输。 - **线程模型**：EventLoopGroup负责管理多个EventLoop，每个EventLoop处理一个或多个连接，...
Netty 实现socket 连接和WebSocket 同时连接，并相互通信
XCG123456789的专栏
07-20 2517
1、maven 依赖 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.65.Final</version> </dependency> 2、Server 端 public class HttpServer { private int port;
聊聊storm client的netty buffer watermark
weixin_34021089的博客
11-01 247
序 本文主要研究一下storm client的netty buffer watermark Config storm-2.0.0/storm-client/src/jvm/org/apache/storm/Config.java /** * Netty based messaging: The netty write buffer high watermark in bytes....
netty初学第一个代码跑起来.............................
summitjava的博客
06-14 301
————————————————————————————————————————————————————————————————————————————————————————————package com.netty.test;import io.netty.bootstrap.ServerBootstrap;import io.netty.channel.ChannelFuture;impor...
Netty网络编程（一）：初步了解
最新发布
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
01-10 7244
netty易于开发、性能优秀，同时兼具稳定性和灵活性。如果你希望开发高性能的服务，那么使用netty总是没错的。
Netty使用（一）
beautifulYuan的博客
08-09 1922
一：netty介绍 Netty是由Jboss提供的一个java 开源框架，github上独立运行的项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 二使用：添加pom文件 <!-- https://mvnrepository.com/artifact/io.netty/netty-all --> <dependency> <groupId>io.netty</groupId...
【netty使用手册】
weixin_43664448的博客
01-10 973
netty 使用手册 前言 如今，我们使用通用应用程序或库彼此通信。例如，我们经常使用HTTP客户端库从web服务器检索信息，并通过web服务调用远程过程调用。然而，通用协议或其实现有时不能很好地扩展。这就像我们不使用通用HTTP服务器来交换巨大的文件、电子邮件和近乎实时的消息，如财务信息和多人游戏数据。所需要的是一个高度优化的协议实现，专门用于特定用途。例如，您可能希望实现一个HTTP服务器，该服务器针对基于AJAX的聊天应用程序、媒体流或大型文件传输进行了优化。您甚至可以设计和实现一个全新的协议，该协议
Netty---BootStrap
阿七
07-02 1441
Bootstrap类是Netty提供的一个工厂类，作用：Netty组件的组装，Netty程序的初始化。 一，概念 1.父子通道 在Netty中，每一个NioSocketChannel通道所封装的是Java Nio通道，java Nio下面就是操作系统封装的socket描述符。操作系统的底层socket描述符又分为： 1.连接监听类型：放在服务器端，负责接收客户端的套接字连接请求，一个监听类型的socket描述符可以监听成千上万个连接请求。 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值