JAVA学习脚印 :日志文件的使用

JAVA学习脚印 :日志文件的使用

1.日志用途

     设计日志API主要是为了给像servlet, applet, EJB,等java应用，产生对于终端用户

系统管理员、领域工程师和软件开发者提供他们感兴趣的信息。

     尤其在软件产品中，程序不能在调试器中运行，或者在调试器中运行时掩盖了一些在实际运行时出现的问题（例如与时间相关的问题）. 因此对于程序来说，日志文件通常是一个包含其运行信息的一大资源。

   简而言之，日志记录了那些不可预料的异常，可供软件开发与维护的相关人员分析，来更好的调整和改善系统。

2.java日志工作机制

2.1 java日志特点

   为了确保在软件产品中使用日志,java的这些API尽量使记录日志经济可行,且不降低软件正常使用时速度，这些API都具有以下几个特点:

1)可以动态地调整记录的内容，打开、取消或者关闭日志记录

2)可以被定向到不同处理器，以不同形式处理记录，例如输出到控制台，写入到文件

3)可以过滤日志记录，也可以将日志记录格式化为不同格式，例如文本或者xml

4)可以灵活的配置日志系统，可以使用多个日志记录器，允许定制个性化记录方式

简而言之，日志API的目标就是要满足: 功能齐全，灵活使用，效率高。

2.2 日志级别

java记录器，有7个记录级别，如下表所示。在默认情况下只有前三个级别，可以通过:setLevel函数设置。

注意，记录器级别有一个特点，只记录当前级别及以上级别的记录。

也就是说，logger.setLevel(Level.FINE)的话，只有FINE和更高级别的记录被记录下来，其余被忽视。另外还有两个辅助级别OFF用来关闭日志记录， ALL则表示记录一切内容。




Logging   levels (降序排列)
SEVERE	The highest value;intended for extremely important messages (e.g. fatal programerrors). (严重，最高级别)
WARNING	Intended for warningmessages.
INFO	Informational runtimemessages.
CONFIG	Informational messagesabout configuration settings/setup.
FINE	Used for greater detail,when debugging/diagnosing problems.
FINER	Even greater detail.
FINEST	The lowest value;greatest detail. (最低级别)

(表格来源:http://www.onjava.com/pub/a/onjava/2002/06/19/log.html?page=1)

2.3 Logger与Handler

日志记录器(Logger)可以对应多个处理器(Handler)，每个处理器接受日志消息并按自己的方式处理它。

日志记录器与处理器的关系如下图所示:

Handler的继承关系如下:

java.util.logging.Handler

• java.util.logging.MemoryHandler

• java.util.logging.StreamHandler

  • java.util.logging.ConsoleHandler

  • java.util.logging.FileHandler

  • java.util.logging.SocketHandler

注意，对于一个要被记录的日志记录，它的日志记录级别必须高于日志记录器和处理器的阀值。

默认情况下，日志记录器会将记录发送给自己的处理器和父处理器，最终的处理器命名为""(即空串),它有一个ConsoleHandler。可以使用SetUseParentHandlers(boolean flag)来设置是否启用父处理器。

2.4 Logger与Formatter

内置的处理器ConsoleHandler和FileHandler类可以生成文本和XML格式的日志记录，但是也可以自定义日志格式。

通过继承java.util.logging.Formatter类并覆盖

String format(LogRecord record)

方法来按照自己定义方式对信息进行格式化。另外可能会调用

String     formatMessage(LogRecord record)

方法来完成LogRecord格式化，或者需要在格式化后文件提供额外头部时使用
String     getHead(Handler h)
String     getTail(Handler h)

方法。具体参见案例代码部分。

2.5 Logger与 filter

每个日志记录器和处理器可以有一个可选的过滤器来完成附加的过滤，另外也可以通过Filter接口自定义过滤器。

该接口只有一个方法:

boolean isLoggable(LogRecord record) 用来筛选那些信息需要被记录。

注意，同一时刻只能有一个过滤器。

2.6 LogManager 

LogManager用来创建和管理记录器，并维护配置文件(可以通过配置文件，修改日志记录器的级别等)。

日志管理器控制着那些内容被记录，在哪里记录。通过

LogManager.setLevel(String name, Level level) 方法
它可以设置一个包或一系列包的记录级别。

例如: LogManager.getLogManager().setLevel("com.learningjava", Level.FINE);设置了com.learningjava包中的每个记录器被设置为FINE级别。

2.7 使用日志的案例代码

下面的案例示例了自定义处理器，格式化器，过滤器的使用。

[java] view plain copy print ?

1. package com.learningjava;  
2.   
3. import java.util.*;  
4. import java.util.logging.*;  
5. import java.util.logging.Formatter;  
6. import java.io.*;  
7. import java.text.SimpleDateFormat;  
8. import javax.swing.*;  
9.   
10. /** 
11.  * this program demonstrate using Log API 
12.  */  
13.   
14. public class LoggingDemo7 {  
15.     public static void main(String[] args) {  
16.   
17.         //use global logger  
18.         Logger logger = Logger.getGlobal();  
19.         logger.setLevel(Level.INFO);  
20.         logger.info("using assert ");  
21.         assert (logger.getLevel() == Level.INFO);  
22.           
23.         //user define logger  
24.         Logger myLogger = Logger.getLogger("com.learningjava");  
25.         myLogger.setLevel(Level.ALL);  
26.         try {  
27.           
28.             //using userdefine Window Handler  
29.             WindowHandler windowHandler = new WindowHandler();  
30.             windowHandler.setLevel(Level.ALL);  
31.             myLogger.addHandler(windowHandler);  
32.               
33.             //use simple fomatter in plain text  
34.             FileHandler fileTxt = new FileHandler("Logging.txt");  
35.             fileTxt.setFormatter(new SimpleFormatter());  
36.             fileTxt.setLevel(Level.INFO);  
37.               
38.             //use user define filter  
39.             fileTxt.setFilter(new MyWeekdayFilter());  
40.             myLogger.addHandler(fileTxt);  
41.               
42.             //user define formatter in html  
43.             FileHandler fileHTML = new FileHandler("Logging.html");  
44.             fileHTML.setFormatter(new MyHtmlFormatter());  
45.             fileHTML.setLevel(Level.ALL);  
46.             myLogger.addHandler(fileHTML);  
47.               
48.             //default formatter in xml  
49.             FileHandler fileXML = new FileHandler("Logging.xml");  
50.             fileTxt.setLevel(Level.ALL);  
51.             myLogger.addHandler(fileXML);  
52.               
53.         } catch (SecurityException e) {  
54.             e.printStackTrace();  
55.         } catch (IOException e) {  
56.             e.printStackTrace();  
57.         }  
58.         //use console handler  
59.         myLogger.setUseParentHandlers(true);  
60.         myLogger.info("out of main");  
61.     }  
62. }  
63. /** 
64.  * custom Handler : a window Handler 
65.  * @author  Cay s.Horstmann 
66.  */  
67. class WindowHandler extends StreamHandler {  
68.     public WindowHandler() {  
69.         frame = new JFrame("Viewing Log");  
70.         final JTextArea output= new JTextArea();  
71.         output.setEditable(false);  
72.         frame.setSize(300, 200);  
73.         frame.add(new JScrollPane(output));  
74.         frame.setFocusableWindowState(false);  
75.         frame.setLocationRelativeTo(null);  
76.         frame.setVisible(true);  
77.         this.setOutputStream(new OutputStream(){  
78.   
79.             @Override  
80.             public void write(int b) throws IOException {  
81.             }  
82.             @Override  
83.             public void write(byte[] b, int off, int len) {  
84.                 output.append(new String(b,off,len));  
85.             }  
86.         });  
87.           
88.     }  
89.     @Override  
90.     public void publish(LogRecord record) {  
91.         if(!frame.isVisible()) return;  
92.         super.publish(record);  
93.         flush();  
94.     }  
95.     private JFrame frame;  
96. }  
97. /** 
98.  * Custom formatter : in html 
99.  * @author Lars Vogel 
100. */  
101.   
102. class MyHtmlFormatter extends Formatter {  
103.   
104.   // This method is called for every log records  
105.   public String format(LogRecord rec) {  
106.     StringBuffer buf = new StringBuffer(1000);  
107.     buf.append("<tr>");  
108.     buf.append("<td>");  
109.     if (rec.getLevel().intValue() >= Level.WARNING.intValue()) {  
110.       buf.append("<b>");// Bold any levels >= WARNING  
111.       buf.append(rec.getLevel());  
112.       buf.append("</b>");  
113.     } else {  
114.       buf.append(rec.getLevel());  
115.     }  
116.     buf.append("</td>");  
117.     buf.append("<td>");  
118.     buf.append(calcDate(rec.getMillis()));  
119.     buf.append('\n');  
120.     buf.append("</td>");  
121.     buf.append("<td>");  
122.     buf.append(' ');  
123.     buf.append(formatMessage(rec));//correct it  
124.     buf.append("</td>");  
125.     buf.append("</tr>\n");  
126.     return buf.toString();  
127.   }  
128.   
129.   private String calcDate(long millisecs) {  
130.     SimpleDateFormat date_format = new SimpleDateFormat("MMM dd,yyyy HH:mm");  
131.     Date resultdate = new Date(millisecs);  
132.     return date_format.format(resultdate);  
133.   }  
134.   /** 
135.    * This method is called just after the handler using this 
136.    * formatter is created 
137.    */  
138.   public String getHead(Handler h) {  
139.   
140.     return "<HTML>\n<HEAD>\n" + (new Date())   
141.         + "\n</HEAD>\n<BODY>\n<PRE>\n"  
142.         + "<table width=\"100%\" border>\n  "  
143.         + "<tr><th>Level</th>" +  
144.         "<th>Time</th>" +  
145.         "<th>Log Message</th>" +  
146.         "</tr>\n";  
147.   }  
148.   /** 
149.    * This method is called just after the handler using this 
150.    * formatter is closed 
151.    */  
152.   public String getTail(Handler h) {  
153.     return "</table>\n  </PRE></BODY>\n</HTML>\n";  
154.   }  
155. }   
156. /** 
157.  * a filter only log weekday record 
158.  * @author wangdq 
159.  */  
160. class MyWeekdayFilter implements Filter {  
161.   
162.     @Override  
163.     public boolean isLoggable(LogRecord record) {  
164.           
165.         //get time form record  
166.         GregorianCalendar cal = new GregorianCalendar();  
167.         cal.setTimeInMillis(record.getMillis());  
168.         int weekday = cal.get(Calendar.DAY_OF_WEEK);  
169.         //check if it is weekend  
170.         if(weekday == Calendar.SATURDAY || weekday == Calendar.SUNDAY) {  
171.             return false;  
172.         } else {  
173.             return true;  
174.         }  
175.     }  
176. }  

3. 使用日志细节

1)java API规范建议使用类的全名来构造记录器，例如:

Logger LOGGER = Logger.getLogger(MyClass.class .getName()); 

2)SocketHandler可以将日志记录发往制定地址的log服务器，

需要配置服务器，在这里未列出。

3)日志记录还有关于权限的问题，未作介绍。

4）日志记录还有关于本地化部分，未作介绍。

4.参考资料

[1]:Java Logging API - Tutorial  

http://www.vogella.com/articles/Logging/article.html#general_manager

[2]:An Introduction to the Java Logging API

http://www.onjava.com/pub/a/onjava/2002/06/19/log.html?page=2

[3]:《java核心技术：卷一》