Java: Logging API
Sumber: http://www.vogella.de/articles/Logging/article.html
Tulisan ini menjelaskan bagaimana cara menggunakan API di program Java. Termasuk cara membuat logger HTML.
Logging di Java
Dalam JDK terdapat "Java Logging API". Melalui sebuah logger kita dapat menyimpan text ke lokasi yang terpusat untuk menulis laporan saat terjadi error, memberikan informasi tambahan tentang program kita, dll. Melalui logging API memungkinkan konfigurasi bagaimana message di tulis dengan class yang mana dengan prioritas yang mana.
Membuat sebuah Logger
Paket java.util.logging memberikan kemampuan logging melalui class Logger.
Untuk membuat sebuah logger di source code java yang kita buat
import java.util.logging.Logger; private final static Logger LOGGER = Logger.getLogger(MyClass.class .getName());
Level
The log levels define the severity of a message. The class Level is used to define which messages should be written to the log.
Die Log Levels in descending order are:
SEVERE (highest) WARNING INFO CONFIG FINE FINER FINEST
In addition to that you have also the levels OFF and ALL to turn the logging of or to log everything.
For example the following will set the logger to level info which means all messages with severe, warning and info will be logged.
LOGGER.setLevel(Level.INFO);
Handler
Each logger can have access to several handler.
The handler receives the log message from the logger and exports it to a certain target
A handler can be turn off with setLevel(Level.OFF) and turned on with setLevel(...)
You have several standard handler, e.g.
ConsoleHandler: Write the log message to console FileHandler: Writes the log message to file
Log Levels INFO and higher will be automatically written to the console.
Formatter
Each handlers output can be configured with a formatter
Available formatter
SimpleFormatter Generate all messages as text XMLFormatter Generates XML output for the log messages
You can also build your own formatter. The following is an example of a formatter which will use create HTML output.
package logging;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
//This custom formatter formats parts of a log record to a single line
class MyHtmlFormatter extends Formatter
{
// This method is called for every log records
public String format(LogRecord rec)
{
StringBuffer buf = new StringBuffer(1000);
// Bold any levels >= WARNING
buf.append(""); buf.append("");
if (rec.getLevel().intValue() >= Level.WARNING.intValue())
{
buf.append("");
buf.append(rec.getLevel());
buf.append("");
} else
{
buf.append(rec.getLevel());
}
buf.append(""); buf.append("");
buf.append(calcDate(rec.getMillis()));
buf.append(' ');
buf.append(formatMessage(rec));
buf.append('\n');
buf.append(""); buf.append("\n"); return buf.toString(); } private String calcDate(long millisecs) { SimpleDateFormat date_format = new SimpleDateFormat("MMM dd,yyyy HH:mm"); Date resultdate = new Date(millisecs); return date_format.format(resultdate); } // This method is called just after the handler using this // formatter is created public String getHead(Handler h) { return "<HTML>\n<HEAD>\n" + (new Date()) + "\n</HEAD>\n<BODY>\n
\n"
+ "<table border>\n "
+ "<tr><th>Time</th><th>Log Message</th></tr>\n";
}
// This method is called just after the handler using this
// formatter is closed
public String getTail(Handler h)
{
return "</table>\n </BODY>\n</HTML>\n";
} }
Log Manager
The log manager is responsible for creating and managing the logger and the maintenance of the configuration.
We could set the logging level for a package, or even a set of packages, by calling the LogManager.setLevel(String name, Level level) method. So, for example, we could set the logging level of all loggers "logging" to Level.FINE by making this call:
LogManager.getLogManager().setLevel("logging", Level.FINE)
Best Practices
It is common practice to use the fully qualified name of each class whose activity is being logged as a message category because this allows developers to fine-tune log settings for each class.
Using the fully qualified class name of your class as the name of your Logger is the approach recommended by the Logging API documentation.
Example
This example is stored in the project "de.vogella.logger".
Create your own formatter.
package logging;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
//This custom formatter formats parts of a log record to a single line
class MyHtmlFormatter extends Formatter
{
// This method is called for every log records
public String format(LogRecord rec)
{
StringBuffer buf = new StringBuffer(1000);
// Bold any levels >= WARNING
buf.append(""); buf.append("");
if (rec.getLevel().intValue() >= Level.WARNING.intValue())
{
buf.append("");
buf.append(rec.getLevel());
buf.append("");
} else
{
buf.append(rec.getLevel());
}
buf.append(""); buf.append("");
buf.append(calcDate(rec.getMillis()));
buf.append(' ');
buf.append(formatMessage(rec));
buf.append('\n');
buf.append(""); buf.append("\n"); return buf.toString(); } private String calcDate(long millisecs) { SimpleDateFormat date_format = new SimpleDateFormat("MMM dd,yyyy HH:mm"); Date resultdate = new Date(millisecs); return date_format.format(resultdate); } // This method is called just after the handler using this // formatter is created public String getHead(Handler h) { return "<HTML>\n<HEAD>\n" + (new Date()) + "\n</HEAD>\n<BODY>\n
\n"
+ "<table border>\n "
+ "<tr><th>Time</th><th>Log Message</th></tr>\n";
}
// This method is called just after the handler using this
// formatter is closed
public String getTail(Handler h)
{
return "</table>\n </BODY>\n</HTML>\n";
} }
Initialize the logger.
package logging;
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
public class MyLogger {
static private FileHandler fileTxt;
static private SimpleFormatter formatterTxt;
static private FileHandler fileHTML;
static private Formatter formatterHTML;
static public void setup() throws IOException {
// Create Logger
Logger logger = Logger.getLogger("");
logger.setLevel(Level.INFO);
fileTxt = new FileHandler("Logging.txt");
fileHTML = new FileHandler("Logging.html");
// Create txt Formatter
formatterTxt = new SimpleFormatter();
fileTxt.setFormatter(formatterTxt);
logger.addHandler(fileTxt);
// Create HTML Formatter
formatterHTML = new MyHtmlFormatter();
fileHTML.setFormatter(formatterHTML);
logger.addHandler(fileHTML);
}
}
Use the logger.
package logging;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class UseLogger {
// Always use the classname, this way you can refactor
private final static Logger LOGGER = Logger.getLogger(UseLogger.class
.getName());
public void writeLog() {
// Set the LogLevel to Severe, only severe Messages will be written
LOGGER.setLevel(Level.SEVERE);
LOGGER.severe("Info Log");
LOGGER.warning("Info Log");
LOGGER.info("Info Log");
LOGGER.finest("Really not important");
// Set the LogLevel to Info, severe, warning and info will be written
// Finest is still not written
LOGGER.setLevel(Level.INFO);
LOGGER.severe("Info Log");
LOGGER.warning("Info Log");
LOGGER.info("Info Log");
LOGGER.finest("Really not important");
}
public static void main(String[] args) {
UseLogger logger = new UseLogger();
try {
MyLogger.setup();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("Problems with creating the log files");
}
logger.writeLog();
}
}