Java NioUdtProvider类代码示例

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public void run() throws Exception {
    final ThreadFactory connectFactory = new DefaultThreadFactory("rendezvous");
    final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
            connectFactory, NioUdtProvider.BYTE_PROVIDER);
    try {
        final Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(connectGroup)
                .channelFactory(NioUdtProvider.BYTE_RENDEZVOUS)
                .handler(new ChannelInitializer<UdtChannel>() {
                    @Override
                    protected void initChannel(UdtChannel ch) throws Exception {
                        ch.pipeline().addLast(
                                new LoggingHandler(LogLevel.INFO),
                                new ByteEchoPeerHandler(messageSize));
                    }
                });
        final ChannelFuture future = bootstrap.connect(peerAddress, myAddress).sync();
        future.channel().closeFuture().sync();
    } finally {
        connectGroup.shutdownGracefully();
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
/**
 * verify factory
 */
@Test
public void provideFactory() {
    // bytes
    assertNotNull(NioUdtProvider.BYTE_ACCEPTOR.newChannel());
    assertNotNull(NioUdtProvider.BYTE_CONNECTOR.newChannel());
    assertNotNull(NioUdtProvider.BYTE_RENDEZVOUS.newChannel());

    // message
    assertNotNull(NioUdtProvider.MESSAGE_ACCEPTOR.newChannel());
    assertNotNull(NioUdtProvider.MESSAGE_CONNECTOR.newChannel());
    assertNotNull(NioUdtProvider.MESSAGE_RENDEZVOUS.newChannel());

    // acceptor types
    assertTrue(NioUdtProvider.BYTE_ACCEPTOR.newChannel() instanceof UdtServerChannel);
    assertTrue(NioUdtProvider.MESSAGE_ACCEPTOR.newChannel() instanceof UdtServerChannel);
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public void run() throws Exception {
    final ThreadFactory connectFactory = new UtilThreadFactory("rendezvous");
    final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
            connectFactory, NioUdtProvider.BYTE_PROVIDER);
    try {
        final Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(connectGroup)
                .channelFactory(NioUdtProvider.BYTE_RENDEZVOUS)
                .handler(new ChannelInitializer<UdtChannel>() {
                    @Override
                    protected void initChannel(UdtChannel ch) throws Exception {
                        ch.pipeline().addLast(
                                new LoggingHandler(LogLevel.INFO),
                                new ByteEchoPeerHandler(messageSize));
                    }
                });
        final ChannelFuture future = bootstrap.connect(peerAddress, myAddress).sync();
        future.channel().closeFuture().sync();
    } finally {
        connectGroup.shutdownGracefully();
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
/**
 * verify factory
 */
@Test
public void provideFactory() {

    EventLoop loop = new NioEventLoopGroup().next();
    EventLoopGroup childGroup = new NioEventLoopGroup();

    // bytes
    assertNotNull(NioUdtProvider.BYTE_ACCEPTOR.newChannel(loop, childGroup));
    assertNotNull(NioUdtProvider.BYTE_CONNECTOR.newChannel(loop));
    assertNotNull(NioUdtProvider.BYTE_RENDEZVOUS.newChannel(loop));

    // message
    assertNotNull(NioUdtProvider.MESSAGE_ACCEPTOR.newChannel(loop, childGroup));
    assertNotNull(NioUdtProvider.MESSAGE_CONNECTOR.newChannel(loop));
    assertNotNull(NioUdtProvider.MESSAGE_RENDEZVOUS.newChannel(loop));

    // acceptor types
    assertTrue(NioUdtProvider.BYTE_ACCEPTOR.newChannel(loop, childGroup) instanceof UdtServerChannel);
    assertTrue(NioUdtProvider.MESSAGE_ACCEPTOR.newChannel(loop, childGroup) instanceof UdtServerChannel);
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
@Override
public ChannelFactory<? extends Channel> getChannelFactory() {
    if (CC.mp.net.tcpGateway()) return super.getChannelFactory();
    if (CC.mp.net.udtGateway()) return NioUdtProvider.BYTE_CONNECTOR;
    if (CC.mp.net.sctpGateway()) return NioSctpChannel::new;
    return super.getChannelFactory();
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
@Override
public SelectorProvider getSelectorProvider() {
    if (CC.mp.net.tcpGateway()) return super.getSelectorProvider();
    if (CC.mp.net.udtGateway()) return NioUdtProvider.BYTE_PROVIDER;
    if (CC.mp.net.sctpGateway()) return super.getSelectorProvider();
    return super.getSelectorProvider();
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
@Override
public ChannelFactory<? extends ServerChannel> getChannelFactory() {
    if (CC.mp.net.tcpGateway()) return super.getChannelFactory();
    if (CC.mp.net.udtGateway()) return NioUdtProvider.BYTE_ACCEPTOR;
    if (CC.mp.net.sctpGateway()) return NioSctpServerChannel::new;
    return super.getChannelFactory();
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public static void main(String[] args) throws Exception {

        // Configure the client.
        final ThreadFactory connectFactory = new DefaultThreadFactory("connect");
        final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
                connectFactory, NioUdtProvider.MESSAGE_PROVIDER);
        try {
            final Bootstrap boot = new Bootstrap();
            boot.group(connectGroup)
                    .channelFactory(NioUdtProvider.MESSAGE_CONNECTOR)
                    .handler(new ChannelInitializer<UdtChannel>() {
                        @Override
                        public void initChannel(final UdtChannel ch)
                                throws Exception {
                            ch.pipeline().addLast(
                                    new LoggingHandler(LogLevel.INFO),
                                    new MsgEchoClientHandler());
                        }
                    });
            // Start the client.
            final ChannelFuture f = boot.connect(HOST, PORT).sync();
            // Wait until the connection is closed.
            f.channel().closeFuture().sync();
        } finally {
            // Shut down the event loop to terminate all threads.
            connectGroup.shutdownGracefully();
        }
    }
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    final ThreadFactory acceptFactory = new DefaultThreadFactory("accept");
    final ThreadFactory connectFactory = new DefaultThreadFactory("connect");
    final NioEventLoopGroup acceptGroup =
            new NioEventLoopGroup(1, acceptFactory, NioUdtProvider.MESSAGE_PROVIDER);
    final NioEventLoopGroup connectGroup =
            new NioEventLoopGroup(1, connectFactory, NioUdtProvider.MESSAGE_PROVIDER);

    // Configure the server.
    try {
        final ServerBootstrap boot = new ServerBootstrap();
        boot.group(acceptGroup, connectGroup)
                .channelFactory(NioUdtProvider.MESSAGE_ACCEPTOR)
                .option(ChannelOption.SO_BACKLOG, 10)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer<UdtChannel>() {
                    @Override
                    public void initChannel(final UdtChannel ch)
                            throws Exception {
                        ch.pipeline().addLast(
                                new LoggingHandler(LogLevel.INFO),
                                new MsgEchoServerHandler());
                    }
                });
        // Start the server.
        final ChannelFuture future = boot.bind(PORT).sync();
        // Wait until the server socket is closed.
        future.channel().closeFuture().sync();
    } finally {
        // Shut down all event loops to terminate all threads.
        acceptGroup.shutdownGracefully();
        connectGroup.shutdownGracefully();
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    // Configure the client.
    final ThreadFactory connectFactory = new DefaultThreadFactory("connect");
    final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
            connectFactory, NioUdtProvider.BYTE_PROVIDER);
    try {
        final Bootstrap boot = new Bootstrap();
        boot.group(connectGroup)
                .channelFactory(NioUdtProvider.BYTE_CONNECTOR)
                .handler(new ChannelInitializer<UdtChannel>() {
                    @Override
                    public void initChannel(final UdtChannel ch)
                            throws Exception {
                        ch.pipeline().addLast(
                                new LoggingHandler(LogLevel.INFO),
                                new ByteEchoClientHandler());
                    }
                });
        // Start the client.
        final ChannelFuture f = boot.connect(HOST, PORT).sync();
        // Wait until the connection is closed.
        f.channel().closeFuture().sync();
    } finally {
        // Shut down the event loop to terminate all threads.
        connectGroup.shutdownGracefully();
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    final ThreadFactory acceptFactory = new DefaultThreadFactory("accept");
    final ThreadFactory connectFactory = new DefaultThreadFactory("connect");
    final NioEventLoopGroup acceptGroup = new NioEventLoopGroup(1, acceptFactory, NioUdtProvider.BYTE_PROVIDER);
    final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1, connectFactory, NioUdtProvider.BYTE_PROVIDER);

    // Configure the server.
    try {
        final ServerBootstrap boot = new ServerBootstrap();
        boot.group(acceptGroup, connectGroup)
                .channelFactory(NioUdtProvider.BYTE_ACCEPTOR)
                .option(ChannelOption.SO_BACKLOG, 10)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer<UdtChannel>() {
                    @Override
                    public void initChannel(final UdtChannel ch)
                            throws Exception {
                        ch.pipeline().addLast(
                                new LoggingHandler(LogLevel.INFO),
                                new ByteEchoServerHandler());
                    }
                });
        // Start the server.
        final ChannelFuture future = boot.bind(PORT).sync();
        // Wait until the server socket is closed.
        future.channel().closeFuture().sync();
    } finally {
        // Shut down all event loops to terminate all threads.
        acceptGroup.shutdownGracefully();
        connectGroup.shutdownGracefully();
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
public void run() throws Exception {
    // Configure the peer.
    final ThreadFactory connectFactory = new DefaultThreadFactory("rendezvous");
    final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
            connectFactory, NioUdtProvider.MESSAGE_PROVIDER);
    try {
        final Bootstrap boot = new Bootstrap();
        boot.group(connectGroup)
                .channelFactory(NioUdtProvider.MESSAGE_RENDEZVOUS)
                .handler(new ChannelInitializer<UdtChannel>() {
                    @Override
                    public void initChannel(final UdtChannel ch)
                            throws Exception {
                        ch.pipeline().addLast(
                                new LoggingHandler(LogLevel.INFO),
                                new MsgEchoPeerHandler(messageSize));
                    }
                });
        // Start the peer.
        final ChannelFuture f = boot.connect(peer, self).sync();
        // Wait until the connection is closed.
        f.channel().closeFuture().sync();
    } finally {
        // Shut down the event loop to terminate all threads.
        connectGroup.shutdownGracefully();
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
@Override
protected Future<?> execute() {
    Bootstrap cb = new Bootstrap().group(proxyServer.getProxyToServerWorkerFor(transportProtocol));

    switch (transportProtocol) {
    case TCP:
        LOG.debug("Connecting to server with TCP");
        cb.channelFactory(new ChannelFactory<Channel>() {
            @Override
            public Channel newChannel() {
                return new NioSocketChannel();
            }
        });
        break;
    case UDT:
        LOG.debug("Connecting to server with UDT");
        cb.channelFactory(NioUdtProvider.BYTE_CONNECTOR)
                .option(ChannelOption.SO_REUSEADDR, true);
        break;
    default:
        throw new UnknownTransportProtocolException(transportProtocol);
    }

    cb.handler(new ChannelInitializer<Channel>() {
        protected void initChannel(Channel ch) throws Exception {
            initChannelPipeline(ch.pipeline(), initialRequest);
        };
    });
    cb.option(ChannelOption.CONNECT_TIMEOUT_MILLIS,
            proxyServer.getConnectTimeout());

    if (localAddress != null) {
        return cb.connect(remoteAddress, localAddress);
    } else {
        return cb.connect(remoteAddress);
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
/**
 * Determines if UDT is available on the classpath.
 *
 * @return true if UDT is available
 */
public static boolean isUdtAvailable() {
    try {
        return NioUdtProvider.BYTE_PROVIDER != null;
    } catch (NoClassDefFoundError e) {
        return false;
    }
}
 

import io.netty.channel.udt.nio.NioUdtProvider; //导入依赖的package包/类
@Override
protected Future<?> execute() {
    Bootstrap cb = new Bootstrap().group(proxyServer
            .getProxyToServerWorkerFor(transportProtocol));

    switch (transportProtocol) {
    case TCP:
        LOG.debug("Connecting to server with TCP");
        cb.channelFactory(new ChannelFactory<Channel>() {
            @Override
            public Channel newChannel() {
                return new NioSocketChannel();
            }
        });
        break;
    case UDT:
        LOG.debug("Connecting to server with UDT");
        cb.channelFactory(NioUdtProvider.BYTE_CONNECTOR)
                .option(ChannelOption.SO_REUSEADDR, true);
        break;
    default:
        throw new UnknownTransportProtocolError(transportProtocol);
    }

    cb.handler(new ChannelInitializer<Channel>() {
        protected void initChannel(Channel ch) throws Exception {
            initChannelPipeline(ch.pipeline(), initialRequest);
        };
    });
    cb.option(ChannelOption.CONNECT_TIMEOUT_MILLIS,
            proxyServer.getConnectTimeout());

    if (localAddress != null) {
        return cb.connect(remoteAddress, localAddress);
    } else {
        return cb.connect(remoteAddress);
    }
}