import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
@Override
public void init(SocketWrapper<Long> socketWrapper,
        AbstractEndpoint<Long> endpoint) throws IOException {

    socket = socketWrapper.getSocket().longValue();
    Socket.setsbb(this.socket, bbuf);
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
@Override
protected Processor<Long> createUpgradeProcessor(
        SocketWrapper<Long> socket,
        HttpUpgradeHandler httpUpgradeProcessor)
        throws IOException {
    return new AprProcessor(socket, httpUpgradeProcessor,
            (AprEndpoint) proto.endpoint,
            proto.getUpgradeAsyncWriteBufferSize());
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
@Override
protected void setCometTimeouts(SocketWrapper<NioChannel> socketWrapper) {
	// Comet support
	SelectionKey key = socketWrapper.getSocket().getIOChannel()
			.keyFor(socketWrapper.getSocket().getPoller().getSelector());
	if (key != null) {
		NioEndpoint.KeyAttachment attach = (NioEndpoint.KeyAttachment) key.attachment();
		if (attach != null) {
			attach.setComet(comet);
			if (comet) {
				Integer comettimeout = (Integer) request
						.getAttribute(org.apache.coyote.Constants.COMET_TIMEOUT_ATTR);
				if (comettimeout != null) {
					attach.setTimeout(comettimeout.longValue());
				}
			}
		}
	}
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * @deprecated  Will be removed in Tomcat 8.0.x.
 */
@Deprecated
@Override
protected P createUpgradeProcessor(SocketWrapper<S> socket,
        org.apache.coyote.http11.upgrade.UpgradeInbound inbound) {
    // TODO should fail - throw IOE
    return null;
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public BioProcessor(SocketWrapper<Socket> wrapper, HttpUpgradeHandler httpUpgradeProcessor,
		int asyncWriteBufferSize) throws IOException {
	super(httpUpgradeProcessor, new BioServletInputStream(wrapper),
			new BioServletOutputStream(wrapper, asyncWriteBufferSize));

	wrapper.getSocket().setSoTimeout(INFINITE_TIMEOUT);
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * Expected to be used by the handler once the processor is no longer
 * required.
 */
@Override
public void release(SocketWrapper<NioChannel> socket,
        Processor<NioChannel> processor, boolean isSocketClosing,
        boolean addToPoller) {
    processor.recycle(isSocketClosing);
    recycledProcessors.offer(processor);
    if (addToPoller) {
        // The only time this method is called with addToPoller == true
        // is when the socket is in keep-alive so set the appropriate
        // timeout.
        socket.setTimeout(getProtocol().getKeepAliveTimeout());
        socket.getSocket().getPoller().add(socket.getSocket());
    }
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * Expected to be used by the handler once the processor is no longer
 * required.
 */
@Override
public void release(SocketWrapper<Long> socket,
        Processor<Long> processor, boolean isSocketClosing,
        boolean addToPoller) {
    processor.recycle(isSocketClosing);
    recycledProcessors.offer(processor);
    if (addToPoller) {
        ((AprEndpoint)proto.endpoint).getPoller().add(
                socket.getSocket().longValue(),
                proto.endpoint.getKeepAliveTimeout(),
                true, false);
    }
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public AprProcessor(SocketWrapper<Long> wrapper, HttpUpgradeHandler httpUpgradeProcessor, AprEndpoint endpoint,
		int asyncWriteBufferSize) {
	super(httpUpgradeProcessor, new AprServletInputStream(wrapper),
			new AprServletOutputStream(wrapper, asyncWriteBufferSize, endpoint));

	Socket.timeoutSet(wrapper.getSocket().longValue(), INFINITE_TIMEOUT);
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * Expected to be used by the handler once the processor is no longer
 * required.
 */
@Override
public void release(SocketWrapper<NioChannel> socket, Processor<NioChannel> processor, boolean isSocketClosing,
		boolean addToPoller) {
	processor.recycle(isSocketClosing);
	recycledProcessors.offer(processor);
	if (addToPoller) {
		// The only time this method is called with addToPoller == true
		// is when the socket is in keep-alive so set the appropriate
		// timeout.
		socket.setTimeout(getProtocol().getKeepAliveTimeout());
		socket.getSocket().getPoller().add(socket.getSocket());
	}
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public UpgradeNioProcessor(SocketWrapper<NioChannel> wrapper, UpgradeInbound upgradeInbound, NioSelectorPool pool) {
	super(upgradeInbound);

	wrapper.setTimeout(upgradeInbound.getReadTimeout());

	this.nioChannel = wrapper.getSocket();
	this.pool = pool;
	this.maxRead = nioChannel.getBufHandler().getReadBuffer().capacity();
	this.maxWrite = nioChannel.getBufHandler().getWriteBuffer().capacity();
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public UpgradeAprProcessor(SocketWrapper<Long> wrapper,
        UpgradeInbound upgradeInbound) {
    super(upgradeInbound);

    Socket.timeoutSet(wrapper.getSocket().longValue(),
            upgradeInbound.getReadTimeout());

    this.socket = wrapper.getSocket().longValue();
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public UpgradeBioProcessor(SocketWrapper<Socket> wrapper, UpgradeInbound upgradeInbound) throws IOException {
	super(upgradeInbound);

	int timeout = upgradeInbound.getReadTimeout();
	if (timeout < 0) {
		timeout = 0;
	}
	wrapper.getSocket().setSoTimeout(timeout);

	this.inputStream = wrapper.getSocket().getInputStream();
	this.outputStream = wrapper.getSocket().getOutputStream();
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public AprServletOutputStream(SocketWrapper<Long> wrapper,
        int asyncWriteBufferSize, AprEndpoint endpoint) {
    super(asyncWriteBufferSize);
    this.endpoint = endpoint;
    this.wrapper = wrapper;
    this.socket = wrapper.getSocket().longValue();
    if (endpoint.isSSLEnabled()) {
        sslOutputBuffer = ByteBuffer.allocateDirect(SSL_OUTPUT_BUFFER_SIZE);
        sslOutputBuffer.position(SSL_OUTPUT_BUFFER_SIZE);
    } else {
        sslOutputBuffer = null;
    }
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
public UpgradeBioProcessor(SocketWrapper<Socket> wrapper,
        UpgradeInbound upgradeInbound) throws IOException {
    super(upgradeInbound);

    int timeout = upgradeInbound.getReadTimeout();
    if (timeout < 0) {
        timeout = 0;
    }
    wrapper.getSocket().setSoTimeout(timeout);

    this.inputStream = wrapper.getSocket().getInputStream();
    this.outputStream = wrapper.getSocket().getOutputStream();
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * Expected to be used by the Poller to release resources on socket
 * close, errors etc.
 */
@Override
public void release(SocketWrapper<NioChannel> socket) {
    Processor<NioChannel> processor =
        connections.remove(socket.getSocket());
    if (processor != null) {
        processor.recycle(true);
        if (!processor.isUpgrade()) {
            recycledProcessors.offer(processor);
        }
    }
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
@Override
protected void init(SocketWrapper<NioChannel> socketWrapper,
        AbstractEndpoint<NioChannel> endpoint) throws IOException {

    socket = socketWrapper.getSocket();
    socketReadBufferSize =
        socket.getBufHandler().getReadBuffer().capacity();

    int bufLength = headerBufferSize + socketReadBufferSize;
    if (buf == null || buf.length < bufLength) {
        buf = new byte[bufLength];
    }

    pool = ((NioEndpoint)endpoint).getSelectorPool();
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * Expected to be used by the handler once the processor is no longer
 * required.
 *
 * @param socket
 * @param processor
 * @param isSocketClosing
 *            Not used in HTTP
 * @param addToPoller
 */
@Override
public void release(SocketWrapper<NioChannel> socket, Processor<NioChannel> processor, boolean isSocketClosing,
		boolean addToPoller) {
	processor.recycle(isSocketClosing);
	recycledProcessors.offer(processor);
	if (addToPoller) {
		// The only time this method is called with addToPoller == true
		// is when the socket is in keep-alive so set the appropriate
		// timeout.
		socket.setTimeout(getProtocol().getKeepAliveTimeout());
		socket.getSocket().getPoller().add(socket.getSocket());
	}
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
@Override
protected void init(SocketWrapper<Long> socketWrapper, AbstractEndpoint<Long> endpoint) throws IOException {

	wrapper = socketWrapper;
	socket = socketWrapper.getSocket().longValue();
	Socket.setrbb(this.socket, bbuf);
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
/**
 * @deprecated Will be removed in Tomcat 8.0.x.
 */
@Deprecated
@Override
protected Processor<Socket> createUpgradeProcessor(SocketWrapper<Socket> socket,
		org.apache.coyote.http11.upgrade.UpgradeInbound inbound) throws IOException {
	return new org.apache.coyote.http11.upgrade.UpgradeBioProcessor(socket, inbound);
}
 

import org.apache.tomcat.util.net.SocketWrapper; //导入依赖的package包/类
@Override
public void init(SocketWrapper<NioChannel> socketWrapper, AbstractEndpoint<NioChannel> endpoint)
		throws IOException {

	socket = socketWrapper.getSocket();
	pool = ((NioEndpoint) endpoint).getSelectorPool();
}