Java ByteBufferSlicePool类代码示例

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
protected PathHandler mountServerEndpoints(final PathHandler pathHandler , List<Class<?>> serverEndpoints) throws ServletException{
  if(!serverEndpoints.isEmpty()){
    DeploymentInfo builder = new DeploymentInfo()
      .setClassLoader(this.getClass().getClassLoader())
      .setContextPath("/");
    WebSocketDeploymentInfo wsDeployInfo = new WebSocketDeploymentInfo();
    wsDeployInfo.setBuffers(new ByteBufferSlicePool(100, 1000));
    for(Class<?> serverEndpoint : serverEndpoints ){
      wsDeployInfo.addEndpoint( serverEndpoint );
    }
    builder.addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, wsDeployInfo );
    builder.setDeploymentName("websocketDeploy.war");
    
    final ServletContainer container = ServletContainer.Factory.newInstance();
    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    pathHandler.addPrefixPath("/", manager.start() );
  }      
  return pathHandler;
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
private static ManagementHttpServer create(Builder builder) {
    SSLContext sslContext = null;
    SslClientAuthMode sslClientAuthMode = builder.sslClientAuthMode;
    if (builder.secureBindAddress != null) {
        sslContext = getSSLContext(builder);
        if (sslContext == null) {
            throw ROOT_LOGGER.sslRequestedNoSslContext();
        }
    }

    HttpOpenListener openListener = new HttpOpenListener(new ByteBufferSlicePool(BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR, 4096, 10 * 4096));

    int secureRedirectPort = builder.secureBindAddress != null ? builder.secureBindAddress.getPort() : -1;
    // WFLY-2870 -- redirect not supported if bindAddress and secureBindAddress are using different InetAddress
    boolean redirectSupported = (builder.bindAddress == null || builder.secureBindAddress == null || builder.bindAddress.getAddress().equals(builder.secureBindAddress.getAddress()));
    if (!redirectSupported && secureRedirectPort > 0) {
        HttpServerLogger.ROOT_LOGGER.httpsRedirectNotSupported(builder.bindAddress.getAddress(), builder.secureBindAddress.getAddress());
        secureRedirectPort = -1;
    }

    final ExtensionHandlers extensionHandlers = setupOpenListener(openListener, secureRedirectPort, builder);
    return new ManagementHttpServer(openListener, builder.bindAddress, builder.secureBindAddress, sslContext, sslClientAuthMode, builder.worker, extensionHandlers);
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
public static void main(final String... args) throws Exception {
    final DeploymentManager deployment = Servlets.defaultContainer()
        .addDeployment(
            Servlets.deployment()
                .setClassLoader(UndertowContainer.class.getClassLoader())
                .setContextPath("/")
                .setDeploymentName(UndertowContainer.class.getName())
                .addServletContextAttribute(
                    WebSocketDeploymentInfo.ATTRIBUTE_NAME,
                    new WebSocketDeploymentInfo()
                        .addEndpoint(ApplicationConfig.ENDPOINT_CONFIG)
                        .setWorker(Xnio.getInstance().createWorker(OptionMap.builder().getMap()))
                        .setBuffers(new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)))
                )
        );
    deployment.deploy();
    final HttpHandler servletHandler = deployment.start();
    Undertow.builder()
        .addHttpListener(Client.PORT, Client.HOST)
        .setHandler(servletHandler)
        .build()
        .start();
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
public HttpHandler createRootHandler(Configuration configuration , ScannerResult scannerResult) {
  PathHandler pathHandler = Handlers.path();

  String appContext = "/" + configuration.getAppContext();
  pathHandler.addPrefixPath( appContext , createAppHandlers(scannerResult));
  if(!scannerResult.getServerEndpoints().isEmpty()){
    DeploymentInfo builder = new DeploymentInfo().setClassLoader(this.getClass().getClassLoader()).setContextPath("/");
    WebSocketDeploymentInfo wsDeployInfo = new WebSocketDeploymentInfo();
    wsDeployInfo.setBuffers(new ByteBufferSlicePool(100, 1000));
    for(Class<?> serverEndpoint : scannerResult.getServerEndpoints() ){
      wsDeployInfo.addEndpoint( serverEndpoint );
    }
    builder.addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, wsDeployInfo);
    builder.setDeploymentName("websocketDeploy.war");

    final ServletContainer container = ServletContainer.Factory.newInstance();
    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    try {
      OvertownSessionManager sessionManager = OvertownSessionManager.getInstance();
      String wsContextPath = "ws";
      if( !appContext.endsWith("/") ){
        wsContextPath += appContext + "/" + wsContextPath;
      }
      pathHandler.addPrefixPath( wsContextPath ,
              new SessionAttachmentHandler(  manager.start() , sessionManager.getSessionManager(),
                sessionManager.getSessionConfig()) );
    } catch (ServletException e) {
      e.printStackTrace();
    }
  }
  String staticContextPath = configuration.getStaticRootPath();
  if( !appContext.endsWith("/") ){
    staticContextPath = appContext + "/" + staticContextPath;
  }
  pathHandler.addPrefixPath( staticContextPath , new ResourceHandlerMounter().mount());
  return pathHandler;
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
private ByteBufferPool createByteBufferPool() {
    long maxMemory = Runtime.getRuntime().maxMemory();
    boolean useDirectBuffers;
    int bufferSize, buffersPerRegion;
    if (maxMemory < 64 * 1024 * 1024) {
        //smaller than 64mb of ram we use 512b buffers
        useDirectBuffers = false;
        bufferSize = 512;
        buffersPerRegion = 10;
    } else if (maxMemory < 128 * 1024 * 1024) {
        //use 1k buffers
        useDirectBuffers = true;
        bufferSize = 1024;
        buffersPerRegion = 10;
    } else {
        //use 16k buffers for best performance
        //as 16k is generally the max amount of data that can be sent in a single write() call
        useDirectBuffers = true;
        bufferSize = 1024 * 16;
        buffersPerRegion = 20;
    }
    BufferAllocator<ByteBuffer> allocator;
    if (useDirectBuffers) {
        allocator = BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR;
    } else {
        allocator = BufferAllocator.BYTE_BUFFER_ALLOCATOR;
    }
    int maxRegionSize = buffersPerRegion * bufferSize;
    ByteBufferSlicePool pool = new ByteBufferSlicePool(allocator, bufferSize, maxRegionSize);
    return new XnioByteBufferPool(pool);
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
private void upgradeConnection(ClientExchange result) throws IOException {
    if (result.getResponse().getResponseCode() == 101) {
        // flush response
        new StringReadChannelListener(bufferPool) {
            @Override
            protected void stringDone(String string) {
            }

            @Override
            protected void error(IOException e) {
            }
        }.setup(result.getResponseChannel());

        // Create the upgraded SPDY connection
        ByteBufferPool heapBufferPool =
            new XnioByteBufferPool(new ByteBufferSlicePool(BufferAllocator.BYTE_BUFFER_ALLOCATOR, 8196, 8196));
        SpdyChannel spdyChannel =
            new SpdyChannelWithoutFlowControl(connection.performUpgrade(), bufferPool, null, heapBufferPool, true,
                OptionMap.EMPTY);
        Integer idleTimeout = DEFAULT_OPTIONS.get(UndertowOptions.IDLE_TIMEOUT);
        if (idleTimeout != null && idleTimeout > 0) {
            spdyChannel.setIdleTimeout(idleTimeout);
        }
        connection = new SpdyClientConnection(spdyChannel, null);
    } else {
        throw new IOException("Failed to upgrade connection");
    }
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    final OptionMap options = OptionMap.builder()
            .set(WORKER_IO_THREADS, 8)
            .set(TCP_NODELAY, true)
            .set(KEEP_ALIVE, true)
            .set(WORKER_NAME, "Client")
            .getMap();
    final Xnio xnio = Xnio.getInstance();
    final XnioWorker worker = xnio.createWorker(null, options);
    final UndertowClient client = UndertowClient.getInstance();

    final URI serverAddress = new URI(SERVER_URL);
    final ClientConnection connection = client.connect(serverAddress, worker, new ByteBufferSlicePool(1024, 1024), EMPTY).get();

    final CountDownLatch latch = new CountDownLatch(1);

    try {
        connection.getIoThread().execute(new Runnable() {
            @Override
            public void run() {
                final ClientRequest request = new ClientRequest().setMethod(GET).setPath("/");
                request.getRequestHeaders().add(UPGRADE, HORNETQ_REMOTING);
                String secretKey = HandshakeUtil.createSecretKey();
                request.getRequestHeaders().add(HttpString.tryFromString(HandshakeUtil.SEC_HORNETQ_REMOTING_KEY), secretKey);
                connection.sendRequest(request, createClientCallback(latch, secretKey));
            }
        });
        latch.await(10, TimeUnit.MINUTES);
        if (connection.isUpgraded()) {
            StreamConnection streamConnection = connection.performUpgrade();
            switchToHornetQProtocol(streamConnection);
        }
    } finally {
        IoUtils.safeClose(connection);
        worker.shutdown();
    }
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
static Pooled<ByteBuffer> allocateDirect(ByteBufferSlicePool pool, int initialCapacity) {
    Pooled<ByteBuffer> pooled;
    if (initialCapacity <= pool.getBufferSize()) {
        pooled = pool.allocate();
    } else {
        pooled = new PooledByteBuf(ByteBuffer.allocateDirect(initialCapacity));
    }
    return pooled;
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
public static void main(final String... args) throws Exception {
    final DeploymentManager deployment = Servlets.defaultContainer()
        .addDeployment(
            Servlets.deployment()
                .setClassLoader(AsyncWsConnectionTest.class.getClassLoader())
                .setContextPath("/")
                .setDeploymentName(AsyncWsConnectionTest.class.getName())
                .addServletContextAttribute(
                    WebSocketDeploymentInfo.ATTRIBUTE_NAME,
                    new WebSocketDeploymentInfo()
                        .addEndpoint(serverEndpointConfig())
                        .setWorker(Xnio.getInstance().createWorker(OptionMap.builder().getMap()))
                        .setBuffers(new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)))
                )
        );
    deployment.deploy();
    Undertow.builder()
        .addHttpListener(PORT, HOST)
        .setHandler(deployment.start())
        .build()
        .start();
    TimeUnit.SECONDS.sleep(1);
    if (true) {
        client(new ServerWebSocketContainer(
            DefaultClassIntrospector.INSTANCE,
            Xnio.getInstance().createWorker(OptionMap.create(Options.THREAD_DAEMON, true)),
            new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)),
            List.of(new ContextClassLoaderSetupAction(ClassLoader.getSystemClassLoader())),
            true,
            true
        ));
    } else {
        final ClientContainer container = new ClientContainer(); // $note: setSendTimeout not yet implemented in Jetty
        container.start();
        client(container);
    }
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
protected static void run(final CountDownLatch latch) throws Exception {
    final Xnio xnio = Xnio.getInstance();
    final DeploymentManager deployment = Servlets.defaultContainer()
        .addDeployment(
            Servlets.deployment()
                .setClassLoader(UndertowTest.class.getClassLoader())
                .setContextPath("/")
                .setDeploymentName(UndertowTest.class.getName())
                .addServletContextAttribute(
                    WebSocketDeploymentInfo.ATTRIBUTE_NAME,
                    new WebSocketDeploymentInfo()
                        .addEndpoint(serverEndpointConfig())
                        .setWorker(xnio.createWorker(OptionMap.builder().getMap()))
                        .setBuffers(new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)))
                )
        );
    deployment.deploy();
    final Undertow server = Undertow.builder()
        .addHttpListener(PORT, "localhost")
        .setHandler(deployment.start())
        .build();
    server.start();
    connect(
        new ServerWebSocketContainer(
            DefaultClassIntrospector.INSTANCE,
            xnio.createWorker(OptionMap.create(Options.THREAD_DAEMON, true)),
            new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)),
            List.of(new ContextClassLoaderSetupAction(ClassLoader.getSystemClassLoader())),
            true,
            true
        ),
        latch
    );
    server.stop();
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
public static void main(final String... args) throws Exception {
    final DeploymentManager deployment = Servlets.defaultContainer()
        .addDeployment(
            Servlets.deployment()
                .setClassLoader(UndertowAcceptor.class.getClassLoader())
                .setContextPath("/")
                .setDeploymentName(UndertowAcceptor.class.getName())
                .addServlet(
                    Servlets.servlet("Xhr", XhrServlet.class)
                        .addMapping(XHR_PATH)
                )
                .addServletContextAttribute(
                    WebSocketDeploymentInfo.ATTRIBUTE_NAME,
                    new WebSocketDeploymentInfo()
                        .addEndpoint(ENDPOINT_CONFIG)
                        .setWorker(Xnio.getInstance().createWorker(OptionMap.builder().getMap()))
                        .setBuffers(new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)))
                )
        );
    deployment.deploy();
    final HttpHandler servletHandler = deployment.start();
    final HttpHandler fileHandler = Handlers.resource(new FileResourceManager(new File(WEB_PATH), 100));
    Undertow.builder()
        .addHttpListener(PORT, HOST)
        .addHttpsListener(PORT + 1, HOST, SslConfig.SERVER.context) // $note: we don't know how to force client authentication
        .setHandler(exchange -> {
            final String path = exchange.getRequestPath();
            if (WS_PATH.equals(path) || XHR_PATH.equals(path)) {
                servletHandler.handleRequest(exchange);
            } else {
                fileHandler.handleRequest(exchange);
            }
        })
        .build()
        .start();
    System.out.println("started");
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
public static void main(final String... args) throws Exception {
    run(new ServerWebSocketContainer(
        DefaultClassIntrospector.INSTANCE,
        Xnio.getInstance().createWorker(OptionMap.create(Options.THREAD_DAEMON, true)),
        new XnioByteBufferPool(new ByteBufferSlicePool(1024, 10240)),
        List.of(new ContextClassLoaderSetupAction(ClassLoader.getSystemClassLoader())),
        true,
        true
    ));
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
@Override
public void dispatchMockRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException {

    final ByteBufferSlicePool bufferPool = new ByteBufferSlicePool(BufferAllocator.BYTE_BUFFER_ALLOCATOR, 1024, 1024);
    MockServerConnection connection = new MockServerConnection(bufferPool);
    HttpServerExchange exchange = new HttpServerExchange(connection);
    exchange.setRequestScheme(request.getScheme());
    exchange.setRequestMethod(new HttpString(request.getMethod()));
    exchange.setProtocol(Protocols.HTTP_1_0);
    exchange.setResolvedPath(request.getContextPath());
    String relative;
    if (request.getPathInfo() == null) {
        relative = request.getServletPath();
    } else {
        relative = request.getServletPath() + request.getPathInfo();
    }
    exchange.setRelativePath(relative);
    final ServletPathMatch info = paths.getServletHandlerByPath(request.getServletPath());
    final HttpServletResponseImpl oResponse = new HttpServletResponseImpl(exchange, servletContext);
    final HttpServletRequestImpl oRequest = new HttpServletRequestImpl(exchange, servletContext);
    final ServletRequestContext servletRequestContext = new ServletRequestContext(servletContext.getDeployment(), oRequest, oResponse, info);
    servletRequestContext.setServletRequest(request);
    servletRequestContext.setServletResponse(response);
    //set the max request size if applicable
    if (info.getServletChain().getManagedServlet().getMaxRequestSize() > 0) {
        exchange.setMaxEntitySize(info.getServletChain().getManagedServlet().getMaxRequestSize());
    }
    exchange.putAttachment(ServletRequestContext.ATTACHMENT_KEY, servletRequestContext);

    exchange.startBlocking(new ServletBlockingHttpExchange(exchange));
    servletRequestContext.setServletPathMatch(info);

    try {
        dispatchRequest(exchange, servletRequestContext, info.getServletChain(), DispatcherType.REQUEST);
    } catch (Exception e) {
        if (e instanceof RuntimeException) {
            throw (RuntimeException) e;
        }
        throw new ServletException(e);
    }
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
private static SpdyClientConnection createSpdyChannel(StreamConnection connection, Pool<ByteBuffer> bufferPool) {
    SpdyChannel spdyChannel = new SpdyChannel(connection, bufferPool, null, new ByteBufferSlicePool(BufferAllocator.BYTE_BUFFER_ALLOCATOR, 8192, 8192), true);
    return new SpdyClientConnection(spdyChannel);
}
 

import org.xnio.ByteBufferSlicePool; //导入依赖的package包/类
@Override
public void start(StartContext context) throws StartException {
    bufferPool = new ByteBufferSlicePool(directBuffers ? BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR : BufferAllocator.BYTE_BUFFER_ALLOCATOR, bufferSize, buffersPerSlice * bufferSize);
}