死磕Tomcat7源码之二:web组件初始化

原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://dba10g.blog.51cto.com/764602/1775827

经过死磕Tomcat7源码之一:解析web.xml，已经知道webapp的配置信息是如何解析到内存中。接下来，就是如何将对应的组件对象初始化化。分析所有的组件初始化过程，根本不可能。本文重点针对阐明3个主要组件的初始化过程，分别是:servlet,listener,filter。通过本文，你可以掌握以下知识点

  • 了解组件初始化调用序列
  • 组件servlet,listener,filter组件的初始化顺序
  • listener的初始化过程
  • servlet的初始化过程
  • filter的初始化过程

1.组件初始化序列

通过《解析web.xml》,我们可以了解，tomcat在自动完成webapp应用的部署时，完成了web.xml信息的解析，也就是说webapp组件配置元信息，tomcat已经拿到了。接下来，就是根据配置的元信息规则，初始化组件。

通过上图，知道组件对象的初始化主要从StandardContext完成的， StandardContext对应着耳熟能详的应用，比如webapp目录下的 docs,ROOT,manager...。

1组件初始化过程使用的是线程启动的。

代码参考org.apache.catalina.core.ContainerBase.startInternal


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

        List<Future<Void>> results = new ArrayList<Future<Void>>();

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

            results.add(startStopExecutor.submit(new StartChild(children[i])));

        }

 

        boolean fail = false;

        for (Future<Void> result : results) {

            try {

                result.get();

            } catch (Exception e) {

                log.error(sm.getString("containerBase.threadedStartFailed"), e);

                fail = true;

            }

 

        }

2.组件servlet,listener,filter组件的初始化顺序

笔者，创建了1个名为"helloapp"的webapp应用，分别声明了多个lister,多个servlet,filter。通过多次调整各组件在web.xml中的相对顺序。得出如下结论。

  • 组件执行顺序按Listener，Filter，Servlet进行。
  • Servlet的load-on-startup影响Servlet的启动顺序,详情见2.1节说明
  • Filter之间的初始化顺序，与<filter-name>中的字符排序规则有关，经测试与默认排序规则相反。
  • Listener之间的初始化顺序，与在web.xml声明的顺序一致。这一点非常重要，如果使用一些mvc框架，安全框架时，如果使用Listener来完成过滤拦截的话，一定要注意Listener的声明顺序。

 2.1servlet中load-on-startup的规则说明

    

  • 标记容器是否在启动的时候就加载这个servlet。
  • 当值为0或者大于0时，表示容器在应用启动时就加载这个servlet；
  • 当是一个负数时或者没有指定时，则指示容器在该servlet被选择时才加载。
  • 正数的值越小，启动该servlet的优先级越高。

3.servlet的初始化过程

org.apache.catalina.core.StandardWrapper


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

   public boolean loadOnStartup(Container children[]) {

 

        // Collect "load on startup" servlets that need to be initialized

        TreeMap<Integer, ArrayList<Wrapper>> map =

            new TreeMap<Integer, ArrayList<Wrapper>>();

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

            Wrapper wrapper = (Wrapper) children[i];

            int loadOnStartup = wrapper.getLoadOnStartup();

            //如果小于0,跳过

            if (loadOnStartup < 0)

                continue;

            Integer key = Integer.valueOf(loadOnStartup);

            ArrayList<Wrapper> list = map.get(key);

            if (list == null) {

                list = new ArrayList<Wrapper>();

                map.put(key, list);

            }

            list.add(wrapper);

        }

 

        // Load the collected "load on startup" servlets

        for (ArrayList<Wrapper> list : map.values()) {

            for (Wrapper wrapper : list) {

                try {

                    //完成加载

                    wrapper.load();

                } catch (ServletException e) {

                    getLogger().error(sm.getString("standardContext.loadOnStartup.loadException",

                          getName(), wrapper.getName()), StandardWrapper.getRootCause(e));

                    // NOTE: load errors (including a servlet that throws

                    // UnavailableException from the init() method) are NOT

                    // fatal to application startup

                    // unless failCtxIfServletStartFails="true" is specified

                    if(getComputedFailCtxIfServletStartFails()) {

                        return false;

                    }

                }

            }

        }

        return true;

 

    }

通过源码分析，我们清楚了load-on-startup 小于0时，表示servlet不需要在启动时初始化。


1

2

3

4

5

6

7

8

9

10

11

12

       protected volatile boolean instanceInitialized = false;

    public synchronized void load() throws ServletException {

        instance = loadServlet();

         

        if (!instanceInitialized) {

            initServlet(instance);

        }

 

        if (isJspServlet) {

                    //

        }

    }

通过分析load()方法， 主要逻辑保证Servlet初始化一次。注意instanceInitialized 变量声明为volatile类型，保证线程安全。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

    private synchronized void initServlet(Servlet servlet)

            throws ServletException {

        // Call the initialization method of this servlet

        try {

            instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT,

                                              servlet);

 

            if( Globals.IS_SECURITY_ENABLED) {

                boolean success = false;

                try {

                    Object[] args = new Object[] { facade };

                    SecurityUtil.doAsPrivilege("init",

                                               servlet,

                                               classType,

                                               args);

                    success = true;

                } finally {

                    if (!success) {

                        // destroy() will not be called, thus clear the reference now

                        SecurityUtil.remove(servlet);

                    }

                }

            } else {

                servlet.init(facade);

            }

 

            instanceInitialized = true;

 

            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,

                                              servlet);   

                                               

           } catch (UnavailableException f) {     

              ...

           }                                        

  }

initServlet方法，主要调用servlet的init方法，完成servlet组件的初始化工作，以及触发beforeInit和afterInit事件，触发操作org.apache.catalina.InstanceListener.instanceEvent(InstanceEvent event)。

4.listener的初始化过程

  4.1 listener类结构图

    4.2 listenerStart方法


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

   /**

     * Configure the set of instantiated application event listeners

     * for this Context.  Return <code>true</code> if all listeners wre

     * initialized successfully, or <code>false</code> otherwise.

     */

    public boolean listenerStart() {

 

 

        // Sort listeners in two arrays

        ArrayList<Object> eventListeners = new ArrayList<Object>();

        ArrayList<Object> lifecycleListeners = new ArrayList<Object>();

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

            if ((results[i] instanceof ServletContextAttributeListener)

                || (results[i] instanceof ServletRequestAttributeListener)

                || (results[i] instanceof ServletRequestListener)

                || (results[i] instanceof HttpSessionAttributeListener)) {

                eventListeners.add(results[i]);

            }

            if ((results[i] instanceof ServletContextListener)

                || (results[i] instanceof HttpSessionListener)) {

                lifecycleListeners.add(results[i]);

            }

        }

...

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

            if (instances[i] == null)

                continue;

            if (!(instances[i] instanceof ServletContextListener))

                continue;

            ServletContextListener listener =

                (ServletContextListener) instances[i];

            try {

                fireContainerEvent("beforeContextInitialized", listener);

                if (noPluggabilityListeners.contains(listener)) {

                    listener.contextInitialized(tldEvent);

                } else {

                    listener.contextInitialized(event);

                }

                fireContainerEvent("afterContextInitialized", listener);

            } catch (Throwable t) {

                ExceptionUtils.handleThrowable(t);

                fireContainerEvent("afterContextInitialized", listener);

                getLogger().error

                    (sm.getString("standardContext.listenerStart",

                                  instances[i].getClass().getName()), t);

                ok = false;

            }

        }

        return (ok);

 

    }

通过分析listenerStart方法片段，可以知道tomcat将listener分为2类，分别是eventListener和lifecycleListener两大类。并将listener加入到StandardHost中，并触发beforeContextInitialized事件，和afterContextInitialized事件。

类型 Listener名称
eventListener ServletContextAttributeListener
eventListener ServletRequestAttributeListener
eventListener ServletRequestListener
eventListener HttpSessionAttributeListener
lifecycleListener HttpSessionListener

lifecycleListener

noPluggabilityListener

 ServletContextListener

5.filter 初始化过程

5.1 filterStart方法，遍历FilterDefs,初始化Filter,并放入filterConfigsMap。

这儿维护的filterConfigsMap，将来会在StandardWrapperValve.invoke方法中调用。而StandardWrapperValve作为servlet为pipeline模式中处理用户请求流程中的一个节点，所以也就实现了filter拦截请求的目的。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

    public boolean filterStart() {

 

        if (getLogger().isDebugEnabled())

            getLogger().debug("Starting filters");

        // Instantiate and record a FilterConfig for each defined filter

        boolean ok = true;

        synchronized (filterConfigs) {

            filterConfigs.clear();

            for (Entry<String, FilterDef> entry : filterDefs.entrySet()) {

                String name = entry.getKey();

                if (getLogger().isDebugEnabled())

                    getLogger().debug(" Starting filter '" + name + "'");

                ApplicationFilterConfig filterConfig = null;

                try {

                    filterConfig =

                        new ApplicationFilterConfig(this, entry.getValue());

                    filterConfigs.put(name, filterConfig);

                } catch (Throwable t) {

                    t = ExceptionUtils.unwrapInvocationTargetException(t);

                    ExceptionUtils.handleThrowable(t);

                    getLogger().error

                        (sm.getString("standardContext.filterStart", name), t);

                    ok = false;

                }

            }

        }

 

        return (ok);

 

    }

5.2 ApplicationFilterConfig构造函数


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

    ApplicationFilterConfig(Context context, FilterDef filterDef)

        throws ClassCastException, ClassNotFoundException,

               IllegalAccessException, InstantiationException,

               ServletException, InvocationTargetException, NamingException {

 

        super();

 

        this.context = context;

        this.filterDef = filterDef;

        // Allocate a new filter instance if necessary

        if (filterDef.getFilter() == null) {

            getFilter();

        } else {

            this.filter = filterDef.getFilter();

            getInstanceManager().newInstance(filter);

            initFilter();

        }

    }

  

    Filter getFilter() throws ClassCastException, ClassNotFoundException,

        IllegalAccessException, InstantiationException, ServletException,

        InvocationTargetException, NamingException {

 

        // Return the existing filter instance, if any

        if (this.filter != null)

            return (this.filter);

 

        // Identify the class loader we will be using

        String filterClass = filterDef.getFilterClass();

        //构造filter对象

        this.filter = (Filter) getInstanceManager().newInstance(filterClass);

         

        initFilter();

         

        return (this.filter);

 

    }    

     

     

        private void initFilter() throws ServletException {

        if (context instanceof StandardContext &&

                context.getSwallowOutput()) {

            try {

                SystemLogHandler.startCapture();

                filter.init(this);//调用filter的初始化

            } finally {

                String capturedlog = SystemLogHandler.stopCapture();

                if (capturedlog != null && capturedlog.length() > 0) {

                    getServletContext().log(capturedlog);

                }

            }

        } else {

            filter.init(this);

        }

         

        // Expose filter via JMX

        registerJMX();

    }

最后，组件已经初始化了。现在理所当然应该可以处理用户请求了。都知道我们用户请求信息都在HttpServletRequest对象中。那么用户的 HTTP socket流信息，怎么一步步转换成HttpServletRequest对象的呢。下次详聊。

本文出自 “简单” 博客，请务必保留此出处http://dba10g.blog.51cto.com/764602/1775827

时间： 2024-04-20 04:47:45

死磕Tomcat7源码之二:web组件初始化的相关文章

死磕Tomcat7源码之一:解析web.xml

原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://dba10g.blog.51cto.com/764602/1775723 熟悉java web开发的同学都清楚,tomcat作为一款非常流行的servlet容器,开源,流行,配置简单,不需要赘述.个人认为,web.xml作为webapp的入口,弄清楚该文件的底层解析过程,进而可以窥探tomcat的底层工作机制,搞明白tomcat对servlert规范的实现机理. 通过本文,可以知

PHP炸死你，源码，巨有效

PHP炸死你,源码,巨有效 http://www.php100.com/uploadfile/2013/0830/20130830010035787.zip

cocos2dx骨骼动画Armature源码剖析(二)_javascript技巧

上篇文章从总体上介绍了cocos2dx自带的骨骼动画,这篇文章介绍一下导出的配置数据各个字段的含义(也解释了DragonBone导出的xml数据每个字段的含义). skeleton节点 <skeleton name="Dragon" frameRate="24" version="2.2"> name:flash文件名字. frameRate:flash帧率. version:dragonbones版本号. armatures节点 首

源码加密-关于web前端代码加密的问题

问题描述 关于web前端代码加密的问题 通常情况下,大家都可以通过f12来查看源代码,并且修改源码,我问一下怎样让源码或者是部分源码不能通过浏览器修改. 解决方案 前台的东西没用加密,只有增加阅读难易程度,可以修改变量名称为,a,b,c这种不让别人一下就可以看到,不过我看最后自己都会搞混,没多大意义 http://www.jb51.net/tools/eval/ 解决方案二: f12修改源码是浏览器的功能,不能禁止吧 解决方案三: 你的源码要想在浏览器上运行就要适应浏览器的规则,前台代码就是要展

openstack源码安装后Web中没有“项目”

问题描述 请教个问题,我用源码安装了openstack各组件后(系统CentOS6.5),现在登录发现没有"项目".使用普通用户登录页面左边是空的,使用管理员账户登录会有"管理员".请问这个"项目"是由哪个组件负责呢?我应该如何入手检查.谢谢 解决方案 解决方案二: 求助求助解决方案三: 每个租户作为一个项目,你新增一个租户就可以看到会增加一个项目

libevent源码浅析(二)：libevent的定时器的实现

在libevent中定时器的实现是通过基于最小堆的优先级队列来实现的. 对于这两个数据结构比较陌生的可以去翻算法导论的6.5节. 主要的源码都在min_heap.c中. 我们先来看主要的数据结构: typedef struct min_heap { struct event** p; unsigned n, a; } min_heap_t; 在这个数据结构中 p也就是整个优先级队列,而这个优先级队列的每个节点都是一个struct *event.n表示这个队列的元素个数.a表示这个队列的大小. 接

SEDA源码解读(二)

接着上一篇的话题,本篇继续探讨SEDA的实践项目--sandstorm. 首先,看看package里面的类文件: ResponseTimeControllerIF:该接口代表一个响应时间的控制器,通常情况下被stage的线程管理器执行,以执行事件准入控制策略来达到特定响应时间的目标. StageStatsIF:该接口允许各种各样的系统组件在执行时记录以及收集关于stage的统计. StageWrapperIF:它是一个应用程序stage的内部表示,一个applicationstage包含一个ev

Apache Flink fault tolerance源码剖析(二)

继续Flink Fault Tolerance机制剖析.上一篇文章我们结合代码讲解了Flink中检查点是如何应用的(如何根据快照做失败恢复,以及检查点被应用的场景),这篇我们来谈谈检查点的触发机制以及基于Actor的消息驱动的协同机制.这篇涉及到一个非常关键的类--CheckpointCoordinator. org.apache.flink.runtime.checkpoint.CheckpointCoordinator 该类可以理解为检查点的协调器,用来协调operator和state的分布

muduo库源码剖析(二) 服务端

一. TcpServer类: 管理所有的TCP客户连接,TcpServer供用户直接使用,生命期由用户直接控制.用户只需设置好相应的回调函数(如消息处理messageCallback)然后TcpServer::start()即可. 主要数据成员: boost::scoped_ptr<Accepter> acceptor_; 用来接受连接 std::map<string,TcpConnectionPtr> connections_; 用来存储所有连接 connectonCallbac