Liferay 启动过程分析4-初始化Servlet上下文池

 我们回到MainServlet类的init()方法中，在执行processStartupEvents()之后，我们开始初始化Servlet上下文池：

1. if (_log.isDebugEnabled()) { 
2.             _log.debug("Initialize servlet context pool"); 
3.         } 
4.  
5.         try { 
6.             initServletContextPool(); 
7.         } 
8.         catch (Exception e) { 
9.             _log.error(e, e); 
10.         } 

它会调用以下方法：

1. protected void initServletContextPool() throws Exception { 
2.         ServletContext servletContext = getServletContext(); 
3.  
4.         String contextPath = PortalUtil.getPathContext(); 
5.  
6.         ServletContextPool.put(contextPath, servletContext); 
7.     } 

首先，它获取Servlet上下文对象，然后它去取得contextPath.这个字符串是通过PortalUtil.getPathContext(）获得，进而调用PortalImpl的getPathContext（）方法：

1. public String getPathContext() { 
2.     return _pathContext; 
3. } 

这个值设置在PortalImpl类的构造器中,我们将其解析出来：

1. .. 
2. // Paths 
3. _pathProxy = PropsValues.PORTAL_PROXY_PATH; 
4. _pathContext = ContextPathUtil.getContextPath(PropsValues.PORTAL_CTX); 
5. _pathContext = _pathProxy.concat(_pathContext); 
6. .. 

解析_pathProxy=PropsValues.PORTAL_PROXY_PATH:

这个值最终定义在portal.properties中：

1. # 
2.    # Set this property if the application server is served behind a proxy and 
3.    # a prefix needs to be added to the portal servlet context path. This prefix 
4.    # will also be added to static resources served by layout templates, 
5.    # portlets, and themes. 
6.    # 
7.    portal.proxy.path= 

解析_pathContext=ContextPathUtil.getContextPath(PropsValues.PORTAL_CTX): 

先找到PropsValues.PORTAL_CTX的取值，很容易发现它最终定义在portal.properties中：

1. # 
2.   # Specify the path of the portal servlet context. This is needed because 
3.   # javax.servlet.ServletContext did not have access to the context path until 
4.   # Java EE 5. 
5.   # 
6.   # Set this property if you deploy the portal to another path besides root. 
7.   # 
8.   portal.ctx=/ 

然后，我们来解析 ContextPathUtil.getContextPath("/"):

对应解析代码为：

1. public static String getContextPath(String contextPath) { 
2.         contextPath = GetterUtil.getString(contextPath); 
3.  
4.         if ((contextPath.length() == 0) || 
5.             contextPath.equals(StringPool.SLASH)) { 
6.  
7.             contextPath = StringPool.BLANK; 
8.         } 
9.         else if (!contextPath.startsWith(StringPool.SLASH)) { 
10.             contextPath = StringPool.SLASH.concat(contextPath); 
11.         } 
12.  
13.         return contextPath; 
14.     } 

先看02行，它调用GetterUtil的getString方法：

1. public static String getString(String value) { 
2.     return getString(value, DEFAULT_STRING); 
3. } 

最终调用的代码为：

1. public static String get(String value, String defaultValue) { 
2.     if (value == null) { 
3.         return defaultValue; 
4.     } 
5.  
6.     value = value.trim(); 
7.  
8.     if (value.indexOf(CharPool.RETURN) != -1) { 
9.         value = StringUtil.replace( 
10.             value, StringPool.RETURN_NEW_LINE, StringPool.NEW_LINE); 
11.     } 
12.  
13.     return value; 
14. } 

所以，他没有进入任何判断，直接返回"/"，

然后我们看03行：

可以发现它匹配contextPath.equals(StringPool.SLASH))，所以最终执行 contextPath = StringPool.BLANK， 也就是把contextPath设为空串。

它就是_pathContext的值。

解析_pathContext = _pathProxy.concat(_pathContext); 

因为我们_pathProxy为空，而_pathContext也为空，所以最终结果_pathContext为空。

最终，我们在MainServlet的initServletContextPool方法中执行以下语句：

1. ServletContextPool.put(contextPath, servletContext); 

它就是在ServletContextPool中添加一个key-value对，于是就完成了ServletContextPool的初始化。