How Tomcat works 翻译(2) 之 Wrapper容器

第五章、容器

      一个容器就是处理一个servlet请求和封装web客户端的相应响应的一个模块。一个容器由org.apache.catalina.Container接口所具有，Tomcat有四种类型容器如：Engine、Host、Context、Wrapper。这章是讲解Context和Wrapper，剩下的两个容器在第13章讲解。这章以讨论Container接口作为开始，紧跟着就是讨论在容器中的管道机制。接下来就要谈论Wrapper和Context接口。两个应用程序总结这章，通过运用一个简单的wrapper和一个简单的context.

一、容器接口

  一个容器一定要实现org.apache.catalina.Container。这如你在第四章看到的，你把Container实例传给Conector对象的setContainer()方法，目的是connector能够调用container的invoke()方法.让我们回想在第四章的Bootstrap类中的代码：

         HttpConnector connector=new HttpConnector();

         SimpleContainer container=new SimpleContainer();

         connector.setContainer(container);

第一件事要注意的就是在Catalina容器中有四个不同概念层次的容器：

   1）Engine   代表整个Catalina servlet engine

   2)  Host     代表一个含有一个或者多个的Context的虚拟host

   3）Context   代表一个Web应用。一个Context包含一个或者更多的wrapper

   4) Wrapper  代表单个servlet

每个上面的容器在org.apache.catalina包中用接口来进行描述，这些接口的名字是：Engine、Host、Context、Wrapper。上面四个接口继承了Container接口。下面四个类StandardEngine、StandardHost、StandardContext、StandardWrapper标准的实现了这四个容器的接口，这四个类在org.apache.catalina.core包中

 

   下面的类图说明了Container接口、以及子接口还有他们的实现。注意整个接口在org.apache.catalina包中，其实现是在org.apache.catalina.core包中。

注意在上面的类图中，整个实现的类派生了一个抽象的类ContainerBase.

 

    一个可以运行的Cataline不需要完完全全的四种类型的容器。比如，在这章第一个应用程序的container模块仅仅是有一个wrapper组成。第二个应用的container模块是由一个Contect和一个Wrapper组成。这章是既没有Engine也没有host容器。

     一个容器有零个或者更多个孩子容器(要比这个容器的层次低)。例如，正常的一个Context有一个或者多个wrapper,一个Host有零个或者多个Context。然而，四个容器中层次最低的Wrapper容器不能包含有孩子容器。为了添加一个孩子容器给一个容器你要用Container接口的方法addChild，下面是是它的方法签名：

       public void addChild(Container child);

   如果要从一个容器中移除孩子容器，就需要调用Container接口的removeChild方法，下面是此方法的签名：

           public void removeChild(Container child);

   除此之外Container接口也有寻找一个孩子和找出容器的所有孩子，下面是两个方法的签名：

            public Container findChild(String name);

            public Cotainer[] findChildren();

    一个容器也可以包含许多组件如：Loader、Logger、Manager、Realm、Resources。我们将会在下面的章节谈论这些组件。有一件值得注意的地方就是Container接口提供了get和set方法，目的是Container和这些组件进行关联。这些方法包括：getLoader、setLoader、getLogger、setLogger、getManager、setManager、getRealm、setRealm、getResources、setResources.

 

       更有趣的是，Container接口被设计成一种可以用xml文件配置的方式，如：Tomcat管理员想要容器需要什么样的功能只需要在server.xml文件下进行配置就可以了。这种实现是引用了管道技术和一系列的阀门，这些技术将会在“管道任务”这段就行讲解。

      注意在Tomcat4中的Container接口与Tomcat5有一点点小的区别。比如：在Tomcat4中Container接口有一个map方法，但是在Tomcat5中此方法就没有。

二、管道任务

      这段主要说明：当connector调用了一个Container中的invoke方法将会发生什么事情。这段的又分为四个小部分，主要是讨论在org.apache.catalina包中的四个接口，Pipeline、Valve、ValveContext和Contained.

      一个Pipeline包含的任务就是容器的调用机制。一个Valve代表着一个具体的任务。在Container的pipeline中有一个基本的valve，而且你也可以添加你所需要的Valve(这个不包含基本的Valve).更令人惊奇的就是这些Valve能够在server.xml文件进行动态编辑。下面是pipeline和他的Valves:

          如果你想了解servlet过滤器，你就需要想象一下pipeline和他的valves是怎么工作的。一个Pipeline就像一个过滤链，每个valve就是过滤门。想一个过滤器，一个valve能过处理request和response对象。valve完成处理之后，又可以调用pipeline中的一下一个Valve中去。注意这个基本的Valve一直是最后被调用。

 

      一个Container可以有一个Pipeline。当Container的Invoke方法被调用，Container就会传递给pipeline中的invoke方法进行处理，pipeline调用了第一个valve然后紧跟着调用下一个，如此类推，直到在pipeline中没有了Valve。因此你可以想象一下在pipeline中的invoke方式调用的伪代码，伪代码请看下面：

        //调用添加到pipeline中的valve

        for(int n=0;n<valves.length;i++){

                valve[n].invoke(...);

        }

//然后就调用the basic valve

    basicValve.invoke(...);

     然而，Tomcat设计者选择了一个与众不同的方法就是在org.apache.catalina包中引用了ValveContext接口。在这里会详细说明他的工作原理。

      当connector调用了invoke()方法，然后调用pipeline中的valves，里面的代码不是十分的复杂。instead，the container 调用了pipeline中的invoke方法。the pipeline接口中的invoke方法的前面在下面，需要注意的就是此方法与the Container接口中的invoke方法是一模一样。

     public void invoke(Request request,Response response)

           throws IOException,ServletException;

下面的代码是org.apache.catalina.core.ContainerBase类实现了Container接口，并实现了invoke方法，代码如下：

       public void invoke(Request request,Response response)

           throws IOException,ServletException{

        pipeline.invoke(request,response);

     }

   Pipeline实例在ContainerBase类中的实例变量中

   现在，the pipeline必须确保添加在pipeline中的valves和the basic valve一定要别调用。the pipeline创建了一个Valve接口实例。the ValveContext被Pipeline中的内部类所实现，以至于the ValveContext 能够访问the pipeline中的所有成员变量。the ValveContext接口中的invokeNext方法是十分重要的，方法签名如下：

       public void invokeNext(Request request,Response response)

             throws IOException,ServletException;

  创建一个ValveContext实例后，the pipeline就要调用the ValveContext中invokeNext方法。the ValveContext将首先调用the pipeline中的第一个valve,在处理第一个valve任务之前，第一个valve将会调用下一个valve.the ValveContext会传给this给每个valve，这样就可以调用ValveContext中的invokeNext方法，下面的方法签名是Valve接口的invoke方法。

           public void invoke(Request request,Response response,ValveContext valveContext)

                      throws IOException,ServletException;

      实现了Valve中的invoke方法就是像下面的代码一样做这些事：

    public void invoke(Request request,Response response,ValveContext valveContext)

                      throws IOException,ServletException{

     //通过传给request和response给pipeline中的下一个valve

      valveContext.invokeNext(request,response);

       //现在就执行valve应该做的任务

      ....

     }

the org.apache.cataline.core.StandardPipeline类在整个Container实现了Pipeline接口。在Tomcat4.这个类有一个内部类叫做StandardPipelineValveContext(实现了ValveContext接口)，下面的代码就是StandardPipelineValveContext的标准实现：

 

protected class StandardPipelineValveContext


        implements ValveContext {


  protected int stage = 0;


  public String getInfo() {


            return info;


        }


      public void invokeNext(Request request, Response response)


            throws IOException, ServletException {





            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


                    (sm.getString("standardPipeline.noValve"));


            }





        }


}

 

注解：这种管道方式的调用方式非常值得借鉴，他的调用相当于堆栈形式那样，读者要用心的去调式跟踪一下他们的调用方式。以后在项目可以运用这种方法。强烈推荐。。。。

The invokeNext方法使用了subscript和stage变量，这两个变量时控制valve调用的。当首次从pipeline中的invkoe方法中调用时，subscript的值是0，stage的值变成1.因此第一个valve（array index 0）被调用.第一个valve在Pipeline中接收到ValveContext实例，然后就在实现valve接口类中的invokeNext方法被调用(这样如此有回调回来了)。然而，the subscript的值变成1以至于第二个valve被调用，以此类推。

     当the invokeNext方法被调用到最后一个valve时，subscript的值与valves的值是相等的。结果，the basic valve被调用。

 

      Tomcat5从StandadrPipeline中移除了内部类StandardPipelineValve，而是依赖于org.apache.core包中的StandardValveContext类。下面会呈现出其代码：

    

 

 

     你能看到在Tomcat4中的StandardPipelineValveContext类与在Tomcat5中的StandardPipelineValveContext有什么类似的吗？

    我们将会更详细的解释the Pipeline、Valve、ValveContext接口。同时也会讨论在org.apache.catalina.Contained接口(这个接口有一个Valve类实现)。

三、The Pipeline接口

     The Pipeline接口的第一个方法，我们已经提到了就是invoke方法，一个Container在Pipeline调用Valves的invoke方法和basic valve。the Pipeline接口允许你添加一个Valve（通过调用addValve方法），允许移除一个Valve(通过调用removeValve方法)。最后，你需要用setBasic方法分配一个basic valve给pipeline,而getBasic方法是获得basic valve.最后被调用的Invoke方法的basic valve主要负责处理the request和相应的response。下面的代码是The Pipeline接口：

 

package org.apache.catalina;


import java.io.IOException;
import javax.servlet.ServletException;
public interface Pipeline {
    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);

}

 四、The Valve接口

     The Valve接口代表了一个阀值，主要是处理request请求。这个接口有两个方法：invoke和getInfo方法。The invoke方法已经在上面讨论了。The getInfo方法就是返回实现Valve的相关信息。下面是关于Valve接口的代码：

 

package org.apache.catalina;


import java.io.IOException;
import javax.servlet.ServletException;
public interface Valve {
      public String getInfo();
      public void invoke(Request request, Response response,
                       ValveContext context)
        throws IOException, ServletException;

}

 五、The ValveContext接口

这个接口有两个方法：The invokeNext方法，此方法已经在上面讨论了，the getInfo方法是返回实现ValveContext接口类的相关信息。下面代码是The ValveContext接口：

package org.apache.catalina;


import java.io.IOException;
import javax.servlet.ServletException;
public interface ValveContext {
      public String getInfo();
      public void invokeNext(Request request, Response response)
        throws IOException, ServletException;

}

 六、The Contained接口

一个Valve类能够任意实现the org.apache.catalina.Contained接口。实现这个接口的类主要的目的就是想和一个Container实例相关(至多一个)，下面是The Contained接口的代码：

package org.apache.catalina;
public interface Contained {
    public Container getContainer();
    public void setContainer(Container container);

}

 七、The Wrapper接口

The org.apache.catalina.Wrapper接口代表了一个封装。A Wrapper是代表了一个单个的Servlet定义的信息的容器。The Wrapper接口继承了Container接口还添加许多新的方法。实现Wrapper接口主要的责任就是管理Servlet的生命周期，比如：调用init、service、destory方法。由于一个Wrapper是容器中层次最低的一个，所有它是不允许添加孩子。如果用户调用了addChild方法，那么就会抛出IllegalArgumentException异常。

      在Wrapper接口中最为重要的方法还是allocate和load方法。

The allocate方法为the servlet初始化实例。The allocate方法也在考虑是否the servlet实现了javax.servlet.SingleThreadModel接口，但是我们将会在下面的章节讨论(11章)。The load 方法就是加载和初始化servlet实例。下面是allocate和load方法标签：

     public javax.servlet.Servlet allocate() throws javax.servlet.ServletException;

     public void load() throws javax.servlet.ServletException;

当我们在讨论org.apache.catalina.core.StandardWrapper类(这个是在第11章讨论)，我们才会谈论Wrapper接口的其他方法。

     八、The Context 接口

   一个Context代表了一个Web应用的容器。一个Context通常有一个或者更多的Wrappers作为它的孩子容器。

  此接口有重要的方法就是addWrapper、createWrapper等，这个接口将会在第12章会详细的讲到。

 

九、The Wrapper应用程序

这个应用程序为了证明怎样写一个微型的container模块。这个应用的核心类是ex05.pyrmont.core.SimpleWrapper(实现了Wrapper接口)。一个Pipeline(这个接口被ex05.pyront.core.SimplePipeline类实现)和一个Loader接口（被ex05.pyront.core.SimpleLoader实现）是The SimpleWrapper类的成员变量。The Pipeline包含了一个basic valve(ex05.pyrmont.core.SimpleWrapperValve)和两个valves(ex05.pyrmont.core.ClientIPLogger和ex05.pyrmont.core.HeaderLoggerValve)。下面是这个应用程序的类图：

   注意The container 使用了Tomocat4的默认连接器

   The wrapper封装了ModernServlet(这个你应该在前面的章节使用过)这个应用程序证明：你有一个由仅仅一个Wrapper组成的servlet容器。整个类没有完完全全的实现整个功能，但是实现的一些方法将会在这些类中呈现出来。现在让我们来详细了解这些类的运行。

十、ex05.pyrmont.core.SimpleLoader

在容器中加载servlet类的任务被指定给实现Loader接口类的身上。在这个应用中SimpleLoader类就充当这个责任。SimpleLoader要知道servlet类的位置，并要有一个getClassLoader方法，目的就是返回一个java.lang.ClassLoader实例（搜索servlet类的位置）。The SimpleLoader类定义了三个成员变量。第一个成员变量就是WEB_ROOT（指定要查找的servlet类的目录）。代码如下：

public static final String WEB_ROOT =
	    System.getProperty("user.dir") + File.separator  + "webroot";

 其他的两个变量是ClassLoader和Container应用变量:

 ClassLoader classLoader = null;
	  Container container = null;

 The SimpleLoader类的构造函数初始化the class loader,目的是为了准备返回一个the SimpleWrapper实例。

	  public SimpleClassLoader() {
		    try {
		      URL[] urls = new URL[1];
		      URLStreamHandler streamHandler = null;
		      File classPath = new File(WEB_ROOT);
		      String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;
		      urls[0] = new URL(null, repository, streamHandler);
		      classLoader = new URLClassLoader(urls);
		    }
		    catch (IOException e) {
		      System.out.println(e.toString() );
		    }

		  }

 这个构造函数的代码在前面的章节出现过，这里就不在详细的解释。

The Container成员变量代表的是The Container与这个Loader相关联。

 

   注意的是Loaders将会在第八章会详细的讨论。

十一、ex05.pyrmont.core.SimplePipeline

  The SimplePipeline类实现了org.apache.catalina.Pipeline接口。十分重要的方法就是the invoke方法，它同时也包含了一个内部类SimplePipelineValveContext.SimplePipelineValveContext实现了org.apache.catalina.ValveContext接口

这个实现的细节在"Pipelining Task"中已经讨论了。

 

十二、ex05.pyrmont.core.SimpleWrapper

   这个类实现了org.apache.catalina.Wrapper接口，并且实现了allocate和load方法。其他的就是，这个类定义了以下

成员变量：

 

	private Loader loader;

	private Container parent;

 The loader成员变量是一个常常用到的类加载器接口。The parent成员变量代表了这个Wrapper的父类容器，这样就意味着这个wrapper能够成为别的容器(Conetx)的孩子容器。

 

特别注意的就是SimpleWrapper类中的getLoader方法，下面就是其代码：

 

public Loader getLoader() {
		if(loader!=null)
			return loader;
		else if(parent!=null)
			return parent.getLoader();
			
		return null;
	}

 The getLoader方法返回一个Loader(经常加载一个sevlet类)，如果the Wrapper与一个Loader相关联，这个Loader就会返回。如果没有，就会返回父类容器的Loader。如果父类容器也没有，那么就只能返回null.

 

   The SimpleWrapper类有一个pipeline和设置一个basic valve给pipeline.你会在the SimpleWrapper构造函数中会做这样的事，下面的代码进行说明：

public SimpleWrapper() {
		pipeline.setBasic(new CallServletValve());
	}

 这儿pipeline作为SimplePipeline类的成员变量，代码如图所示：

/***
	 * 只要new SimpleWrapper()就把Container容器传过来，
	 * 因为SimpleWrapper实现了Wrapper接口而Wrapper继承了
	 * Container接口,注意的是为什么要new SimpleWrapper()
	 * 呢？    
	 * 这是因为SimpleWrapper这个类代理调用了SimplePipeLine
	 * 的方法，这样做的好处就是客户写程序时不再去面对SimplePipeLine类，
	 * 而只需要关注SimpleWrapper这个类的方法就行，
	 */
	private SimplePipeline pipeline = new SimplePipeline(this);

 

十三、ex05.pyrmont.core.SimpleWrapperValve

The SimpleWrapperValve类是一个the basic valve(专门处理the SimpleWrapper类中的request请求)。SimpleWrapperValve实现了the org.apache.catalina.Valve接口，同时还实现了the org.apache.catalina.Contained接口。在SimpleWrapperValve十分重要的方法就是the invoke方法，下面是其方法的代码：

	public void invoke(Request request, Response response,
			ValveContext context)
			throws IOException, ServletException {
//		System.out.println("这个是CallServletValve中的容器："+getContainer());
	    SimpleWrapper wrapper = (SimpleWrapper) getContainer();
	    ServletRequest sreq = request.getRequest();
	    ServletResponse sres = response.getResponse();
	    Servlet servlet = null;
	    HttpServletRequest hreq = null;
	    if (sreq instanceof HttpServletRequest)
	      hreq = (HttpServletRequest) sreq;
	    HttpServletResponse hres = null;
	    if (sres instanceof HttpServletResponse)
	      hres = (HttpServletResponse) sres;

	    // 分配一个servlet实例，调用servlet中service()方法
	    try {
	      servlet = wrapper.allocate();
	      if (hres!=null && hreq!=null) {
	        servlet.service(hreq, hres);
	      }
	      else {
	        servlet.service(sreq, sres);
	      }
	    }
	    catch (ServletException e) {
	    }
	}

 因为SimpleWrapperValve被作为basic valve，所以The invoke方法不需要调用the ValveContext中的invokeNext方法。The invoke方法调用了the SimpleWrapper类中的the allocate方法，目的是获得一个servlet实例，然而该实例就会调用本身方法service。注意the Wrapper的pipeline中的the basic valve调用了servlet的service方法，而不是the wrapper本身调用的。

十四、ex05.pyrmont.valves.ClientIPLoggerValve

  The ClientIPLoggerValve类主要职责就是把客户的IP地址打印在控制台上，下面是其代码：

package org.hewen.jerry.conatiner;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;

import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.hewen.jerry.inter.Contained;
import org.hewen.jerry.inter.Container;
import org.hewen.jerry.inter.Valve;
import org.hewen.jerry.inter.ValveContext;

public class ClientLoggerValve implements Contained, Valve {
	protected Container container;
	public Container getContainer() {
		return this.container;
	}

	public void setContainer(Container container) {
		this.container=container;
	}

	public void invoke(Request request, Response response, ValveContext context)
			throws IOException, ServletException {
		
		 context.invokeNext(request, response);
		 System.out.println("该阀门的职责就是获取客户端的IP");
//		 System.out.println("这是ClientLoggerValve容器："+getContainer());
		 
		 ServletRequest sreq = request.getRequest();
		 System.out.println(sreq.getRemoteAddr());
		 System.out.println("------------------------------------");
	}

}

 注意the invoke方法。the invoke第一件事就是调用了The ValveContext的invokeNext方法，这样调用的目的就是为了在pipeline中调用下一个valve的invoke方法。这个类也打印了一些字符串包括输出了the request对象的远程地址方法。

 

十五、ex05.pyrmont.valves.HeaderLoggerValve

这个类与the ClientIPLoggerValve类十分相似，The HeaderLoggerValve类主要职责就是在控制台上打印the request的相关信息。下面的代码所示：

package org.hewen.jerry.conatiner;

import java.io.IOException;
import java.util.Enumeration;

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;

import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.hewen.jerry.inter.Contained;
import org.hewen.jerry.inter.Container;
import org.hewen.jerry.inter.Valve;
import org.hewen.jerry.inter.ValveContext;

public class HeaderLoggerValve implements Contained, Valve {
	
	protected Container container;
	public Container getContainer() {
		return this.container;
	}

	public void setContainer(Container container) {
		this.container=container;
	}


	public void invoke(Request request, Response response, ValveContext context)
			throws IOException, ServletException {
		context.invokeNext(request, response);
		
		System.out.println("这个阀门所做的事就是获取请求头的信息");
//		System.out.println("这个是HeaderLoggerValve容器："+getContainer());
		ServletRequest serRequest=request.getRequest();
		if(serRequest instanceof HttpServletRequest){
			HttpServletRequest hsr=(HttpServletRequest)serRequest;
			Enumeration names=hsr.getHeaderNames();
			while(names.hasMoreElements()){
				String name=names.nextElement().toString();
				String value=hsr.getHeader(name);
				System.out.println(name+" :"+value);
			}
		}else{
			System.out.println("没有相应Http请求");
		}
		System.out.println("----------------------------------");
		
	}

}

 现在反复强调特别注意the invoke 方法。the invoke第一件事就是调用了The ValveContext的invokeNext方法，这样调用的目的就是为了在pipeline中调用下一个valve的invoke方法。这个类也打印了一些头部信息。

 

十六、ex05.pyrmont.startup.Bootstrap1

The Bootstrap1类是用来启动这个应用程序，下面给出其代码：

package ex04.pyrmont.startup;

import org.apache.catalina.connector.http.HttpConnector;
import org.hewen.jerry.conatiner.ClientLoggerValve;
import org.hewen.jerry.conatiner.HeaderLoggerValve;
import org.hewen.jerry.conatiner.SimpleClassLoader;
import org.hewen.jerry.conatiner.SimpleWrapper;
import org.hewen.jerry.inter.Loader;
import org.hewen.jerry.inter.Pipeline;
import org.hewen.jerry.inter.Wrapper;

public final class Bootstartup {
	public static void main(String[] args){
		HttpConnector connector=new HttpConnector();
		Wrapper wrapper=new SimpleWrapper();
		wrapper.setServletClass("ModernServlet");
		Loader loader=new SimpleClassLoader();
		ClientLoggerValve clientValve=new ClientLoggerValve();
		HeaderLoggerValve headerValve=new HeaderLoggerValve();
		((Pipeline)wrapper).addValve(clientValve);
		((Pipeline)wrapper).addValve(headerValve);
		
		wrapper.setLoader(loader);
		
		connector.setMyDefContainer(wrapper);
		
		try {
			connector.initialize();
			connector.start();
			System.in.read();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
	}
}

 创建了HttpConnector和SimpleWrapper实例后，The Bootstrap类的main方法把ModernServlet传给SimpleWrapper的setServletClass方法（即作为参数传递），目的就是为了告知the wrapper要加载以该名称的class。

        wrapper.setServletClass("ModernServlet");

接下来就是创建一个Loader和两个Valves并且把loader传给wrapper,下面代码：

    Loader loader=new SimpleLoader();

    Valve valve1=new HeaderLoggerValve();

    Valve valve2=new ClientIPLoggerValve();

    wrapper.setLoader(loader);

 两个valves就会被添加到the wrapper中的pipeline上。

     ((Pipeline)wrapper).addValve(valve1);
        ((Pipeline)wrapper).addValve(valve2);

 最后，The wrapper被the Connector类的setContainer方法当做参数传递，接着就是the connector 的初始化和启动，下面代码：

       connector.setContainer(wrapper);

      try{

               connector.initialize();

               connector.start();

       }

      下面的代码就是允许用户停止应用

 

 

   System.in.read();

十七、运行这个应用程序

    这里我就不翻译了，我当时做的就是直接在myEclipse中新建一个项目，再把源代码加上去就可以了，运行浏览器url地址就OK。。。。这里就不详细分析。。。。

评论

2 楼 he_wen 2010-12-09  

前面几章已经有人翻译，你自己可以在csdn里面下

1 楼 吾日三省吾身 2010-12-09  

怎么直接就是第五章了？是从这里开始的吗？