Java FilterChainBuilder.add方法代码示例

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
@Override
protected void doOpen() throws Throwable {
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new GrizzlyCodecAdapter(getCodec(), getUrl(), this));
    filterChainBuilder.add(new GrizzlyHandler(getUrl(), this));
    TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance();
    ThreadPoolConfig config = builder.getWorkerThreadPoolConfig(); 
    config.setPoolName(CLIENT_THREAD_POOL_NAME)
            .setQueueLimit(-1)
            .setCorePoolSize(0)
            .setMaxPoolSize(Integer.MAX_VALUE)
            .setKeepAliveTime(60L, TimeUnit.SECONDS);
    builder.setTcpNoDelay(true).setKeepAlive(true)
            .setConnectionTimeout(getTimeout())
            .setIOStrategy(SameThreadIOStrategy.getInstance());
    transport = builder.build();
    transport.setProcessor(filterChainBuilder.build());
    transport.start();
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
public void start(int listenPort, ExecutorService threadpool) throws Exception {
  ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) threadpool;
  ThreadPoolConfig config = ThreadPoolConfig.defaultConfig().copy().setCorePoolSize(threadPoolExecutor.getCorePoolSize())
      .setMaxPoolSize(threadPoolExecutor.getMaximumPoolSize()).setPoolName("GRIZZLY-SERVER");
  ExecutorService executorService = GrizzlyExecutorService.createInstance(config);

  FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
  filterChainBuilder.add(new TransportFilter());
  filterChainBuilder.add(new GrizzlyProtocolFilter());
  filterChainBuilder.add(new GrizzlyServerHandler(executorService));
  TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance();
  builder.setOptimizedForMultiplexing(true);
  builder.setIOStrategy(SameThreadIOStrategy.getInstance());

  transport = builder.build();

  transport.setProcessor(filterChainBuilder.build());
  transport.bind(listenPort);

  transport.start();
  LOGGER.warn("server started,listen at: " + listenPort);
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
public void start() throws IOException {
    // Create TCP transport
    transport = TCPNIOTransportBuilder.newInstance().build();

    // Create a FilterChain using FilterChainBuilder
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    // Add TransportFilter, which is responsible
    // for reading and writing data to the connection
    filterChainBuilder.add(new TransportFilter());
    // filterChainBuilder.add(new ClientEncodeFilter());
    filterChainBuilder.add(new TunnelRedirectServerFilter(
            TCPNIOConnectorHandler.builder(transport).build(), targetHost,
            targetPort));
    transport.setProcessor(filterChainBuilder.build());
    // transport.setReadBufferSize(512);
    // Set async write queue size limit
    // transport.getAsyncQueueIO().getWriter()
    // .setMaxPendingBytesPerConnection(10240 * 10240);
    // binding transport to start listen on certain host and port
    transport.bind(localHost, localPort);
    // start the transport
    transport.start();
    logger.info("Press any key to stop the server...");
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
@Override
protected void doOpen() throws Throwable {
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new GrizzlyCodecAdapter(getCodec(), getUrl(), this));
    filterChainBuilder.add(new GrizzlyHandler(getUrl(), this));
    TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance();
    ThreadPoolConfig config = builder.getWorkerThreadPoolConfig();
    config.setPoolName(CLIENT_THREAD_POOL_NAME)
            .setQueueLimit(-1)
            .setCorePoolSize(0)
            .setMaxPoolSize(Integer.MAX_VALUE)
            .setKeepAliveTime(60L, TimeUnit.SECONDS);
    builder.setTcpNoDelay(true).setKeepAlive(true)
            .setConnectionTimeout(getTimeout())
            .setIOStrategy(SameThreadIOStrategy.getInstance());
    transport = builder.build();
    transport.setProcessor(filterChainBuilder.build());
    transport.start();
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
protected Client createClient(String targetIP, int targetPort, int connectTimeout, String key) throws Exception {
  Connection connection = null;
  GrizzlyClientHandler handler = new GrizzlyClientHandler();
  FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
  filterChainBuilder.add(new TransportFilter());
  filterChainBuilder.add(new GrizzlyProtocolFilter());
  filterChainBuilder.add(handler);

  final TCPNIOTransportBuilder transportBuilder = TCPNIOTransportBuilder.newInstance();
  transportBuilder.setOptimizedForMultiplexing(true);

  transportBuilder.setIOStrategy(SameThreadIOStrategy.getInstance());

  final TCPNIOTransport transport = transportBuilder.build();
  transport.setTcpNoDelay(Boolean.parseBoolean(System.getProperty("nfs.rpc.tcp.nodelay", "true")));

  transport.setProcessor(filterChainBuilder.build());

  transport.start();
  Future<Connection> future = transport.connect(targetIP, targetPort);
  if (connectTimeout < 1000) {
    connectTimeout = 1000;
  }
  connection = future.get(connectTimeout, TimeUnit.MILLISECONDS);
  @SuppressWarnings("unchecked")
  GrizzlyClient client = new GrizzlyClient(targetIP, targetPort, connectTimeout, connection, key);
  handler.setClient(client);
  return client;
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
@Override
public void setup(NetworkListener networkListener, FilterChainBuilder builder) {
    // Get the index of HttpServerFilter in the HttpServer filter chain
    final int httpServerFilterIdx = builder.indexOfType(HttpServerFilter.class);

    if (httpServerFilterIdx >= 0) {
        // Insert the WebSocketFilter right before HttpServerFilter
        builder.add(httpServerFilterIdx, new GrizzlyServerFilter(container, contextPath));
    }
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
public static TCPClient start(String host, int port, BaseFilter coder, BaseFilter clientFilter) {
    TCPClient client = new TCPClient( host, port);
    client.clientFilter = clientFilter;
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    // Add TransportFilter, which is responsible
    // for reading and writing data to the connection
    filterChainBuilder.add(new TransportFilter());

    // StringFilter is responsible for Buffer <-> String conversion
    filterChainBuilder.add(coder);

    // EchoFilter is responsible for echoing received messages
    filterChainBuilder.add(clientFilter);

    // Create TCP transport
    client.transport = TCPNIOTransportBuilder.newInstance().build();

    client.transport.setProcessor(filterChainBuilder.build());

    try {
        // binding transport to start listen on certain host and port
        try {
            client.transport.start();
            // perform async. connect to the server
            Future<Connection> future = client.transport.connect(client.host, client.port);
            // wait for connect operation to complete
            client.connection = future.get(5, TimeUnit.SECONDS);
            if ( client.connection.isOpen())
                return client;
            else
                throw new ConnectionException("can not connect to "+client.toString());
            //System.in.read();
        } catch (Exception e) {
            //shutdown transport thread
            if ( client.transport != null )
                client.transport.shutdown();
            throw new RuntimeException( e.getMessage(), e);
        }

    } finally {

    }
}
 

import org.glassfish.grizzly.filterchain.FilterChainBuilder; //导入方法依赖的package包/类
@Override
public void setup(NetworkListener listener, FilterChainBuilder builder) {
	int index = builder.indexOfType(HttpServerFilter.class);
	index = index < 0 ? 0 : index;
	builder.add(index, this);
}