Tomcat源码分析

Tomcat源码分析(类加载器)

文章分类:Java编程

1.Tomcat共有五类ClassLoader: 
  commonLoader: 
      用于加载公共jar包，比如servlet规范包,servlet-api.jar，位于/common 
  catalinaLoader: 
      用于加载Tomcat的实现jar包，比如catalina.jar，位于/server 
  sharedLoader: 
      用于加载所有应用的共享jar包，比如struts核心包就可以放在下面，位于/shared 
  webappClassLoader 
      用于加载web应用下的class，一个web应用有一个webappClassLoader 
  JasperLoader 
      用于加载web应用下由jsp编译后的servlet，一个web应用有一个JasperLoader 

它们的父子代理关系如下: 

                     JREClassLoader 
                               | 
                     commonLoader 
                     /                       \  
          catalinaLoader        sharedLoader   
                                              /                      \ 
                          webappClassLoader ........webappClassLoader 
                                     |                                         | 
                           JasperLoader                   JasperLoader 

2.WebAppClassLoader加载策略 
  1.首先判断class是否已经加载，若已加载，则直接返回，若没加载，则进行第2步 
  2.使用系统加载器加载class，若加载成功，则返回，若失败，则进行第3步 
  3.如果webAppClassLoader设置了代理模式，则用父加载器进行加载；否则直接加载 
  4.如果webAppClassLoader未设置代理模式，则自己先加载，失败后再使用父加载器加载 

WebappClassLoader类loadClass方法

public Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException {

        if (log.isDebugEnabled())
            log.debug("loadClass(" + name + ", " + resolve + ")");
        Class clazz = null;

        // Log access to stopped classloader
        if (!started) {
            try {
                throw new IllegalStateException();
            } catch (IllegalStateException e) {
                log.info(sm.getString("webappClassLoader.stopped", name), e);
            }
        }

        // (0) Check our previously loaded local class cache
        clazz = findLoadedClass0(name);
        if (clazz != null) {
            if (log.isDebugEnabled())
                log.debug("  Returning class from cache");
            if (resolve)
                resolveClass(clazz);
            return (clazz);
        }

        // (0.1) Check our previously loaded class cache
        clazz = findLoadedClass(name);
        if (clazz != null) {
            if (log.isDebugEnabled())
                log.debug("  Returning class from cache");
            if (resolve)
                resolveClass(clazz);
            return (clazz);
        }

        // (0.2) Try loading the class with the system class loader, to prevent
        //       the webapp from overriding J2SE classes
        try {
            clazz = system.loadClass(name);
            if (clazz != null) {
                if (resolve)
                    resolveClass(clazz);
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            // Ignore
        }

        // (0.5) Permission to access this class when using a SecurityManager
        if (securityManager != null) {
            int i = name.lastIndexOf('.');
            if (i >= 0) {
                try {
                    securityManager.checkPackageAccess(name.substring(0,i));
                } catch (SecurityException se) {
                    String error = "Security Violation, attempt to use " +
                        "Restricted Class: " + name;
                    log.info(error, se);
                    throw new ClassNotFoundException(error, se);
                }
            }
        }

        boolean delegateLoad = delegate || filter(name);

        // (1) Delegate to our parent if requested
        if (delegateLoad) {
            if (log.isDebugEnabled())
                log.debug("  Delegating to parent classloader1 " + parent);
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            try {
                clazz = loader.loadClass(name);
                if (clazz != null) {
                    if (log.isDebugEnabled())
                        log.debug("  Loading class from parent");
                    if (resolve)
                        resolveClass(clazz);
                    return (clazz);
                }
            } catch (ClassNotFoundException e) {
                ;
            }
        }

        // (2) Search local repositories
        if (log.isDebugEnabled())
            log.debug("  Searching local repositories");
        try {
            clazz = findClass(name);
            if (clazz != null) {
                if (log.isDebugEnabled())
                    log.debug("  Loading class from local repository");
                if (resolve)
                    resolveClass(clazz);
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            ;
        }

        // (3) Delegate to parent unconditionally
        if (!delegateLoad) {
            if (log.isDebugEnabled())
                log.debug("  Delegating to parent classloader at end: " + parent);
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            try {
                clazz = loader.loadClass(name);
                if (clazz != null) {
                    if (log.isDebugEnabled())
                        log.debug("  Loading class from parent");
                    if (resolve)
                        resolveClass(clazz);
                    return (clazz);
                }
            } catch (ClassNotFoundException e) {
                ;
            }
        }

        throw new ClassNotFoundException(name);
    }

 

 

Tomcat源码分析(过滤器)

文章分类:Java编程

Tomcat的过滤器主要由Filter、FilterChain组成，FilterChain包含一个Filter数组.当Wrapper执行FilterChain的doFilter(request,response)方法时，FilterChain首先调用第一个Filter的doFilter(request,response,filterchain)方法，当第一个filter做完过滤操作后，它又会调用filterchain的doFilter方法，此时filterchain的当前filter已变为第二个filter，第二个filter又执行dofilter方法，依此类推，直至所有过滤器都执行完毕 

1.接口 

public interface Filter {
        .....
        //执行过滤
        public void doFilter ( ServletRequest request, ServletResponse response, FilterChain chain ) throws IOException, ServletException;

}

public interface FilterChain {
    public void doFilter ( ServletRequest request, ServletResponse response ) throws IOException, ServletException;
}

2.实现例子 

class ApplicationFilterChain implements FilterChain {

   //pos为当前filter的所在位置,n为filters数组的长度
   if (pos < n) {
            //pos++执行后，把filterchain的当前filter指向下一个
            ApplicationFilterConfig filterConfig = filters[pos++];
            Filter filter = null;
            try {
                filter = filterConfig.getFilter();

                //filter执行过滤操作
                filter.doFilter(request, response, this);
            }
            ...
   }
}


class SampleFilter implements Filter {
      ........
      public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain)
        throws IOException, ServletException {

         //do something
         .....
         //request, response传递给下一个过滤器进行过滤
         chain.doFilter(request, response);
    }

}

过滤器可以在web.xml中进行配置

 

Tomcat源码分析(阀门)

关键字: tomcat源码分析

1.Tomcat组件及关系 

Server 
   --Service 
        --Connector 
        --Engine 
            --Host 
                 --Context 
                     --Wrapper(Servlet) 

Server代表Tomcat应用服务器，它可以包含多个Service服务；一个Service服务包含多个Connector和一个Engine；一个Engine可以包含多个虚拟主机Host；一个Host可以包含多个Web应用Context，而每个Web下有可以包含多个Wrapper(Servlet的包装器) 
组件及其关系可以参考Tomcat的Server.xml及Web.xml文件 


2.当一个请求到达时，Connector会把它包装成Request对象，同时生成Response对象；然后Connector会调用Engine的invoke方法，它又会调用Host的invoke 方法，Host的invoke方法又会调用Context的invoke方法，最后，Context的invoke方法调用Wrapper的invoke方法，至此，责任链调用结束。 


接口及实现: 
a.Pipeline ， 此接口的实现主要用于维护阀门及先后关系，实现见  org.apache.catalina.core.StandardPipleline 

public interface Pipeline {

   //获取最后一个阀门
   public Valve getBasic();

   //设置最后一个阀门
   public void setBasic(Valve valve);

   //添加阀门
   public void addValve(Valve valve);

   public Valve[] getValves();

   public void removeValve(Valve valve);

   //获取第一个阀门
   public Valve getFirst();

b.Valve ， 阀门接口，主要用于做过滤工作 

  public interface Valve {

    public String getInfo();

    //获取下一个阀门
    public Valve getNext();

    //设置下一个阀门
    public void setNext(Valve valve);

    public void backgroundProcess();

    //阀门过滤
    public void invoke(Request request, Response response)
        throws IOException, ServletException;

}

c.下面是与责任链有关的实现代码，以Engine的标准实现StandardEngine为例 

StandardEngine{

    public StandardEngine() {
        super();
        //设置StandardEngineValve为Engine的最后一个阀门
        pipeline.setBasic(new StandardEngineValve());
    }

   //添加阀门
    public synchronized void addValve(Valve valve) {
        pipeline.addValve(valve);
    }

    //此方法被Connector调用
    public void invoke(Request request, Response response)
        throws IOException, ServletException {
        pipeline.getFirst().invoke(request, response);
    }
}

   
d.StandardEngine简单阀门的实现 

SimpleValve implements Valve{
   ....
   //阀门过滤方法
    public void invoke(Request request, Response response)
        throws IOException, ServletException{
       //do something
       //调用下一个阀门的invoke方法
       getNext().invoke(Request request, Response response);
       //do something
   }
}

e.StandardEngine最后一个阀门(StandardEngineValve)的实现 

StandardEngineValve extends ValveBase{
   ...
   public void invoke(Request request, Response response)
        throws IOException, ServletException{
        Host host = request.getHost();

        //至此，StandardEngine中的阀门都已处理完毕，下面把request、
         //response对象交给host处理
        host.getPipeline().getFirst().invoke(request, response);
}

c,d,e代码即为StandardEngine责任链调用的主要代码，Host、Context、Wrapper的责任链调用相关代码与其类似，阀门可以在Server.xml及Web.xml中配置