public interface Lifecycle {
    String START_EVENT = "start";
    String BEFORE_START_EVENT = "before_start";
    String AFTER_START_EVENT = "after_start";
    String STOP_EVENT = "stop";
    String BEFORE_STOP_EVENT = "before_stop";
    String AFTER_STOP_EVENT = "after_stop";

    void addLifecycleListener(LifecycleListener var1);

    LifecycleListener[] findLifecycleListeners();

    void removeLifecycleListener(LifecycleListener var1);

    void start() throws LifecycleException;

    void stop() throws LifecycleException;
}

public final class LifecycleEvent extends EventObject {

    public LifecycleEvent(Lifecycle lifecycle, String type) {
        this(lifecycle, type, null);
    }

    public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
        super(lifecycle);
        this.lifecycle = lifecycle;
        this.type = type;
        this.data = data;
    }

    private Object data = null;

    private Lifecycle lifecycle = null;

    private String type = null;

    public Object getData() {
        return (this.data);
    }

    public Lifecycle getLifecycle() {
        return (this.lifecycle);
    }

    public String getType() {
        return (this.type);
    }
}

public interface LifecycleListener {
    /**
     * Acknowledge the occurrence of the specified event.
     *
     * @param event LifecycleEvent that has occurred
     */
    public void lifecycleEvent(LifecycleEvent event);
}

public interface LifecycleListener {
    /**
     * Acknowledge the occurrence of the specified event.
     *
     * @param event LifecycleEvent that has occurred
     */
    public void lifecycleEvent(LifecycleEvent event);
}

public abstract class AbstractHandler {
    private AbstractHandler handler;

    public abstract void handleRequest(String condition);

    public AbstractHandler getHandler() {
        return handler;
    }

    public void setHandler(AbstractHandler handler) {
        this.handler = handler;
    }
}

public class ConcreteHandlerA extends AbstractHandler {
    @Override
    public void handleRequest(String condition) {
        if (condition.equals("A")) {
            System.out.println("Concrete Handler A processed...");
        } else {
            System.out.println("Concrete Handler A can't process, call other handler...");
            getHandler().handleRequest(condition);
        }
    }
}

public class ConcreteHandlerB extends AbstractHandler {
    @Override
    public void handleRequest(String condition) {
        if (condition.equals("B")) {
            System.out.println("Concrete Handler B processed...");
        } else {
            System.out.println("Concrete Handler B can't process, call other handler...");
            getHandler().handleRequest(condition);
        }
    }
}

public class ConcreteHandlerZ extends AbstractHandler {
    @Override
    public void handleRequest(String condition) {
        // 一般就是最后一个处理器
        System.out.println("Concrete handler z processed...");
    }
}

public class ChainClient {
    public static void main(String[] args) {
        AbstractHandler handlerA = new ConcreteHandlerA();
        AbstractHandler handlerB = new ConcreteHandlerB();
        AbstractHandler handlerZ = new ConcreteHandlerZ();

        // 设置链顺序
        handlerA.setHandler(handlerB);
        handlerB.setHandler(handlerZ);

        System.out.println("--------------- handle A ---------------");
        handlerA.handleRequest("A");
        System.out.println("--------------- handle B ---------------");
        handlerA.handleRequest("B");
        System.out.println("--------------- handle Z ---------------");
        handlerA.handleRequest("Z");
    }
}

// 执行结果
//
// --------------- handle A ---------------
// Concrete Handler A processed...
// --------------- handle B ---------------
// Concrete Handler A can't process, call other handler...
// Concrete Handler B processed...
// --------------- handle Z ---------------
// Concrete Handler A can't process, call other handler...
// Concrete Handler B can't process, call other handler...
// Concrete handler z processed...

public abstract class AbstractLogger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;

    //责任链中的下一个元素
    protected AbstractLogger nextLogger;

    public void setNextLogger(AbstractLogger nextLogger){
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message){
        if(this.level <= level){
            write(message);
        }
        if(nextLogger !=null){
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);
}

public class ConsoleLogger extends AbstractLogger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Standard Console::Logger: " + message);
    }
}

public class ErrorLogger  extends AbstractLogger {
    public ErrorLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }
}

public class FileLogger extends AbstractLogger {
    public FileLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }
}

public class ChainPatternDemo {
    private static AbstractLogger getChainOfLoggers(){

        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
        AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);

        return errorLogger;
    }

    public static void main(String[] args) {
        AbstractLogger loggerChain = getChainOfLoggers();

        System.out.println("--------------- handle info ---------------");
        loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");

        System.out.println("--------------- handle debug ---------------");
        loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information.");

        System.out.println("--------------- handle Error ---------------");
        loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information.");
    }
}

// --------------- handle info ---------------
// Standard Console::Logger: This is an information.
// --------------- handle debug ---------------
// File::Logger: This is a debug level information.
// Standard Console::Logger: This is a debug level information.
// --------------- handle Error ---------------
// Error Console::Logger: This is an error information.
// File::Logger: This is an error information.
// Standard Console::Logger: This is an error information.

// invoke each valve added to the pipeline
for(int n=0; n<valves.length; n++) {
    valves[n].invoke(...);
}
// then, invoke the basic valve
basicValve.invoke(...);

public interface Pipeline {
    public void invoke(Request request, Response response)
        throws IOException, ServletException;
}

public interface Container {
        public void invoke(Request request, Response response)
        throws IOException, ServletException;
}

// container 的实现
public abstract class ContainerBase implements Container, Lifecycle, Pipeline {
    protected Pipeline pipeline = new StandardPipeline(this);

    public void invoke(Request request, Response response)
        throws IOException, ServletException {

        pipeline.invoke(request, response);

    }
}

public interface ValveContext {
    public void invokeNext(Request request, Response response)
        throws IOException, ServletException;
}

public class SimplePipeline implements Pipeline {
    protected Valve valves[] = new Valve[0];

    public void addValve(Valve valve) {...}
    
    protected class SimplePipelineValveContext implements ValveContext {
        protected int stage = 0;

        public String getInfo() {
            return null;
        }

        public void invokeNext(Request request, Response response)
                throws IOException, ServletException {
            // subscript: 下标 + stage 用来标记被调用的 valve
            int subscript = stage;
            stage = stage + 1;
            // Invoke the requested Valve for the current request thread
            if (subscript < valves.length) {
                valves[subscript].invoke(request, response, this);
            } else if ((subscript == valves.length) && (basic != null)) {
                basic.invoke(request, response, this);
            } else {
                throw new ServletException("No valve");
            }
        }
    }
}

public interface Valve {
    public void invoke(Request request, Response response, ValveContext context) throws IOException, ServletException;
}

public interface Pipeline {
    // 操作 basic valve
    public Valve getBasic();
    public void setBasic(Valve valve);

    public void addValve(Valve valve);
    public Valve[] getValves();

    public void invoke(Request request, Response response)
        throws IOException, ServletException;

    public void removeValve(Valve valve);
}

public interface Valve {
    public String getInfo();

    public void invoke(Request request, Response response, ValveContext context)
        throws IOException, ServletException;
}

public interface ValveContext {

    public String getInfo();

    public void invokeNext(Request request, Response response)
        throws IOException, ServletException;
}

public interface Contained {
    public Container getContainer();
    public void setContainer(Container container);
}

 public void addChild(Container child) {
    throw new IllegalStateException(sm.getString("standardWrapper.notChild"));
}

public interface Wrapper extends Container {
    public Servlet allocate() throws ServletException;
    public void load() throws ServletException;
}

public Container map(Request request, boolean update) {
    //this method is taken from the map method in org.apache.cataline.core.ContainerBase
    //the findMapper method always returns the default mapper, if any, regardless the
    //request's protocol
    Mapper mapper = findMapper(request.getRequest().getProtocol());
    if (mapper == null)
        return (null);

    // Use this Mapper to perform this mapping
    return (mapper.map(request, update));
}

public interface Mapper {
    public Container getContainer();
    public void setContainer(Container container);
    public String getProtocol();
    public void setProtocol(String protocol);
    public Container map(Request request, boolean update);
}

public void invoke(
    org.apache.catalina.Request request,
    org.apache.catalina.Response response
    );

/**
* Return the server socket factory used by this Container.
*/
public ServerSocketFactory getFactory() {

    if (this.factory == null) {
        synchronized (this) {
            this.factory = new DefaultServerSocketFactory();
        }
    }
    return (this.factory);

}

private Stack processor = new Stack();

public void start() throws LifecycleException {
    // Validate and update our current state
    if (started)
        throw new LifecycleException
            (sm.getString("httpConnector.alreadyStarted"));
    threadName = "HttpConnector[" + port + "]";
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    started = true;

    // Start our background thread - 启动 Connector 线程，设置为守护线程
    threadStart();

    // Create the specified minimum number of processors
    while (curProcessors < minProcessors) {
        if ((maxProcessors > 0) && (curProcessors >= maxProcessors))
            break;
        HttpProcessor processor = newProcessor();
        recycle(processor);
    }
}

void recycle(HttpProcessor processor) {
    processors.push(processor);
}

public HttpProcessor(HttpConnector connector, int id) {

    super();
    this.connector = connector;
    this.debug = connector.getDebug();
    this.id = id;
    this.proxyName = connector.getProxyName();
    this.proxyPort = connector.getProxyPort();
    this.request = (HttpRequestImpl) connector.createRequest();
    this.response = (HttpResponseImpl) connector.createResponse();
    this.serverPort = connector.getPort();
    this.threadName = "HttpProcessor[" + connector.getPort() + "][" + id + "]"; 

}

public void run() {
        // Loop until we receive a shutdown command
        while (!stopped) {
            // Accept the next incoming connection from the server socket
            Socket socket = null;
            try {
                socket = serverSocket.accept();
                // ...
            }
            // ...
        }
        // ...
}

/**
    * Create and return a new processor suitable for processing HTTP
    * requests and returning the corresponding responses.
    */
private HttpProcessor newProcessor() {

    //        if (debug >= 2)
    //            log("newProcessor: Creating new processor");
    HttpProcessor processor = new HttpProcessor(this, curProcessors++);
    if (processor instanceof Lifecycle) {
        try {
            ((Lifecycle) processor).start();
        } catch (LifecycleException e) {
            log("newProcessor", e);
            return (null);
        }
    }
    created.addElement(processor);
    return (processor);

}

/**
* The background thread that listens for incoming TCP/IP connections and
* hands them off to an appropriate processor.
*/
public void run() {

    // Process requests until we receive a shutdown signal
    while (!stopped) {

        // Wait for the next socket to be assigned
        Socket socket = await();
        if (socket == null)
            continue;

        // Process the request from this socket, omit the try-catch
        process(socket);

        // Finish up this request
        connector.recycle(this);
    }

    // Tell threadStop() we have shut ourselves down successfully
    synchronized (threadSync) {
        threadSync.notifyAll();
    }
}

/**
* Process an incoming TCP/IP connection on the specified socket.  Any
* exception that occurs during processing must be logged and swallowed.
* <b>NOTE</b>:  This method is called from our Connector's thread.  We
* must assign it to our own thread so that multiple simultaneous
* requests can be handled.
*
* @param socket TCP socket to process
*/
synchronized void assign(Socket socket) {

    // Wait for the Processor to get the previous Socket
    while (available) {
        try {
            wait();
        } catch (InterruptedException e) {
        }
    }

    // Store the newly available Socket and notify our thread
    this.socket = socket;
    available = true;
    notifyAll();

    if ((debug >= 1) && (socket != null))
        log(" An incoming request is being assigned");

}

/**
* Await a newly assigned Socket from our Connector, or <code>null</code>
* if we are supposed to shut down.
*/
private synchronized Socket await() {

    // Wait for the Connector to provide a new Socket
    while (!available) {
        try {
            wait();
        } catch (InterruptedException e) {
        }
    }

    // Notify the Connector that we have received this Socket
    Socket socket = this.socket;
    available = false;
    notifyAll();

    if ((debug >= 1) && (socket != null))
        log("  The incoming request has been awaited");

    return (socket);

}

boolean ok = true;
boolean finishResponse = true;

SocketInputStream input = null;
OutputStream output = null;

// Construct and initialize the objects we will need
try {
    input = new SocketInputStream(socket.getInputStream(), connector.getBufferSize());
} catch (Exception e) {
    log("process.create", e);
    ok = false;
}

keepAlive = true;
while (!stopped && ok && keepAlive) {...}

finishResponse = true;

try {
    request.setStream(input);
    request.setResponse(response);
    output = socket.getOutputStream();
    response.setStream(output);
    response.setRequest(request);
    ((HttpServletResponse) response.getResponse()).setHeader
        ("Server", SERVER_INFO);
} catch (Exception e) {
    log("process.create", e);
    ok = false;
}

// Parse the incoming request
try {
    if (ok) {
        parseConnection(socket);
        parseRequest(input, output);
        if (!request.getRequest().getProtocol()
            .startsWith("HTTP/0"))
            parseHeaders(input);

if (http11) {
    // Sending a request acknowledge back to the client if
    // requested.
    ackRequest(output);
    // If the protocol is HTTP/1.1, chunking is allowed.
    if (connector.isChunkingAllowed())
        response.setAllowChunking(true);
}

// Ask our Container to process this request
try {
    ((HttpServletResponse) response).setHeader("Date", FastHttpDateFormat.getCurrentDate());
    if (ok) {
        connector.getContainer().invoke(request, response);
    }
}

// Finish up the handling of the request
if (finishResponse) {
    response.finishResponse();
    request.finishRequest();
    output.flush();
    ok = false;
}

// We have to check if the connection closure has been requested
// by the application or the response stream (in case of HTTP/1.0
// and keep-alive).
if ( "close".equals(response.getHeader("Connection")) ) {
    keepAlive = false;
}

// End of request processing
status = Constants.PROCESSOR_IDLE;

// Recycling the request and the response objects
request.recycle();
response.recycle();

try {
    shutdownInput(input);
    socket.close();
}

private void parseConnection(Socket socket) throws IOException, ServletException {
    ((HttpRequestImpl) request).setInet(socket.getInetAddress());
    if (proxyPort != 0)
        request.setServerPort(proxyPort);
    else
        request.setServerPort(serverPort);
    request.setSocket(socket);
}

private static Hashtable managers = new Hashtable();

/**
    * Get the StringManager for a particular package. If a manager for
    * a package already exists, it will be reused, else a new
    * StringManager will be created and returned.
    *
    * @param packageName
    */

public synchronized static StringManager getManager(String packageName) {
    StringManager mgr = (StringManager)managers.get(packageName);
    if (mgr == null) {
        mgr = new StringManager(packageName);
        managers.put(packageName, mgr);
    }
    return mgr;
}

private void parseRequest(SocketInputStream input, OutputStream output) throws IOException, ServletException {
    // Parse the incoming request line
    input.readRequestLine(requestLine);
    String method = new String(requestLine.method, 0, requestLine.methodEnd);
    String uri = null;
    String protocol = new String(requestLine.protocol, 0,
            requestLine.protocolEnd);

    // Validate the incoming request line
    if (method.length() < 1) {
        throw new ServletException("Missing HTTP request method");
    } else if (requestLine.uriEnd < 1) {
        throw new ServletException("Missing HTTP request URI");
    }
    // Parse any query parameters out of the request URI
    int question = requestLine.indexOf("?");
    if (question >= 0) {
        request.setQueryString(new String(requestLine.uri, question + 1,
                requestLine.uriEnd - question - 1));
        uri = new String(requestLine.uri, 0, question);
    } else {
        request.setQueryString(null);
        uri = new String(requestLine.uri, 0, requestLine.uriEnd);
    }

    // Checking for an absolute URI (with the HTTP protocol)
    if (!uri.startsWith("/")) {
        int pos = uri.indexOf("://");
        // Parsing out protocol and host name
        if (pos != -1) {
            pos = uri.indexOf('/', pos + 3);
            if (pos == -1) {
                uri = "";
            } else {
                uri = uri.substring(pos);
            }
        }
    }

    // Parse any requested session ID out of the request URI
    String match = ";jsessionid=";
    int semicolon = uri.indexOf(match);
    if (semicolon >= 0) {
        String rest = uri.substring(semicolon + match.length());
        int semicolon2 = rest.indexOf(';');
        if (semicolon2 >= 0) {
            request.setRequestedSessionId(rest.substring(0, semicolon2));
            rest = rest.substring(semicolon2);
        } else {
            request.setRequestedSessionId(rest);
            rest = "";
        }
        request.setRequestedSessionURL(true);
        uri = uri.substring(0, semicolon) + rest;
    } else {
        request.setRequestedSessionId(null);
        request.setRequestedSessionURL(false);
    }

    // Normalize URI (using String operations at the moment)
    String normalizedUri = normalize(uri);

    // Set the corresponding request properties
    ((HttpRequest) request).setMethod(method);
    request.setProtocol(protocol);
    if (normalizedUri != null) {
        ((HttpRequest) request).setRequestURI(normalizedUri);
    } else {
        ((HttpRequest) request).setRequestURI(uri);
    }

    if (normalizedUri == null) {
        throw new ServletException("Invalid URI: " + uri + "'");
    }
}

/**
* Read byte.
*/
public int read()
    throws IOException {
    if (pos >= count) {
        fill();
        if (pos >= count)
            return -1;
    }
    return buf[pos++] & 0xff;
}

private void parseHeaders(SocketInputStream input) throws IOException, ServletException {
    while (true) {
        HttpHeader header = new HttpHeader();
        ;

        // Read the next header
        input.readHeader(header);
        if (header.nameEnd == 0) {
            if (header.valueEnd == 0) {
                return;
            } else {
                throw new ServletException(
                        sm.getString("httpProcessor.parseHeaders.colon"));
            }
        }

        String name = new String(header.name, 0, header.nameEnd);
        String value = new String(header.value, 0, header.valueEnd);
        request.addHeader(name, value);
        // do something for some headers, ignore others.
        if (name.equals("cookie")) {
            Cookie cookies[] = RequestUtil.parseCookieHeader(value);
            for (int i = 0; i < cookies.length; i++) {
                if (cookies[i].getName().equals("jsessionid")) {
                    // Override anything requested in the URL
                    if (!request.isRequestedSessionIdFromCookie()) {
                        // Accept only the first session id cookie
                        request.setRequestedSessionId(cookies[i].getValue());
                        request.setRequestedSessionCookie(true);
                        request.setRequestedSessionURL(false);
                    }
                }
                request.addCookie(cookies[i]);
            }
        } else if (name.equals("content-length")) {
            int n = -1;
            try {
                n = Integer.parseInt(value);
            } catch (Exception e) {
                throw new ServletException(
                        sm.getString("httpProcessor.parseHeaders.contentLength"));
            }
            request.setContentLength(n);
        } else if (name.equals("content-type")) {
            request.setContentType(value);
        }
    } // end while
}

/**
* Parse a cookie header into an array of cookies according to RFC 2109.
*
* @param header Value of an HTTP "Cookie" header
*/
public static Cookie[] parseCookieHeader(String header) {

    if ((header == null) || (header.length() < 1))
        return (new Cookie[0]);

    ArrayList cookies = new ArrayList();
    while (header.length() > 0) {
        int semicolon = header.indexOf(';');
        if (semicolon < 0)
            semicolon = header.length();
        if (semicolon == 0)
            break;
        String token = header.substring(0, semicolon);
        if (semicolon < header.length())
            header = header.substring(semicolon + 1);
        else
            header = "";
        try {
            int equals = token.indexOf('=');
            if (equals > 0) {
                String name = token.substring(0, equals).trim();
                String value = token.substring(equals+1).trim();
                cookies.add(new Cookie(name, value));
            }
        } catch (Throwable e) {
            ;
        }
    }

    return ((Cookie[]) cookies.toArray(new Cookie[cookies.size()]));

}

/**
* Parse the parameters of this request, if it has not already occurred.
* If parameters are present in both the query string and the request
* content, they are merged.
*/
protected void parseParameters() {
    if (parsed)
        return;
    ParameterMap results = parameters;
    if (results == null)
        results = new ParameterMap();
    results.setLocked(false);
    String encoding = getCharacterEncoding();
    if (encoding == null)
        encoding = "ISO-8859-1";

    // Parse any parameters specified in the query string
    String queryString = getQueryString();
    try {
        RequestUtil.parseParameters(results, queryString, encoding);
    }
    catch (UnsupportedEncodingException e) {
        ;
    }

    // Parse any parameters specified in the input stream
    String contentType = getContentType();
    if (contentType == null)
        contentType = "";
    int semicolon = contentType.indexOf(';');
    if (semicolon >= 0) {
        contentType = contentType.substring(0, semicolon).trim();
    }
    else {
        contentType = contentType.trim();
    }
    if ("POST".equals(getMethod()) && (getContentLength() > 0)
        && "application/x-www-form-urlencoded".equals(contentType)) {
        try {
        int max = getContentLength();
        int len = 0;
        byte buf[] = new byte[getContentLength()];
        ServletInputStream is = getInputStream();
        while (len < max) {
            int next = is.read(buf, len, max - len);
            if (next < 0 ) {
            break;
            }
            len += next;
        }
        is.close();
        if (len < max) {
            throw new RuntimeException("Content length mismatch");
        }
        RequestUtil.parseParameters(results, buf, encoding);
        }
        catch (UnsupportedEncodingException ue) {
        ;
        }
        catch (IOException e) {
        throw new RuntimeException("Content read fail");
        }
    }

    // Store the final results
    results.setLocked(true);
    parsed = true;
    parameters = results;
    }

public final class ParameterMap extends HashMap {
    // ...
    private boolean locked = false;
    
    // ...

    public void clear() {

        if (locked)
            throw new IllegalStateException(sm.getString("parameterMap.locked"));
        super.clear();

    }

    // ...
}

public class HttpServer1 {
    public static void main(String[] args) {
        HttpServer1 server = new HttpServer1();
        server.await();
    }

    public void await() {
        ServerSocket serverSocket = null;
        int port = 8080;
        serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));

        // Loop waiting for a request
        while (!shutdown) {
            Socket socket = serverSocket.accept();
            InputStream input = socket.getInputStream();
            OutputStream output = socket.getOutputStream();

            // create Request object and parse
            Request request = new Request(input);
            request.parse();

            // create Response object
            Response response = new Response(output);
            response.setRequest(request);

            // check if this is a request for a servlet or a static resource
            // a request for a servlet begins with "/servlet/"
            if (request.getUri().startsWith("/servlet/")) {
                ServletProcessor1 processor = new ServletProcessor1();
                processor.process(request, response);
            } else {
                StaticResourceProcessor processor = new StaticResourceProcessor();
                processor.process(request, response);
            }

            // Close the socket
            socket.close();
            //check if the previous URI is a shutdown command
            shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
        }
    }
}

// Response
public class Response implements ServletResponse {
    // constructor ...

    /* This method is used to serve a static page */
    public void sendStaticResource() throws IOException {
        // write response header
        String header = "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/html\r\n" +
                "\r\n";
        output.write(header.getBytes());

        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        try {
            /* request.getUri has been replaced by request.getRequestURI */
            File file = new File(Constants.WEB_ROOT, request.getUri());
            fis = new FileInputStream(file);
      /*
         HTTP Response = Status-Line
           *(( general-header | response-header | entity-header ) CRLF)
           CRLF
           [ message-body ]
         Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
      */
            int ch = fis.read(bytes, 0, BUFFER_SIZE);
            while (ch != -1) {
                output.write(bytes, 0, ch);
                ch = fis.read(bytes, 0, BUFFER_SIZE);
            }
        } catch (FileNotFoundException e) {
            String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
                    "Content-Type: text/html\r\n" +
                    "Content-Length: 23\r\n" +
                    "\r\n" +
                    "<h1>File Not Found</h1>";
            output.write(errorMessage.getBytes());
        } finally {
            if (fis != null)
                fis.close();
        }
    }
    // other required methods defined in ServletResponse
}

public class StaticResourceProcessor {
    public void process(Request request, Response response) {
        response.sendStaticResource();
    }
}

public class ServletProcessor1 {
    public void process(Request request, Response response) {
        // 解析 servlet 名字
        String uri = request.getUri();
        String servletName = uri.substring(uri.lastIndexOf("/") + 1);

        // create a URLClassLoader
        URL[] urls = new URL[1];
        URLStreamHandler streamHandler = null;
        File classPath = new File(Constants.WEB_ROOT);

        // the forming of repository is taken from the createClassLoader
        // method in org.apache.catalina.startup.ClassLoaderFactory
        String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();

        // the code for forming the URL is taken from the addRepository
        // method in org.apache.catalina.loader.StandardClassLoader class.
        urls[0] = new URL(null, repository, streamHandler);
        URLClassLoader loader = new URLClassLoader(urls);
       

        Class<?> myClass = myClass = loader.loadClass(servletName);
        Servlet servlet = (Servlet) myClass.newInstance();
        servlet.service(request, response);
    }
}

// ...
Servlet servlet = null;
RequestFacade requestFacade = new RequestFacade(request);
ResponseFacade responseFacade = new ResponseFacade(response);
try {
    servlet = (Servlet) myClass.newInstance();
    servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
} catch (Exception e) {
    System.out.println(e.toString());
} catch (Throwable e) {
    System.out.println(e.toString());
}
// ...

public class ParentServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setAttribute("name", "jack");
        getServletContext().getRequestDispatcher("/parent.jsp").forward(req, resp);
    }
}

response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
        null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;

out.write("\n");
out.write("\n");
out.write("<html>\n");
out.write("<head>\n");
out.write("    <title>Title</title>\n");
out.write("</head>\n");
out.write("<body>\n");
out.write("\n");

String myname = (String)request.getAttribute("name");

out.write("\n");
out.write("\n");
out.write("<hr>\n");
out.write("<h1> include jspf file </h1>\n"); // <---------- sub.jsp part
out.write('\n');
out.write('\n');
out.write("\n");
out.write("<h2> Name: ");
out.print( myname);
out.write(" <h2/>");
out.write("\n");
out.write("\n");
out.write("<hr>\n");
out.write("<h1> include jsp file </h1>\n"); // <---------- sub2.jsp part
out.write("\n");
out.write("<h2> Name: ");
out.print(myname);
out.write(" </h2>\n");
out.write("\n");
out.write("\n");
out.write("<hr>\n");
out.write("<h1> jsp:include jsp file </h1>\n"); // <---------- sub3.jsp part
org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "sub3.jsp", out, false);
out.write("\n");
out.write("\n");
out.write("</body>\n");
out.write("</html>\n");

public class IndexServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setAttribute("name", "jack");
        RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/index.jsp");
        dispatcher.forward(req, resp);
    }
}