论坛首页 → 入门技术论坛 →

Spring 源码分析(Log4jConfigListener Parts)

浏览 5246 次
锁定老帖子 主题：Spring 源码分析(Log4jConfigListener Parts)
该帖已经被评为新手帖
作者 正文
  • hotforcc
  • 等级: 初级会员
  • 性别:
  • 文章: 24
  • 积分: 30
  • 来自: 北京
   发表时间：2007-08-25  
java 代码
 
  1. Spring Open Sourse Research(Log4jConfigListener Parts)  
  2. /** 
  3.  * Bootstrap listener for custom Log4J initialization in a web environment. 
  4.  * Delegates to Log4jWebConfigurer (see its javadoc for configuration details). 
  5.  * 
  6.  * WARNING: Assumes an expanded WAR file, both for loading the configuration 
  7.  * file and for writing the log files. If you want to keep your WAR unexpanded or 
  8.  * don't need application-specific log files within the WAR directory, don't use 
  9.  * Log4J setup within the application (thus, don't use Log4jConfigListener or 
  10.  * Log4jConfigServlet). Instead, use a global, VM-wide Log4J setup (for example, 
  11.  * in JBoss) or JDK 1.4's java.util.logging (which is global too). 
  12.  * 
  13.  * 
  14.  
  15. This listener should be registered before ContextLoaderListener in web.xml, 
  16.  * when using custom Log4J initialization. 
  17.  * 
  18.  * 
  19.  
  20. For Servlet 2.2 containers and Servlet 2.3 ones that do not 
  21.  * initalize listeners before servlets, use Log4jConfigServlet. 
  22.  * See the ContextLoaderServlet javadoc for details. 
  23.  * 
  24.  * @author Juergen Hoeller 
  25.  * @since 13.03.2003 
  26.  * @see Log4jWebConfigurer 
  27.  * @see Log4jConfigServlet 
  28.  * @see org.springframework.web.context.ContextLoaderListener 
  29.  * @see org.springframework.web.context.ContextLoaderServlet 
  30.  * @see WebAppRootListener 
  31.  */  
  32. public class Log4jConfigListener implements ServletContextListener {  
  33.   
  34.     public void contextInitialized(ServletContextEvent event) {  
  35.         Log4jWebConfigurer.initLogging(event.getServletContext());  
  36.     }  
  37.   
  38.     public void contextDestroyed(ServletContextEvent event) {  
  39.         Log4jWebConfigurer.shutdownLogging(event.getServletContext());  
  40.     }  
  41.   
  42. }  
  43.   
  44.   
  45. Log4jWebConfigurer.java  
  46. public abstract class Log4jWebConfigurer {  
  47.   
  48.     /** Parameter specifying the location of the Log4J config file */  
  49.     public static final String CONFIG_LOCATION_PARAM = "log4jConfigLocation";  
  50.   
  51.     /** Parameter specifying the refresh interval for checking the Log4J config file */  
  52.     public static final String REFRESH_INTERVAL_PARAM = "log4jRefreshInterval";  
  53.   
  54.     /** Parameter specifying whether to expose the web app root system property */  
  55.     public static final String EXPOSE_WEB_APP_ROOT_PARAM = "log4jExposeWebAppRoot";  
  56.   
  57.   
  58.     /** 
  59.      * Initialize Log4J, including setting the web app root system property. 
  60.      * @param servletContext the current ServletContext 
  61.      * @see WebUtils#setWebAppRootSystemProperty 
  62.      */  
  63.     public static void initLogging(ServletContext servletContext) {  
  64.         // Expose the web app root system property.  
  65.         if (exposeWebAppRoot(servletContext)) {  
  66.             WebUtils.setWebAppRootSystemProperty(servletContext);  
  67.         }  
  68.   
  69.         // Only perform custom Log4J initialization in case of a config file.  
  70.         //CONFIG_LOCATION_PARAM 为log4j.properties的存放路径  
  71.         String location = servletContext.getInitParameter(CONFIG_LOCATION_PARAM);  
  72.         if (location != null) {  
  73.             // Perform actual Log4J initialization; else rely on Log4J's default initialization.  
  74.             try {  
  75.                 // Return a URL (e.g. "classpath:" or "file:") as-is;  
  76.                 // consider a plain file path as relative to the web application root directory.  
  77.                 if (!ResourceUtils.isUrl(location)) {  
  78.                     // Resolve system property placeholders before resolving real path.  
  79.                     location = SystemPropertyUtils.resolvePlaceholders(location);  
  80.                     location = WebUtils.getRealPath(servletContext, location);  
  81.                 }  
  82.   
  83.                 // Write log message to server log.  
  84.                 //初始化log  
  85.                 servletContext.log("Initializing Log4J from [" + location + "]");  
  86.   
  87.                 // Check whether refresh interval was specified.  
  88.                 // REFRESH_INTERVAL_PARAM equals the refresh interval for checking the Log4J config file  
  89.                 String intervalString = servletContext.getInitParameter(REFRESH_INTERVAL_PARAM);  
  90.                 if (intervalString != null) {  
  91.                     // Initialize with refresh interval, i.e. with Log4J's watchdog thread,  
  92.                     // checking the file in the background.  
  93.                     try {  
  94.                         long refreshInterval = Long.parseLong(intervalString);  
  95.                         Log4jConfigurer.initLogging(location, refreshInterval);  
  96.                     }  
  97.                     catch (NumberFormatException ex) {  
  98.                         throw new IllegalArgumentException("Invalid 'log4jRefreshInterval' parameter: " + ex.getMessage());  
  99.                     }  
  100.                 }  
  101.                 else {  
  102.                     // Initialize without refresh check, i.e. without Log4J's watchdog thread.  
  103.                     Log4jConfigurer.initLogging(location);  
  104.                 }  
  105.             }  
  106.             catch (FileNotFoundException ex) {  
  107.                 throw new IllegalArgumentException("Invalid 'log4jConfigLocation' parameter: " + ex.getMessage());  
  108.             }  
  109.         }  
  110.     }  
  111.   
  112.     /** 
  113.      * Return whether to expose the web app root system property, 
  114.      * checking the corresponding ServletContext init parameter. 
  115.      * @see #EXPOSE_WEB_APP_ROOT_PARAM 
  116.      */  
  117.     //返回是否暴露web app root system property  
  118.     //get the "log4jExposeWebAppRoot" para from web.xml  
  119.     private static boolean exposeWebAppRoot(ServletContext servletContext) {  
  120.         String exposeWebAppRootParam = servletContext.getInitParameter(EXPOSE_WEB_APP_ROOT_PARAM);  
  121.         return (exposeWebAppRootParam == null || Boolean.valueOf(exposeWebAppRootParam).booleanValue());  
  122.     }  
  123.   
  124. }  
  125. WebUtils.java  
  126.   
  127. public abstract class WebUtils {  
  128.   
  129.     /** 
  130.      * Standard Servlet 2.3+ spec request attributes for include URI and paths. 
  131.      * 
  132.  
  133. If included via a RequestDispatcher, the current resource will see the 
  134.      * originating request. Its own URI and paths are exposed as request attributes. 
  135.      */  
  136.     public static final String INCLUDE_REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";  
  137.     public static final String INCLUDE_CONTEXT_PATH_ATTRIBUTE = "javax.servlet.include.context_path";  
  138.     public static final String INCLUDE_SERVLET_PATH_ATTRIBUTE = "javax.servlet.include.servlet_path";  
  139.     public static final String INCLUDE_PATH_INFO_ATTRIBUTE = "javax.servlet.include.path_info";  
  140.     public static final String INCLUDE_QUERY_STRING_ATTRIBUTE = "javax.servlet.include.query_string";  
  141.   
  142.     /** 
  143.      * Standard Servlet 2.4+ spec request attributes for forward URI and paths. 
  144.      * 
  145.  
  146. If forwarded to via a RequestDispatcher, the current resource will see its 
  147.      * own URI and paths. The originating URI and paths are exposed as request attributes. 
  148.      */  
  149.     public static final String FORWARD_REQUEST_URI_ATTRIBUTE = "javax.servlet.forward.request_uri";  
  150.     public static final String FORWARD_CONTEXT_PATH_ATTRIBUTE = "javax.servlet.forward.context_path";  
  151.     public static final String FORWARD_SERVLET_PATH_ATTRIBUTE = "javax.servlet.forward.servlet_path";  
  152.     public static final String FORWARD_PATH_INFO_ATTRIBUTE = "javax.servlet.forward.path_info";  
  153.     public static final String FORWARD_QUERY_STRING_ATTRIBUTE = "javax.servlet.forward.query_string";  
  154.   
  155.   
  156.     /** 
  157.      * Prefix of the charset clause in a content type String: ";charset=" 
  158.      */  
  159.     public static final String CONTENT_TYPE_CHARSET_PREFIX = ";charset=";  
  160.   
  161.     /** 
  162.      * Default character encoding to use when request.getCharacterEncoding 
  163.      * returns null, according to the Servlet spec. 
  164.      * @see ServletRequest#getCharacterEncoding 
  165.      */  
  166.     public static final String DEFAULT_CHARACTER_ENCODING = "ISO-8859-1";  
  167.   
  168.     /** 
  169.      * Standard Servlet spec context attribute that specifies a temporary 
  170.      * directory for the current web application, of type java.io.File. 
  171.      */  
  172.     public static final String TEMP_DIR_CONTEXT_ATTRIBUTE = "javax.servlet.context.tempdir";  
  173.   
  174.     /** 
  175.      * HTML escape parameter at the servlet context level 
  176.      * (i.e. a context-param in web.xml): "defaultHtmlEscape". 
  177.      */  
  178.     public static final String HTML_ESCAPE_CONTEXT_PARAM = "defaultHtmlEscape";  
  179.   
  180.     /** 
  181.      * Web app root key parameter at the servlet context level 
  182.      * (i.e. a context-param in web.xml): "webAppRootKey". 
  183.      */  
  184.     public static final String WEB_APP_ROOT_KEY_PARAM = "webAppRootKey";  
  185.   
  186.     /** Default web app root key: "webapp.root" */  
  187.     public static final String DEFAULT_WEB_APP_ROOT_KEY = "webapp.root";  
  188.   
  189.     /** Name suffixes in case of image buttons */  
  190.     public static final String[] SUBMIT_IMAGE_SUFFIXES = {".x", ".y"};  
  191.   
  192.     /** Key for the mutex session attribute */  
  193.     public static final String SESSION_MUTEX_ATTRIBUTE = WebUtils.class.getName() + ".MUTEX";  
  194.      
  195.     /** 
  196.      * Set a system property to the web application root directory. 
  197.      * The key of the system property can be defined with the "webAppRootKey" 
  198.      * context-param in web.xml. Default is "webapp.root". 
  199.      * 
  200.  
  201. Can be used for tools that support substition with System.getProperty 
  202.      * values, like Log4J's "${key}" syntax within log file locations. 
  203.      * @param servletContext the servlet context of the web application 
  204.      * @throws IllegalStateException if the system property is already set, 
  205.      * or if the WAR file is not expanded 
  206.      * @see #WEB_APP_ROOT_KEY_PARAM 
  207.      * @see #DEFAULT_WEB_APP_ROOT_KEY 
  208.      * @see WebAppRootListener 
  209.      * @see Log4jWebConfigurer 
  210.      */  
  211.     /**把当前的项目的路径放到System属性参数中，供以后调用，其中key值为web.xml 
  212.         
  213.         webAppRootKey 
  214.         fms.root 
  215.         
  216.     */  
  217.     public static void setWebAppRootSystemProperty(ServletContext servletContext) throws IllegalStateException {  
  218.         Assert.notNull(servletContext, "ServletContext must not be null");  
  219.         String root = servletContext.getRealPath("/");// 项目路径  
  220.         if (root == null) {  
  221.             throw new IllegalStateException(  
  222.                 "Cannot set web app root system property when WAR file is not expanded");  
  223.         }  
  224.         String param = servletContext.getInitParameter(WEB_APP_ROOT_KEY_PARAM);  
  225.         String key = (param != null ? param : DEFAULT_WEB_APP_ROOT_KEY);  
  226.         String oldValue = System.getProperty(key);  
  227.         if (oldValue != null && !StringUtils.pathEquals(oldValue, root)) {  
  228.             throw new IllegalStateException(  
  229.                 "Web app root system property already set to different value: '" +  
  230.                 key + "' = [" + oldValue + "] instead of [" + root + "] - " +  
  231.                 "Choose unique values for the 'webAppRootKey' context-param in your web.xml files!");  
  232.         }  
  233.         System.setProperty(key, root);  
  234.         servletContext.log("Set web app root system property: '" + key + "' = [" + root + "]");  
  235.     }  
  236. }  


In a word ,if you want to use the Log4jConfigListener ,
there are several context params need to config in web.xml as follows:
1,webAppRootKey，项目名称
2,log4jExposeWebAppRoot, whether to expose the webAppRootKey to  the System,是否将webAppRootKey.value这个属性暴露给System,
也就是否可以用System.getProperty(webAppRootKey.value)获得项目名称
3，log4jRefreshInterval，Parameter specifying the refresh interval for checking the Log4J config file
4，log4jConfigLocation，Parameter specifying the place where you can find log4j.properties.
返回顶楼
         
论坛首页 → 入门技术版

跳转论坛:
Global site tag (gtag.js) - Google Analytics