Java ChannelFactory类代码示例

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
public void run() {
  // Configure the client.
  ChannelFactory factory = new NioClientSocketChannelFactory(
      Executors.newCachedThreadPool(), Executors.newCachedThreadPool(), 1, 1);
  ClientBootstrap bootstrap = new ClientBootstrap(factory);

  // Set up the pipeline factory.
  bootstrap.setPipelineFactory(setPipelineFactory());

  bootstrap.setOption("tcpNoDelay", true);
  bootstrap.setOption("keepAlive", true);

  // Start the connection attempt.
  ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));

  if (oneShot) {
    // Wait until the connection is closed or the connection attempt fails.
    future.getChannel().getCloseFuture().awaitUninterruptibly();

    // Shut down thread pools to exit.
    bootstrap.releaseExternalResources();
  }
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
/**
  * Starts the BGP peer.
  *
  * @param connectToSocket the socket to connect to
  */
 private void connect(InetSocketAddress connectToSocket)
     throws InterruptedException {

     ChannelFactory channelFactory =
         new NioClientSocketChannelFactory(
                 Executors.newCachedThreadPool(),
                 Executors.newCachedThreadPool());
     ChannelPipelineFactory pipelineFactory = () -> {
         ChannelPipeline pipeline = Channels.pipeline();
         pipeline.addLast("BgpPeerFrameDecoderTest",
                 peerFrameDecoder);
         pipeline.addLast("BgpPeerChannelHandlerTest",
                 peerChannelHandler);
         return pipeline;
     };

     peerBootstrap = new ClientBootstrap(channelFactory);
     peerBootstrap.setOption("child.keepAlive", true);
     peerBootstrap.setOption("child.tcpNoDelay", true);
     peerBootstrap.setPipelineFactory(pipelineFactory);
     peerBootstrap.connect(connectToSocket);
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
private Channel connectFrom(InetSocketAddress connectToSocket, SocketAddress localAddress)
     throws InterruptedException {

     ChannelFactory channelFactory =
         new NioClientSocketChannelFactory(
                 Executors.newCachedThreadPool(),
                 Executors.newCachedThreadPool());
     ChannelPipelineFactory pipelineFactory = () -> {
         ChannelPipeline pipeline = Channels.pipeline();
         pipeline.addLast("BgpPeerFrameDecoderTest",
                 peerFrameDecoder);
         pipeline.addLast("BgpPeerChannelHandlerTest",
                 peerChannelHandler);
         return pipeline;
     };

     peerBootstrap = new ClientBootstrap(channelFactory);
     peerBootstrap.setOption("child.keepAlive", true);
     peerBootstrap.setOption("child.tcpNoDelay", true);
     peerBootstrap.setPipelineFactory(pipelineFactory);
     Channel channel = peerBootstrap.connect(connectToSocket, localAddress).getChannel();
     return channel;
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
public static void main(String[] args) {
    String hostname = "127.0.0.1";
    int port = 5044;
    if (args.length >= 2) {
        hostname = args[0];
        port = firstNonNull(Ints.tryParse(args[1]), 5044);
    }
    if (args.length >= 1) {
        port = firstNonNull(Ints.tryParse(args[1]), 5044);
    }

    final ChannelFactory factory =
            new NioServerSocketChannelFactory(
                    Executors.newCachedThreadPool(),
                    Executors.newCachedThreadPool());
    final ServerBootstrap b = new ServerBootstrap(factory);
    b.getPipeline().addLast("beats-frame-decoder", new BeatsFrameDecoder());
    b.getPipeline().addLast("beats-codec", new BeatsCodecHandler());
    b.getPipeline().addLast("logging", new LoggingHandler());
    System.out.println("Starting listener on " + hostname + ":" + port);
    b.bind(new InetSocketAddress(hostname, port));
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
@Override
protected void doOpen() throws Throwable {
    NettyHelper.setNettyLoggerFactory();
    //设置线程池(但是线程池中的线程都是守护线程，为的就是当JVM退出时候不用考虑守护线程是否已经结束)
    ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
    ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
    ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
    bootstrap = new ServerBootstrap(channelFactory); //Netty启动类
    //定义NettyHandler(这个应该是通用的Handler，只有在服务启动的时候生效一次)
    final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
    channels = nettyHandler.getChannels();
    bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
        public ChannelPipeline getPipeline() {
            NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec() ,getUrl(), NettyServer.this);
            ChannelPipeline pipeline = Channels.pipeline();

            pipeline.addLast("decoder", adapter.getDecoder()); //增加解码处理器
            pipeline.addLast("encoder", adapter.getEncoder()); //增加编码处理器
            pipeline.addLast("handler", nettyHandler); //增加具体操作的处理器
            return pipeline;
        }
    });
    // bind
    channel = bootstrap.bind(getBindAddress());
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
@Override
public void doOpen() throws Throwable {
    ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", false));
       ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
       int ioThread = conf.getInt(Constants.IO_THREADS,Constants.DEFAULT_IO_THREADS);
       ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, ioThread);
       bootstrap = new ServerBootstrap(channelFactory);
       
       final NettyHandler nettyHandler = new NettyHandler(getConf(), this);
       channels = nettyHandler.getChannels();
       bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
           public ChannelPipeline getPipeline() {
               NettyCodecAdapter adapter = new NettyCodecAdapter(conf,getCodec(), NettyServer.this);
               ChannelPipeline pipeline = Channels.pipeline();
               pipeline.addLast("decoder", adapter.getDecoder());
               pipeline.addLast("encoder", adapter.getEncoder());
               pipeline.addLast("handler", nettyHandler);
               return pipeline;
           }
       });
       // bind
       channel = bootstrap.bind(getBindAddress());
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
NettyClientAsync(Map storm_conf, ChannelFactory factory, ScheduledExecutorService scheduler, String host, int port, ReconnectRunnable reconnector) {
    super(storm_conf, factory, scheduler, host, port, reconnector);

    BATCH_THREASHOLD_WARN = ConfigExtension.getNettyBufferThresholdSize(storm_conf);
    blockSend = isBlockSend(storm_conf);
    directlySend = isDirectSend(storm_conf);

    flush_later = new AtomicBoolean(false);
    flushCheckInterval = Utils.getInt(storm_conf.get(Config.STORM_NETTY_FLUSH_CHECK_INTERVAL_MS), 10);

    Runnable flusher = new Runnable() {
        @Override
        public void run() {
            flush();
        }
    };
    long initialDelay = Math.min(1000, max_sleep_ms * max_retries);
    scheduler.scheduleAtFixedRate(flusher, initialDelay, flushCheckInterval, TimeUnit.MILLISECONDS);

    clientChannelFactory = factory;

    start();
    LOG.info(this.toString());
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
public void init(ChannelPipelineFactory pipeline, int workerNum) {
  ChannelFactory factory = RpcChannelFactory.createServerChannelFactory(serviceName, workerNum);

  DefaultChannelFuture.setUseDeadLockChecker(false);

  pipelineFactory = pipeline;
  bootstrap = new ServerBootstrap(factory);
  bootstrap.setPipelineFactory(pipelineFactory);
  // TODO - should be configurable
  bootstrap.setOption("reuseAddress", true);
  bootstrap.setOption("child.tcpNoDelay", true);
  bootstrap.setOption("child.keepAlive", true);
  bootstrap.setOption("child.connectTimeoutMillis", 10000);
  bootstrap.setOption("child.connectResponseTimeoutMillis", 10000);
  bootstrap.setOption("child.receiveBufferSize", 1048576 * 10);
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
public void prepare(Map stormConf, TopologyContext context,
        			final OutputCollector collector) {
	_collector = collector;
	ChannelFactory factory = new NioClientSocketChannelFactory(
									Executors.newCachedThreadPool(),
									Executors.newCachedThreadPool());
	_bootstrap = new ClientBootstrap(factory);
	
	_bootstrap.setPipelineFactory(getPipelineFactory());
	_bootstrap.setOptions(_options);
	
    ChannelFuture future = _bootstrap.connect(new InetSocketAddress(_host, _port));
    
    int connectTimeout = DEFAULT_CONNECT_TIMEOUT;
       Object connectTimeoutConfig = stormConf.get(Config.NIMBUS_TASK_LAUNCH_SECS);
       if (connectTimeoutConfig != null) {
       	connectTimeout = ((Number)connectTimeoutConfig).intValue()*1000/2;
       }
       
    future.awaitUninterruptibly(connectTimeout);
    if (!future.isSuccess()) {
    	_bootstrap.releaseExternalResources();
    	throw new RuntimeException("Could not connect to '"+_host+":"+_port, future.getCause());
    }
    _channel = future.getChannel();  
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
public static void main(String[] args) throws Exception {        

        Executor executor = Executors.newCachedThreadPool();
        ChannelFactory factory = new NioServerSocketChannelFactory(executor, executor);
        ServerBootstrap sb = new ServerBootstrap(factory);
        ClientSocketChannelFactory cf = new NioClientSocketChannelFactory(executor, executor);
        sb.setPipelineFactory(new ProxyPipelineFactory(cf,
                RtmpConfig.PROXY_REMOTE_HOST, RtmpConfig.PROXY_REMOTE_PORT));
        InetSocketAddress socketAddress = new InetSocketAddress(RtmpConfig.PROXY_PORT);
        sb.bind(socketAddress);
        logger.info("proxy server started, listening on {}", socketAddress);

        Thread monitor = new StopMonitor(RtmpConfig.PROXY_STOP_PORT);
        monitor.start();
        monitor.join();

        ChannelGroupFuture future = ALL_CHANNELS.close();
        logger.info("closing channels");
        future.awaitUninterruptibly();
        logger.info("releasing resources");
        factory.releaseExternalResources();
        logger.info("server stopped");

    }
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
private void addNewSwitch(DummySwitch dummySwitch) {
	final SwitchChannelHandler switchHandler = new SwitchChannelHandler(coreConnector, aggreedVersion, moduleName);
	switchHandler.setDummySwitch(dummySwitch); // CONTAINS ALL THE INFO
												// ABOUT THIS SWITCH
	ChannelFactory factory = new NioClientSocketChannelFactory(Executors.newCachedThreadPool(),
			Executors.newCachedThreadPool());
	ClientBootstrap bootstrap = new ClientBootstrap(factory);
	bootstrap.setOption("tcpNoDelay", true);
	bootstrap.setOption("keepAlive", true);
	bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
		@Override
		public ChannelPipeline getPipeline() {
			return Channels.pipeline(switchHandler);
		}
	});

	// CONNECT AND ADD TO HASHMAP OF MANAGED SWITCHES
	ChannelFuture future = bootstrap.connect(new InetSocketAddress("localhost", 7753));
	managedSwitchesChannel.put(dummySwitch.getDatapathId(), future);
	managedBootstraps.put(dummySwitch.getDatapathId(), bootstrap);
	managedSwitches.put(dummySwitch.getDatapathId(), dummySwitch);
	switchHandler.registerSwitchConnection(future);
	switchHandler.setModuleHandler(moduleHandler);

}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
	//ADD SWITCH LISTENERS
	floodlightProvider.addOFSwitchListener(this);
	
	//REGISTER FOR MESSAGES FROM THE SWITCHES
	floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
	floodlightProvider.addOFMessageListener(OFType.PACKET_OUT, this);
	floodlightProvider.addOFMessageListener(OFType.FLOW_MOD, this);
       floodlightProvider.addOFMessageListener(OFType.ERROR, this);
       

       //START UP THE SERVER FOR THE ODL-SHIM
       ChannelFactory serverFactory = new NioServerSocketChannelFactory(
                    Executors.newCachedThreadPool(),
                    Executors.newCachedThreadPool());

       ServerBootstrap serverBootstrap = new ServerBootstrap(serverFactory);
       serverBootstrap.setOption("child.tcpNoDelay", true);
       serverBootstrap.setOption("child.keepAlive", true);
       serverBootstrap.setPipelineFactory(new NetIdePipelineFactory());
       logger.info("NetIDE Module binding to 41414..." );
       serverBootstrap.bind(new InetSocketAddress(41414)); //TODO: REMOVE HARD CODING
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
/**
 * Creates the comms channel to the SDN Controller and then adds a 
 * fake switch for the controller to manage
 * @param dummySwitch the switch to be managed
 */
private void addNewSwitch(DummySwitch dummySwitch) {
	final SwitchChannelHandler switchHandler = new SwitchChannelHandler();
	switchHandler.setDummySwitch(dummySwitch); //CONTAINS ALL THE INFO ABOUT THIS SWITCH
	switchHandler.setShimChannel(this.channel);
	
	
	ChannelFactory factory = new NioClientSocketChannelFactory(
                  Executors.newCachedThreadPool(),
                  Executors.newCachedThreadPool());
    ClientBootstrap bootstrap = new ClientBootstrap(factory);
    bootstrap.setOption("tcpNoDelay", true);
    bootstrap.setOption("keepAlive", true);
    bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
        public ChannelPipeline getPipeline() {
            return Channels.pipeline(switchHandler);
        }
    });
    //CONNECT AND ADD TO HASHMAP OF MANAGED SWITCHES
    ChannelFuture future = bootstrap.connect(new InetSocketAddress("localhost", 6634));
    managedSwitches.put(dummySwitch.getId(), future);
    managedBootstraps.put(dummySwitch.getId(), bootstrap);
    switchHandler.setControllerChannel(future);
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
/**
 * Initialises the server.
 * 
 * @param releaseClassName The class name of the current active {@link Release}.
 * @throws ClassNotFoundException If the release class could not be found.
 * @throws IllegalAccessException If the release class could not be accessed.
 * @throws InstantiationException If the release class could not be instantiated.
 */
public void init(String releaseClassName) throws ClassNotFoundException, InstantiationException,
		IllegalAccessException {
	Class<?> clazz = Class.forName(releaseClassName);
	Release release = (Release) clazz.newInstance();

	logger.info("Initialized release #" + release.getReleaseNumber() + ".");

	ChannelFactory factory = new NioServerSocketChannelFactory(networkExecutor, networkExecutor);
	serviceBootstrap.setFactory(factory);
	httpBootstrap.setFactory(factory);
	jagGrabBootstrap.setFactory(factory);

	context = new ServerContext(release, serviceManager);
	ApolloHandler handler = new ApolloHandler(context);

	ChannelPipelineFactory servicePipelineFactory = new ServicePipelineFactory(handler, timer);
	serviceBootstrap.setPipelineFactory(servicePipelineFactory);

	ChannelPipelineFactory httpPipelineFactory = new HttpPipelineFactory(handler, timer);
	httpBootstrap.setPipelineFactory(httpPipelineFactory);

	ChannelPipelineFactory jagGrabPipelineFactory = new JagGrabPipelineFactory(handler, timer);
	jagGrabBootstrap.setPipelineFactory(jagGrabPipelineFactory);
}
 

import org.jboss.netty.channel.ChannelFactory; //导入依赖的package包/类
/**
 * Creates a new channel to given host and port.<br>
 *
 * @param host
 * @param port
 * @return
 * @throws Exception
 */
private Channel createChannel(String host, int port) throws Exception {
    // Important notice; use NioClientSocketChannelFactory instead
    // of NioServerSocketChannelFactory
    ChannelFactory channelFactory = new NioClientSocketChannelFactory(
            Executors.newCachedThreadPool(),
            Executors.newCachedThreadPool());
    ClientBootstrap bootstrap = new ClientBootstrap(channelFactory);
    //bootstrap.setPipelineFactory(new SipClientPipelineFactory(false,false));
    bootstrap.setPipelineFactory(new SipPipelineFactory(sipServerHandler));
    ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));

    // open / connect to channel
    Channel c = future.await().getChannel();
    if (!future.isSuccess()) {
        log.warn(String.format("createChannel. Establishing connection failed[%s]",
                future.getCause().getMessage()));
        bootstrap.releaseExternalResources();
    }
    return c;
}