Java/Language Basics/Log

Материал из Java эксперт
Перейти к: навигация, поиск

Содержание

A file handler that appends.

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean append = true;
   FileHandler handler = new FileHandler("my.log", append);
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(handler);
 }

} 


 </source>



Alternate XML by using FileHandler

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   FileHandler handler = new FileHandler("alterxml.xml");
   Logger logger = Logger.getLogger("your.logging");
   logger.addHandler(handler);
   logger.log(Level.INFO, "alternative xml");
 }

} 


 </source>



An example of a program providing the functionality of logging

   <source lang="java">

import java.util.logging.Logger; public class Main{ 

 public static void main(String[] args) {
   Logger log = Logger.getLogger("com.mycompany.BasicLogging");
   log.severe("severe message");
   log.warning("warning message");
   log.info("info message");
   log.config("config message");
   log.fine("fine level one message");
   log.finer("fine level two message");
   log.finest("fine level three message");
 }

} 


 </source>



A simple wrapper around JDK logging facilities

   <source lang="java">

/*** 

*    This program is free software; you can redistribute it and/or modify
*    it under the terms of the GNU General Public License as published by
*    the Free Software Foundation; either version 2 of the License, or
*    (at your option) any later version.
*
*    This program is distributed in the hope that it will be useful,
*    but WITHOUT ANY WARRANTY; without even the implied warranty of
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*    GNU General Public License for more details.
*
*    You should have received a copy of the GNU General Public License
*    along with this program; if not, write to the Free Software
*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*    Project: www.simpledbm.org
*    Author : Dibyendu Majumdar
*    Email  : dibyendu@mazumdar.demon.co.uk
*/

import java.io.FileInputStream; import java.io.IOException; import java.util.logging.Level; import java.util.logging.LogManager; /** 

* A simple wrapper around JDK logging facilities. The aim is to allow 
* easy switch to another logging system, such as Log4J.
* 
* @author Dibyendu Majumdar
*/

public final class Logger { 

 /**
  * Instance of the real logger object.
  */
 private final java.util.logging.Logger realLogger;
 
 /**
  * Obtain a new or existing Logger instance. 
  * @param name Name of the logger, package names are recommended
  */
 public static Logger getLogger(String name) {
   return new Logger(name);
 }
 
 public static void configure(String filename) {
   FileInputStream is = null; 
   try {
     is = new FileInputStream(filename);
     LogManager.getLogManager().readConfiguration(is);
   }
   catch (Exception e) {
     System.err.println("SIMPLEDBM-ERROR: Failed to initialize logging system due to following error: " + e.getMessage());
     e.printStackTrace();
   }
   finally {
     try {
       is.close();
     } catch (IOException e) {}
   }
 }
 
 public Logger(String name) {
   realLogger = java.util.logging.Logger.getLogger(name);
 }
 
 public void info(String sourceClass, String sourceMethod, String message) {
   realLogger.logp(Level.INFO, sourceClass, sourceMethod, message);
 }
 
 public void info(String sourceClass, String sourceMethod, String message, Throwable thrown) {
   realLogger.logp(Level.INFO, sourceClass, sourceMethod, message, thrown);
 }
 
 public void debug(String sourceClass, String sourceMethod, String message) {
   realLogger.logp(Level.FINE, sourceClass, sourceMethod, message);
 }
 
 public void debug(String sourceClass, String sourceMethod, String message, Throwable thrown) {
   realLogger.logp(Level.FINE, sourceClass, sourceMethod, message, thrown);
 }
 public void trace(String sourceClass, String sourceMethod, String message) {
   realLogger.logp(Level.FINER, sourceClass, sourceMethod, message);
 }
 
 public void trace(String sourceClass, String sourceMethod, String message, Throwable thrown) {
   realLogger.logp(Level.FINER, sourceClass, sourceMethod, message, thrown);
 }
 
 public void warn(String sourceClass, String sourceMethod, String message) {
   realLogger.logp(Level.WARNING, sourceClass, sourceMethod, message);
 }
 
 public void warn(String sourceClass, String sourceMethod, String message, Throwable thrown) {
   realLogger.logp(Level.WARNING, sourceClass, sourceMethod, message, thrown);
 }
 public void error(String sourceClass, String sourceMethod, String message) {
   realLogger.logp(Level.SEVERE, sourceClass, sourceMethod, message);
 }
 public void error(String sourceClass, String sourceMethod, String message, Throwable thrown) {
   realLogger.logp(Level.SEVERE, sourceClass, sourceMethod, message, thrown);
 }
 
 public boolean isTraceEnabled() {
   return realLogger.isLoggable(Level.FINER);
 }
 public boolean isDebugEnabled() {
   return realLogger.isLoggable(Level.FINE);
 }
 
 public void enableDebug() {
   realLogger.setLevel(Level.FINE);
 }
 public void disableDebug() {
   realLogger.setLevel(Level.INFO);
 }

} 

 </source>



Basic Logging Example

   <source lang="java">

import java.util.logging.*; public class BasicLoggingExample { 

   public static void main(String args[])
   {
       Logger logger = Logger.getLogger("BasicLoggingExample");
       logger.log(Level.INFO, "Test of logging system");
   }

} 



 </source>



Comparing Log Levels: To compare the severity of two logging levels, use Level.intValue().

   <source lang="java">

import java.util.logging.Level; public class Main { 

 public static void main(String[] argv) throws Exception {
   Level level1 = Level.INFO;
   Level level2 = Level.CONFIG;
   if (level1.intValue() > level2.intValue()) {
     System.out.println("level1 is more severe");
   } else if (level1.intValue() < level2.intValue()) {
     System.out.println("level2 is more severe");
   } else {
     System.out.println("level1 == level2");
   }
 }

} 


 </source>



Config Demo

   <source lang="java">

import java.util.logging.Logger; import java.util.logging.SocketHandler; public class Main { 

 public static void main(String args[])throws Exception {
   Logger logger = Logger.getLogger("logging");
   logger.addHandler(new SocketHandler());
   logger.warning("SocketHandler is working...");
 }

} 


 </source>



config.properties

   <source lang="java">
  1. define the logger level

your.logging.level=INFO 


 </source>



Configure Logging

   <source lang="java">

// : c15:ConfigureLogging.java //{JVMArgs: -Djava.util.logging.config.file=log.prop} //{Clean: java0.log,java0.log.lck} //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Logger; public class ConfigureLogging { 

 static Logger lgr = Logger.getLogger("com"), lgr2 = Logger
     .getLogger("com.bruceeckel"), util = Logger
     .getLogger("com.bruceeckel.util"), test = Logger
     .getLogger("com.bruceeckel.test"), rand = Logger
     .getLogger("random");
 public ConfigureLogging() {
   /*
    * Set Additional formatters, Filters and Handlers for the loggers here.
    * You cannot specify the Handlers for loggers except the root logger
    * from the configuration file.
    */
 }
 public static void main(String[] args) {
   sendLogMessages(lgr);
   sendLogMessages(lgr2);
   sendLogMessages(util);
   sendLogMessages(test);
   sendLogMessages(rand);
 }
 private static void sendLogMessages(Logger logger) {
   System.out.println(" Logger Name : " + logger.getName() + " Level: "
       + logger.getLevel());
   logger.finest("Finest");
   logger.finer("Finer");
   logger.fine("Fine");
   logger.config("Config");
   logger.info("Info");
   logger.warning("Warning");
   logger.severe("Severe");
 }

} ///:~ 



 </source>



Configuring Logger Default Values with a Properties File

   <source lang="java">
  1. The following creates two handlers

handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler

  1. Set the default logging level for the root logger

.level = ALL

  1. Set the default logging level for new ConsoleHandler instances

java.util.logging.ConsoleHandler.level = INFO

  1. Set the default logging level for new FileHandler instances

java.util.logging.FileHandler.level = ALL

  1. Set the default formatter for new ConsoleHandler instances

java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

  1. Set the default logging level for the logger named com.mycompany

com.mycompany.level = ALL The custom logging properties file is loaded by specifying a system property on the command line: java -Djava.util.logging.config.file=mylogging.properties <class> 


 </source>



Create a memory handler with a memory of 100 records and dumps the records into the file my.log

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class Main { 

 public static void main(String[] argv) throws Exception {
   FileHandler fhandler = new FileHandler("my.log");
   int numRec = 100;
   MemoryHandler mhandler = new MemoryHandler(fhandler, numRec, Level.OFF) {
     public synchronized void publish(LogRecord record) {
       super.publish(record);
       push();
     }
   };
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(mhandler);
 }

} 


 </source>



Create log with package name

   <source lang="java">

import org.apache.log4j.*; public class SimpleLogging { 

   public static void main(String[] args) {
       Logger logger = Logger.getLogger(SimpleLogging.class.getPackage().getName());
       logger.info("Hello this is an info message");
   }

} 


 </source>



Creating a Custom Formatter for a Logger Handler

   <source lang="java">

import java.util.Date; import java.util.logging.FileHandler; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; class MyHtmlFormatter extends Formatter { 

 public String format(LogRecord rec) {
   StringBuffer buf = new StringBuffer(1000);
   if (rec.getLevel().intValue() >= Level.WARNING.intValue()) {
     buf.append("");
     buf.append(rec.getLevel());
     buf.append("");
   } else {
     buf.append(rec.getLevel());
   }
   buf.append(" ");
   buf.append(rec.getMillis());
   buf.append(" ");
   buf.append(formatMessage(rec));
   buf.append("\n");
   return buf.toString();
 }
 public String getHead(Handler h) {
return "<HTML><HEAD>" + (new Date()) + "</HEAD><BODY>
\n";
  }
  public String getTail(Handler h) {
    return "
</BODY></HTML>\n"; 
 }

} public class Main { 

 public static void main(String[] argv) throws Exception {
   Logger logger = Logger.getLogger("com.mycompany");
   FileHandler fh = new FileHandler("mylog.html");
   fh.setFormatter(new MyHtmlFormatter());
   logger.addHandler(fh);
   logger.setLevel(Level.ALL);
   logger.severe("my severe message");
   logger.info("my info message");
   logger.entering("Main class", "myMethod", new Object[] { "para1", "para2" });
 }

} 


 </source>



Creating a Custom Log Level

   <source lang="java">

import java.util.logging.Level; import java.util.logging.Logger; class MyLevel extends Level { 

 public static final Level DISASTER = new MyLevel("DISASTER", Level.SEVERE.intValue() + 1);
 public MyLevel(String name, int value) {
   super(name, value);
 }

} public class Main { 

 public static void main(String[] argv) throws Exception {
   Logger logger = Logger.getLogger("com.mycompany");
   logger.log(MyLevel.DISASTER, "my disaster message");
   Level disaster = Level.parse("DISASTER");
   logger.log(disaster, "my disaster message");
 }

} 


 </source>



Custom filter

   <source lang="java">

import java.util.logging.Filter; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; class Person { 

 private String name = null;
 private int age;
 public Person(String name, int age) {
   this.name = name;
   this.age = age;
 }
 public void setName(String name) {
   this.name = name;
 }
 public String getName() {
   return name;
 }
 public void setAge(int age) {
   this.age = age;
 }
 public int getAge() {
   return age;
 }

} class AgeFilter implements Filter { 

 public boolean isLoggable(LogRecord record) {
   boolean result = false;
   Object[] objs = record.getParameters();
   Person person = (Person) objs[0];
   if (person != null) {
     int age = person.getAge();
     if (age > 30)
       result = true;
     else
       result = false;
   }
   return result;
 }

} public class Main { 

 public static void main(String args[]) {
   Logger logger = Logger.getLogger("your.logging");
   AgeFilter filter = new AgeFilter();
   logger.setFilter(filter);
   Person person = new Person("YourName", 32);
   logger.log(Level.INFO, "Person has age " + person.getAge(), person);
 }

} 


 </source>



#define the properties for the SocketHandler

   <source lang="java">

java.util.logging.SocketHandler.level=INFO java.util.logging.SocketHandler.host=localhost java.util.logging.SocketHandler.port=2020 


 </source>



Define your own Custom Formatter

   <source lang="java">

import java.util.logging.Formatter; import java.util.logging.LogRecord; public class CustomFormatter extends Formatter { 

 public synchronized String format(LogRecord record) {
   String methodName = record.getSourceMethodName();
   String message = record.getMessage();
   StringBuffer buffer = new StringBuffer(50);
   buffer.append(methodName);
   buffer.append("=");
   buffer.append(message);
   return buffer.toString();
 }

} 


 </source>



Determining If a Message Will Be Logged

   <source lang="java">

import java.util.logging.Level; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   Logger logger = Logger.getLogger("com.mycompany.MyClass");
   // Check if the message will be logged
   if (logger.isLoggable(Level.FINEST)) {
     logger.finest("my finest message");
   }
 }

} 


 </source>



Determining When the Logging Configuration Properties are Reread

   <source lang="java">

import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.util.logging.LogManager; public class Main { 

 public static void main(String[] argv) throws Exception {
   // Register for the event
   LogManager.getLogManager().addPropertyChangeListener(new PropertyChangeListener() {
     // This method is called when configuration file is reread
     public void propertyChange(PropertyChangeEvent evt) {
       String propName = evt.getPropertyName();
       Object oldValue = evt.getOldValue();
       Object newValue = evt.getOldValue();
       // All values are null
     }
   });
 }

} 


 </source>



Email Logger

   <source lang="java">

//: c15:EmailLogger.java // {RunByHand} Must be connected to the Internet // {Depends: mail.jar,activation.jar} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.*; import java.io.*; import java.util.Properties; import javax.mail.*; import javax.mail.internet.*; public class EmailLogger { 

 private static Logger logger = Logger.getLogger("EmailLogger");
 public static void main(String[] args) throws Exception {
   logger.setUseParentHandlers(false);
   Handler conHdlr = new ConsoleHandler();
   conHdlr.setFormatter(new Formatter() {
     public String format(LogRecord record) {
       return record.getLevel() + "  :  "
         + record.getSourceClassName() + ":"
         + record.getSourceMethodName() + ":"
         + record.getMessage() + "\n";
     }
   });
   logger.addHandler(conHdlr);
   logger.addHandler(
     new FileHandler("EmailLoggerOutput.xml"));
   logger.addHandler(new MailingHandler());
   logger.log(Level.INFO,
     "Testing Multiple Handlers", "SendMailTrue");
 }

} // A handler that sends mail messages class MailingHandler extends Handler { 

 public void publish(LogRecord record) {
   Object[] params = record.getParameters();
   if(params == null) return;
   // Send mail only if the parameter is true
   if(params[0].equals("SendMailTrue")) {
     new MailInfo("bruce@theunixman.ru",
       new String[] { "bruce@theunixman.ru" },
       "smtp.theunixman.ru", "Test Subject",
       "Test Content").sendMail();
   }
 }
 public void close() {}
 public void flush() {}

} class MailInfo { 

 private String fromAddr;
 private String[] toAddr;
 private String serverAddr;
 private String subject;
 private String message;
 public MailInfo(String from, String[] to,
   String server, String subject, String message) {
   fromAddr = from;
   toAddr = to;
   serverAddr = server;
   this.subject = subject;
   this.message = message;
 }
 public void sendMail() {
   try {
     Properties prop = new Properties();
     prop.put("mail.smtp.host", serverAddr);
     Session session =
       Session.getDefaultInstance(prop, null);
     session.setDebug(true);
     // Create a message
     Message mimeMsg = new MimeMessage(session);
     // Set the from and to address
     Address addressFrom = new InternetAddress(fromAddr);
     mimeMsg.setFrom(addressFrom);
     Address[] to = new InternetAddress[toAddr.length];
     for(int i = 0; i < toAddr.length; i++)
       to[i] = new InternetAddress(toAddr[i]);
     mimeMsg.setRecipients(Message.RecipientType.TO,to);
     mimeMsg.setSubject(subject);
     mimeMsg.setText(message);
     Transport.send(mimeMsg);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }

} ///:~ 



 </source>



File Logger

   <source lang="java">

/* Software Architecture Design Patterns in Java by Partha Kuchana Auerbach Publications

  • /

import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileLogger { 

 public synchronized void log(String msg) {
   DataOutputStream dos = null;
   try {
     dos = new DataOutputStream(new FileOutputStream("log.txt", true));
     dos.writeBytes(msg);
     dos.close();
   } catch (FileNotFoundException ex) {
     //
   } catch (IOException ex) {
     //
   }
 }

} 


 </source>



Flush File Handler and Logger

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class Main { 

 public static void main(String[] args) throws Exception {
   FileHandler handler = null;
   Logger logger = Logger.getLogger("logging");
   handler = new FileHandler("pattern", 1000, 2);
   logger.addHandler(handler);
   LogRecord record = new LogRecord(Level.INFO, "Logged in a file...");
   logger.log(record);
   handler.flush();
   handler.close();
 }

} 


 </source>



Handling Errors While Parsing an XML File

   <source lang="java">

import java.io.File; import java.util.logging.Level; import java.util.logging.Logger; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.xml.sax.ErrorHandler; import org.xml.sax.SAXParseException; public class Main { 

 public static void main(String[] argv) throws Exception {
   DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   builder.setErrorHandler(new MyErrorHandler());
   Document doc = builder.parse(new File("infilename.xml"));
 }

} class MyErrorHandler implements ErrorHandler { 

 public void error(SAXParseException e) {
   log(Level.SEVERE, "Error", e);
 }
 public void fatalError(SAXParseException e) {
   log(Level.SEVERE, "Fatal Error", e);
 }
 public void warning(SAXParseException e) {
   log(Level.WARNING, "Warning", e);
 }
 private Logger logger = Logger.getLogger("com.mycompany");
 private void log(Level level, String message, SAXParseException e) {
   int line = e.getLineNumber();
   int col = e.getColumnNumber();
   String publicId = e.getPublicId();
   String systemId = e.getSystemId();
   message = message + ": " + e.getMessage() + ": line=" + line + ", col=" + col + ", PUBLIC="
       + publicId + ", SYSTEM=" + systemId;
   logger.log(level, message);
 }

} 


 </source>



How to write custom Log handler

   <source lang="java">

// : c15:CustomHandler.java //How to write custom handler //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.ArrayList; import java.util.List; import java.util.logging.Handler; import java.util.logging.LogRecord; import java.util.logging.Logger; public class CustomHandler { 

 private static Logger logger = Logger.getLogger("CustomHandler");
 private static List strHolder = new ArrayList();
 public static void main(String[] args) {
   logger.addHandler(new Handler() {
     public void publish(LogRecord logRecord) {
       strHolder.add(logRecord.getLevel() + ":");
       strHolder.add(logRecord.getSourceClassName() + ":");
       strHolder.add(logRecord.getSourceMethodName() + ":");
       strHolder.add("<" + logRecord.getMessage() + ">");
       strHolder.add("\n");
     }
     public void flush() {
     }
     public void close() {
     }
   });
   logger.warning("Logging Warning");
   logger.info("Logging Info");
   System.out.print(strHolder);
 }

} ///:~ 



 </source>



Java log: alternate XML log

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; public class AlternateXML { 

 public static void main(String args[]) {
   try {
     FileHandler handler = new FileHandler("alterxml.xml");
     Logger logger = Logger.getLogger("jexp.logging");
     logger.addHandler(handler);
     logger.log(Level.INFO, "alternative xml");
   } catch (Exception e) {
     e.printStackTrace();
   }
 }

} 



 </source>



Java Log:Basic Logging

   <source lang="java">

import java.util.logging.*; import java.io.*; public class BasicLogging { 

   private static Logger logger = Logger.getLogger("MyLogger");
   private ConsoleHandler console = null;
   private FileHandler file = null;
   public BasicLogging()
   {
       console = new ConsoleHandler();
       try{
           file = new FileHandler("basicLogging.out");
       }catch(IOException ioe){
           logger.warning("Could not create a file...");
       }
       logger.addHandler(console);
       logger.addHandler(file);
   }
   public void logMessage()
   {
     logger.info("I am logging test message..");
   }
 public static void main(String args[])
 {
     BasicLogging demo = new BasicLogging();
     demo.logMessage();
 }

} 


 </source>



Java log: Basic logging 2

   <source lang="java">

import java.util.logging.Logger; public class BasicLogging1 { 

 public static void main(String args[]) {
   Logger logger = Logger.getLogger("current.package");
   logger.info("Simple formatted message..");
 }

} 



 </source>



Java log: Custom XML Formatter

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

import java.util.logging.*; import java.io.*; class CustomFormatter extends Formatter { 

 public CustomFormatter(){}
  /**
    This method formats the given log record, in a java properties file style
  */
 public synchronized String format(LogRecord record)
 {
   String methodName = record.getSourceMethodName();
   String message = record.getMessage();
   StringBuffer buffer = new StringBuffer(50);
   buffer.append(methodName);
   buffer.append("=");
   buffer.append(message);
   return buffer.toString();
 }

} public class CustomFormatterTest{ 

   private static Logger logger = Logger.getLogger("sam.logging");
   private String fileName = null;
   public CustomFormatterTest(String fileName)
   {
       this.fileName = fileName;
       try
       {
           FileHandler fh = new FileHandler(fileName);
           CustomFormatter formatter = new CustomFormatter();
           fh.setFormatter(formatter);
           logger.addHandler(fh);
       }catch(IOException ioe)
       {
           ioe.printStackTrace();
       }
   }
   /**
    * This method performs the logging activity
    */
   public void logMessage()
   {
       logger.info("log this message");
   }
   public static void main(String args[]) {
       CustomFormatterTest test = new CustomFormatterTest("name");
       test.logMessage();
   }

} 


 </source>



Java log: File Handler Demo

   <source lang="java">

import java.io.IOException; import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class FileHandlerDemo { 

 private FileHandler handler = null;
 private static Logger logger = Logger.getLogger("sam.logging");
 public FileHandlerDemo(String pattern) {
   try {
     handler = new FileHandler(pattern, 1000, 2);
     logger.addHandler(handler);
   } catch (IOException ioe) {
     ioe.printStackTrace();
   }
 }
 public void logMessage() {
   LogRecord record = new LogRecord(Level.INFO, "Logged in a file..22.");
   logger.log(record);
   handler.flush();
   handler.close();
 }
 public static void main(String[] args) {
   FileHandlerDemo demo = new FileHandlerDemo("%h/log%g.out");
   demo.logMessage();
 }

} 


 </source>



Java log: Hierarchy logging

   <source lang="java">

import java.util.logging.*; class ParentLogger{ 

 private Logger logger = Logger.getLogger("sam.logging");
 private Level level = null;
 
 public ParentLogger(){
   level = Level.SEVERE;
   logger.setLevel(level);
 }
 public void aMethod()
 {
   logger.log(level, "Severe message from Parent Logger");
 }

} class ChildLogger{ 

   private Logger logger = Logger.getLogger("sam.logging.child");
   private Level level = null;
   public ChildLogger()
   {
       //level = Level.INFO;
       //setting the level of this child logger, if not specified, it
       // will use the level of the parent logger
       logger.setLevel(level);
   }
   public void aMethod()
   {
       logger.log(Level.INFO, "Info message from Child Logger");
       logger.log(Level.SEVERE, "Severe message from Child Logger");
   }

}

public class LoggingMonitor { 

   public static void main(String[] args){
       ParentLogger pLogger = new ParentLogger();
       ChildLogger cLogger = new ChildLogger();
       cLogger.aMethod();
   }

} 


 </source>



Java log: Localize Logging

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

import java.util.logging.*; import java.io.*; import java.util.ResourceBundle; public class LocalizeLogging { 

   private static Logger logger = Logger.getLogger("sam.logging");
   private String rbName = null;
   public LocalizeLogging(String rbName)
   {
       this.rbName = rbName;
   }
   public void logMessage()
   {
       logger.logrb(Level.INFO, "LocalizeLogging", "logMessage", rbName,"success");
   }
   public static void main(String args[]) {
       //collect the name of the resource bundle
       String rbName = "name";
       LocalizeLogging lLogging = new LocalizeLogging(rbName);
       lLogging.logMessage();
   }

} 


 </source>



Java log: Log and Window(JFrame, frame)

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

import java.util.logging.*; import javax.swing.JFrame; import javax.swing.JTextArea; import javax.swing.JScrollPane; class LogWindow extends JFrame { 

 private int width;
 private int height;
 private JTextArea textArea = null;
 private JScrollPane pane = null;
 public LogWindow(String title, int width, int height) {
   super(title);
   setSize(width, height);
   textArea = new JTextArea();
   pane = new JScrollPane(textArea);
   getContentPane().add(pane);
   setVisible(true);
 }
 /**
  * This method appends the data to the text area.
  * 
  * @param data
  *            the Logging information data
  */
 public void showInfo(String data) {
   textArea.append(data);
   this.getContentPane().validate();
 }

} class WindowHandler extends Handler { 

 //the window to which the logging is done
 private LogWindow window = null;
 private Formatter formatter = null;
 private Level level = null;
 //the singleton instance
 private static WindowHandler handler = null;
 /**
  * private constructor, preventing initialization
  */
 private WindowHandler() {
   configure();
   if (window == null)
     window = new LogWindow("Logging window", 500, 200);
 }
 /**
  * The getInstance method returns the singleton instance of the
  * WindowHandler object It is synchronized to prevent two threads trying to
  * create an instance simultaneously. @ return WindowHandler object
  */
 public static synchronized WindowHandler getInstance() {
   if (handler == null) {
     handler = new WindowHandler();
   }
   return handler;
 }
 /**
  * This method loads the configuration properties from the JDK level
  * configuration file with the help of the LogManager class. It then sets
  * its level, filter and formatter properties.
  */
 private void configure() {
   LogManager manager = LogManager.getLogManager();
   String className = this.getClass().getName();
   String level = manager.getProperty(className + ".level");
   String filter = manager.getProperty(className + ".filter");
   String formatter = manager.getProperty(className + ".formatter");
   //accessing super class methods to set the parameters
   setLevel(level != null ? Level.parse(level) : Level.INFO);
   setFilter(makeFilter(filter));
   setFormatter(makeFormatter(formatter));
 }
 /**
  * private method constructing a Filter object with the filter name.
  * 
  * @param filterName
  *            the name of the filter
  * @return the Filter object
  */
 private Filter makeFilter(String filterName) {
   Class c = null;
   Filter f = null;
   try {
     c = Class.forName(filterName);
     f = (Filter) c.newInstance();
   } catch (Exception e) {
     System.out.println("There was a problem to load the filter class: "
         + filterName);
   }
   return f;
 }
 /**
  * private method creating a Formatter object with the formatter name. If no
  * name is specified, it returns a SimpleFormatter object
  * 
  * @param formatterName
  *            the name of the formatter
  * @return Formatter object
  */
 private Formatter makeFormatter(String formatterName) {
   Class c = null;
   Formatter f = null;
   try {
     c = Class.forName(formatterName);
     f = (Formatter) c.newInstance();
   } catch (Exception e) {
     f = new SimpleFormatter();
   }
   return f;
 }
 /**
  * This is the overridden publish method of the abstract super class
  * Handler. This method writes the logging information to the associated
  * Java window. This method is synchronized to make it thread-safe. In case
  * there is a problem, it reports the problem with the ErrorManager, only
  * once and silently ignores the others.
  * 
  * @record the LogRecord object
  *  
  */
 public synchronized void publish(LogRecord record) {
   String message = null;
   //check if the record is loggable
   if (!isLoggable(record))
     return;
   try {
     message = getFormatter().format(record);
   } catch (Exception e) {
     reportError(null, e, ErrorManager.FORMAT_FAILURE);
   }
   try {
     window.showInfo(message);
   } catch (Exception ex) {
     reportError(null, ex, ErrorManager.WRITE_FAILURE);
   }
 }
 public void close() {
 }
 public void flush() {
 }

} public class CustomHandlerDemo { 

 private WindowHandler handler = null;
 private Logger logger = null;
 public CustomHandlerDemo() {
   handler = WindowHandler.getInstance();
   //obtaining a logger instance and setting the handler
   logger = Logger.getLogger("sam.logging.handler");
   logger.addHandler(handler);
 }
 /**
  * This method publishes the log message
  */
 public void logMessage() {
   logger.info("Hello from WindowHandler...");
 }
 public static void main(String args[]) {
   //logging with the help of a logger
   CustomHandlerDemo demo = new CustomHandlerDemo();
   demo.logMessage();
   //using the handler.publish() to log
   WindowHandler h = WindowHandler.getInstance();
   LogRecord r = new LogRecord(Level.WARNING,
       "The Handler publish method...");
   h.publish(r);
 }

} 



 </source>



Java log: log filter

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

import java.util.logging.*; public class FilterDemo { 

 private Logger logger = null;
 private AgeFilter filter = null;
 public FilterDemo()
 {
   //obtaining a logger object
   logger = Logger.getLogger("sam.logging");
   //creating a AgeFilter object
   filter = new AgeFilter();
   //attaching the filter to the logger
   logger.setFilter(filter);
 }
 /**
  * This method logs the message
  */
 public void logMessage(Person person)
 {
   //logging the message with Person object as parameter
   logger.log(Level.INFO, "Person has age "+person.getAge(), person);
 }
 public static void main(String args[])
 {
   FilterDemo demo = new FilterDemo();
   //creating Person objects
   Person person1 = new Person("Paul", 32);
   Person person2 = new Person("sam", 29);
   //logging with each Person object
   demo.logMessage(person1);
   demo.logMessage(person2);
 }

} class Person{ 

 private String name = null;
 private int age;
 public Person(String name, int age)
 {
  this.name = name;
  this.age = age;
 }
 public void setName(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return name;
 }
 public void setAge(int age)
 {
  this.age = age;
 }
 public int getAge()
 {
  return age;
 }

} class AgeFilter implements Filter { 

   public AgeFilter() {
   }
   /**
    * This is the overridden method from the Filter interface.
    * It checks the Person object associated with the LogRecord
    * checks the age>30, and returns true
    *@param record the LogRecord object
    *@return boolean true/false
    */
   public boolean isLoggable(LogRecord record) {
       boolean result = false;
       //obtaining the Person object from the record
       Object[] objs = record.getParameters();
       Person person = (Person)objs[0];
       //check if person is not null
       if(person !=null) {
           //obtain the age
           int age = person.getAge();
           if(age>30)
               result = true;
           else
               result = false;
       }
       return result;
   }

} 


 </source>



Java log: Logging Server

   <source lang="java">

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; public class LoggingServer { 

 private ServerSocket serverSocket = null;
 private Socket socket = null;
 public LoggingServer(int port) {
   try {
     serverSocket = new ServerSocket(port);
     socket = serverSocket.accept();
   } catch (IOException ioe) {
     ioe.printStackTrace();
   }
 }
 public void acceptMessage() {
   try {
     InputStream inStream = socket.getInputStream();
     BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
     String str = null;
     while ((str = reader.readLine()) != null) {
       System.out.println(str);
     }
   } catch (IOException ioe) {
     ioe.printStackTrace();
   }
 }
 public static void main(String args[]) {
   LoggingServer server = new LoggingServer(2020);
   server.acceptMessage();
 }

} 



 </source>



Java log: Memory Handler Demo

   <source lang="java">

import java.util.logging.ConsoleHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class MemoryHandlerDemo { 

 private ConsoleHandler handler = null;
 private MemoryHandler mHandler = null;
 private static Logger logger = Logger.getLogger("sam.logging");
 public MemoryHandlerDemo(int size, Level pushLevel) {
   handler = new ConsoleHandler();
   mHandler = new MemoryHandler(handler, size, pushLevel);
   logger.addHandler(mHandler);
   logger.setUseParentHandlers(false);
 }
 public void logMessage() {
   LogRecord record1 = new LogRecord(Level.SEVERE, "This is SEVERE level message");
   LogRecord record2 = new LogRecord(Level.WARNING, "This is WARNING level message");
   logger.log(record1);
   logger.log(record2);
 }
 public static void main(String args[]) {
   MemoryHandlerDemo demo = new MemoryHandlerDemo(2, Level.SEVERE);
   demo.logMessage();
 }

} 



 </source>



Java log: Remote Config Reader

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

// /* If this property is not passed to the logging framework at startup, by default, LogManager reads a configuration file located in the "JAVA_HOME/jre/lib/ logging.properties" file. This configuration file defines the default configuration parameters for the logging framework to work. It is possible to override the default location and specify our own configuration file by passing a command line option to the Java runtime as: java -Djava.util.logging.config.file=configuration file name 

RemoteConfigReader.java
  • /

import java.util.logging.LogManager; import java.net.URL; import java.net.URLConnection; import java.net.MalformedURLException; import java.io.InputStream; import java.io.IOException; public class RemoteConfigReader { 

private String urlString = "http://www.xyz.ru/config.properties";
private URL url = null;
private URLConnection urlConn = null;
private InputStream inStream = null;
private LogManager manager = null;
/**
 * The constructor obtains a connection to the URL specified in the
 * urlString object, obtains an InputStream on the URL and
 * calls the readConfiguration(InputStream) of the LogManager class
 * to perform the initialization
 */
public RemoteConfigReader(){
     try{
          url = new URL(urlString);
          urlConn = url.openConnection();
          inStream = urlConn.getInputStream();
          manager = LogManager.getLogManager();
          manager.readConfiguration(inStream);
     }catch(MalformedURLException mue){
          System.out.println("could not open url: "+urlString);
     }catch(IOException ioe){
          System.out.println("IOException occured in reading: "+urlString);
     }catch(SecurityException se){
          System.out.println("Security exception occured in class RemoteConfigLoader");
     }
}

} 


 </source>



Java log: Socket Handler Demo

   <source lang="java">

import java.io.IOException; import java.util.logging.Logger; import java.util.logging.SocketHandler; public class SocketHandlerDemo { 

 private SocketHandler handler = null;
 private static Logger logger = Logger.getLogger("sam.logging");
 public SocketHandlerDemo(String host, int port) {
   try {
     handler = new SocketHandler(host, port);
     logger.addHandler(handler);
   } catch (IOException ioe) {
     ioe.printStackTrace();
   }
 }
 public void logMessage() {
   logger.warning("SocketHandler is working...");
 }
 public static void main(String args[]) {
   SocketHandlerDemo demo = new SocketHandlerDemo("localhost", 2020);
   demo.logMessage();
 }

} 


 </source>



Java log: Stream Handler Demo

   <source lang="java">

import java.io.OutputStream; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; import java.util.logging.StreamHandler; public class StreamHandlerDemo { 

 private StreamHandler handler = null;
 private OutputStream outStream = null;
 private static Logger logger = Logger.getLogger("sam.logging");
 public StreamHandlerDemo() {
   outStream = System.out;
   handler = new StreamHandler(outStream, new SimpleFormatter());
   logger.addHandler(handler);
   logger.setUseParentHandlers(false);
 }
 public void logMessage() {
   logger.info("StreamHandler is working!");
 }
 public static void main(String[] args) {
   StreamHandlerDemo demo = new StreamHandlerDemo();
   demo.logMessage();
 }

} 


 </source>



Java log: various log methods

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

import java.util.logging.*; import java.io.IOException; public class LogMethods { 

   private static Logger logger = Logger.getLogger("sam.logging");
   public LogMethods()
   {
       //first obtain the logmanager instance
       LogManager manager = LogManager.getLogManager();
       //remove all the associated handlers with this manager
       manager.reset();
       //create a new handler for the logger to write messages
       // to the console
       ConsoleHandler ch = new ConsoleHandler();
       ch.setLevel(Level.FINEST);
       //setting the logger level and handler
       logger.setLevel(Level.FINEST);
       logger.addHandler(ch);
   }
   /**
    * This method demonstrates the basic logging methods
    */
   public void printBasicMethods()
   {
       logger.log(Level.INFO, "THIS IS INFO LEVEL MESSAGE");
       //creating a log record on our own
       LogRecord record = new LogRecord(Level.SEVERE, "OUR OWN LOGRECORD OBJECT");
       //logging the log record object
       logger.log(record);
   }
   /**
    * This method demonstrates the precise logging methods
    */
   public void printPreciseMethods()
   {
       logger.logp(Level.INFO, "LogMethods", "printPreciseMethods","PRECISE METHODS..");
   }
   /**
    * This method demonstrates the level based logging methods
    */
   public void printLevelMethods()
   {
       logger.fine("THIS IS A FINE LEVEL MESSAGE");
       logger.finer("THIS IS A FINER LEVEL MESSAGE");
       logger.finest("THIS IS A FINEST LEVEL MESSAGE");
       logger.config("THIS IS CONFIG LEVEL MESSAGE");
   }
   /**
    *This method demonstrates the method level logging methods
    */
   public void printMethod()
   {
       logger.entering("LogMethods", "printMethod");
       logger.exiting("LogMethods", "printMethod");
   }
   public static void main(String[] args)
   {
       LogMethods lm = new LogMethods();
       lm.printBasicMethods();
       lm.printPreciseMethods();
       lm.printLevelMethods();
       lm.printMethod();
   }

} 



 </source>



Java log: XML log

   <source lang="java">

/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996

  • /

import java.util.logging.*; import java.io.*; public class XMLLogging { 

   private     ConsoleHandler ch ;
   private     XMLFormatter formatter ;
   private     FileHandler handler = null;
   /**
    * constructor
    */
   public XMLLogging() {
       ch = new ConsoleHandler();
       formatter = new XMLFormatter();
   }
   /**
    * This method demonstrates the logging using XMLFormatter
    * and should there be an exception, the exception
    * is logged into the console with ConsoleHandler and formatted
    * withXMLFormatter.
    */
   public void logMessage()
   {
       //creating a LogRecord object with level and message
       LogRecord record = new LogRecord(Level.INFO, "XML message..");
       try
       {
           //creating a StreamHandler object to file output the xml message
           handler = new FileHandler("newxml.xml");
           handler.setFormatter(formatter);
           //publishing the log message to the file and flushing the buffer
           handler.publish(record);
           handler.flush();
       }catch(Exception e) {
           //creating a log record object with the WARNING level
           //and exception message
           LogRecord rec = new LogRecord(Level.WARNING, e.toString());
           //setting the formatter for the consolehandler as
           //XMLFormatter and publishing the message
           ch.setFormatter(formatter);
           ch.publish(rec);
       }
   }
   public static void main(String args[]) {
       XMLLogging logging = new XMLLogging();
       logging.logMessage();
   }

} 


 </source>



Limiting the Size of a Log by Using a Rotating Sequence of Files

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   // Create a file handler that uses 3 logfiles, each with a limit of 1Mbyte
   String pattern = "my%g.log";
   int limit = 1000000; // 1 Mb
   int numLogFiles = 3;
   FileHandler fh = new FileHandler(pattern, limit, numLogFiles);
   // Add to logger
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(fh);
 }

} 


 </source>



Limiting the Size of a Log File

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   // Create a file handler with a limit of 1 megabytes
   String pattern = "my.log";
   int limit = 1000000; // 1 Mb
   FileHandler fh = new FileHandler("my.log", limit, 1);
   // Add to logger
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(fh);
 }

} 


 </source>



Localized Logging

   <source lang="java">

import java.util.logging.Level; import java.util.logging.Logger; public class Main { 

 public static void main(String args[]) {
   Logger logger = Logger.getLogger("your.logging");
   String rbName = null;
   logger.logrb(Level.INFO, "LocalizeLogging", "logMessage", rbName, "success");
 }

} 


 </source>



Log Client Filter

   <source lang="java">

import java.util.logging.LogRecord; public class ClientFilter implements java.util.logging.Filter { 

 public boolean isLoggable(LogRecord record) {
   if (record.getMessage().startsWith("client"))
     return (true);
   else
     return (false);
 }

} 


 </source>



Logger Demo

   <source lang="java">

import org.apache.log4j.*; public class LoggerDemo { 

   private static Logger logger = Logger.getLogger(LoggerDemo.class.getPackage().getName());
   public LoggerDemo(String rbName) {
       logger.setAdditivity(false);
       logger.debug("A");
       logger.setResourceBundle(java.util.ResourceBundle.getBundle(rbName));
       logger.debug("B");
   }
   public void doLogging(String name) {
       logger.debug("Entered the doLogging method..");
       //do something
       
       logger.info("printing the message...");
       logger.debug("Exiting the doLogging method...");
   }
   public void doLocalizedLogging() {
       logger.l7dlog(Level.DEBUG, "Entry", null);
       logger.l7dlog(Level.DEBUG, "Exit", null);
   }
   public static void main(String args[]) {
       String name = args[0];
       String rbName = args[1];
       LoggerDemo demo = new LoggerDemo(rbName);
       demo.doLogging(name);
       demo.doLocalizedLogging();
   }

} 


 </source>



Logger with XMLFormatter and FileHandler

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Handler; import java.util.logging.Logger; import java.util.logging.XMLFormatter; public class Main { 

 public static void main(String[] args) throws Exception {
   Logger logger = Logger.getLogger("my.log");
   Handler handler = null;
   handler = new FileHandler("messages.log");
   logger.addHandler(handler);
   handler.setFormatter(new XMLFormatter());
   logger.info("Our first logging message");
   logger.severe("Something terrible happened");
 }

} 


 </source>



Logging a Method Call

   <source lang="java">

import java.util.logging.Level; import java.util.logging.Logger; //package com.mycompany; class MyClass { 

 public boolean myMethod(int p1, Object p2) {
   Logger logger = Logger.getLogger("com.mycompany.MyClass");
   if (logger.isLoggable(Level.FINER)) {
     logger.entering(this.getClass().getName(), "myMethod", new Object[] { new Integer(p1), p2 });
   }
   System.out.println("Method body");
   boolean result = true;
   if (logger.isLoggable(Level.FINER)) {
     logger.exiting(this.getClass().getName(), "myMethod", new Boolean(result));
     logger.exiting(this.getClass().getName(), "myMethod");
   }
   return result;
 }

} 


 </source>



Logging an Exception

   <source lang="java">

import java.io.IOException; import java.util.logging.Level; import java.util.logging.Logger; //package com.mycompany; public class Main { 

 public static void main(String[] argv) {
   Logger logger = Logger.getLogger("com.mycompany.MyClass");
   try {
     throw new IOException();
   } catch (Throwable e) {
     logger.log(Level.SEVERE, "Uncaught exception", e);
   }
   Exception ex = new IllegalStateException();
   logger.throwing("Main class", "myMethod", ex);
 }

} 


 </source>



Logging Example 1

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.Logger; import java.util.logging.XMLFormatter; public class LoggingExample1 { 

 public static void main(String args[]) {
   try {
     LogManager lm = LogManager.getLogManager();
     Logger logger;
     FileHandler fh = new FileHandler("log_test.txt");
     logger = Logger.getLogger("LoggingExample1");
     lm.addLogger(logger);
     logger.setLevel(Level.INFO);
     fh.setFormatter(new XMLFormatter());
     logger.addHandler(fh);
     // root logger defaults to SimpleFormatter. We don"t want messages
     // logged twice.
     //logger.setUseParentHandlers(false);
     logger.log(Level.INFO, "test 1");
     logger.log(Level.INFO, "test 2");
     logger.log(Level.INFO, "test 3");
     fh.close();
   } catch (Exception e) {
     System.out.println("Exception thrown: " + e);
     e.printStackTrace();
   }
 }

} 



 </source>



Logging Level Manipulation

   <source lang="java">

// : c15:LoggingLevelManipulation.java //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Level; import java.util.logging.Logger; public class LoggingLevelManipulation { 

 private static Logger lgr = Logger.getLogger("com"), lgr2 = Logger
     .getLogger("com.bruceeckel"), util = Logger
     .getLogger("com.bruceeckel.util"), test = Logger
     .getLogger("com.bruceeckel.test"), rand = Logger
     .getLogger("random");
 static void printLogMessages(Logger logger) {
   logger.finest(logger.getName() + " Finest");
   logger.finer(logger.getName() + " Finer");
   logger.fine(logger.getName() + " Fine");
   logger.config(logger.getName() + " Config");
   logger.info(logger.getName() + " Info");
   logger.warning(logger.getName() + " Warning");
   logger.severe(logger.getName() + " Severe");
 }
 static void logMessages() {
   printLogMessages(lgr);
   printLogMessages(lgr2);
   printLogMessages(util);
   printLogMessages(test);
   printLogMessages(rand);
 }
 static void printLevels() {
   System.out.println(" -- printing levels -- " + lgr.getName() + " : "
       + lgr.getLevel() + " " + lgr2.getName() + " : "
       + lgr2.getLevel() + " " + util.getName() + " : "
       + util.getLevel() + " " + test.getName() + " : "
       + test.getLevel() + " " + rand.getName() + " : "
       + rand.getLevel());
 }
 public static void main(String[] args) {
   printLevels();
   lgr.setLevel(Level.SEVERE);
   printLevels();
   System.out.println("com level: SEVERE");
   logMessages();
   util.setLevel(Level.FINEST);
   test.setLevel(Level.FINEST);
   rand.setLevel(Level.FINEST);
   printLevels();
   System.out.println("individual loggers set to FINEST");
   logMessages();
   lgr.setLevel(Level.FINEST);
   printLevels();
   System.out.println("com level: FINEST");
   logMessages();
 }

} ///:~ 



 </source>



Logging Levels

   <source lang="java">

// : c15:LoggingLevels.java //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.Handler; import java.util.logging.LogManager; public class LoggingLevels { 

 private static Logger lgr = Logger.getLogger("com"), lgr2 = Logger
     .getLogger("com.bruceeckel"), util = Logger
     .getLogger("com.bruceeckel.util"), test = Logger
     .getLogger("com.bruceeckel.test"), rand = Logger
     .getLogger("random");
 private static void logMessages() {
   lgr.info("com : info");
   lgr2.info("com.bruceeckel : info");
   util.info("util : info");
   test.severe("test : severe");
   rand.info("random : info");
 }
 public static void main(String[] args) {
   lgr.setLevel(Level.SEVERE);
   System.out.println("com level: SEVERE");
   logMessages();
   util.setLevel(Level.FINEST);
   test.setLevel(Level.FINEST);
   rand.setLevel(Level.FINEST);
   System.out.println("individual loggers set to FINEST");
   logMessages();
   lgr.setLevel(Level.SEVERE);
   System.out.println("com level: SEVERE");
   logMessages();
 }

} ///:~ 



 </source>



Log HTML Table Formatter

   <source lang="java">

import java.util.logging.Handler; import java.util.logging.LogRecord; public class HTMLTableFormatter extends java.util.logging.Formatter { 

 public String format(LogRecord record) {
   return ("  <tr><td>" + record.getMillis() + "</td><td>"
       + record.getMessage() + "</td></tr>\n");
 }
 public String getHead(Handler h) {
return ("\n " + "\n"); 
 }
 public String getTail(Handler h) {
return ("
TimeLog Message
\n"); 
 }

} 


 </source>



Log level

   <source lang="java">

// : c15:SimpleFilter.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Filter; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class SimpleFilter { 

 private static Logger logger = Logger.getLogger("SimpleFilter");
 static class Duck {
 };
 static class Wombat {
 };
 static void sendLogMessages() {
   logger.log(Level.WARNING, "A duck in the house!", new Duck());
   logger.log(Level.WARNING, "A Wombat at large!", new Wombat());
 }
 public static void main(String[] args) {
   sendLogMessages();
   logger.setFilter(new Filter() {
     public boolean isLoggable(LogRecord record) {
       Object[] params = record.getParameters();
       if (params == null)
         return true; // No parameters
       if (record.getParameters()[0] instanceof Duck)
         return true; // Only log Ducks
       return false;
     }
   });
   logger.info("After setting filter..");
   sendLogMessages();
 }

} ///:~ 



 </source>



Log multiple Handlers

   <source lang="java">

// : c15:MultipleHandlers.java // {Clean: MultipleHandlers.xml,MultipleHandlers.xml.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.ConsoleHandler; import java.util.logging.FileHandler; import java.util.logging.Logger; public class MultipleHandlers { 

 private static Logger logger = Logger.getLogger("MultipleHandlers");
 public static void main(String[] args) throws Exception {
   FileHandler logFile = new FileHandler("MultipleHandlers.xml");
   logger.addHandler(logFile);
   logger.addHandler(new ConsoleHandler());
   logger.warning("Output to multiple handlers");
 }

} ///:~ 



 </source>



Log multiple Handlers 2

   <source lang="java">

// : c15:MultipleHandlers2.java // {Clean: MultipleHandlers2.xml,MultipleHandlers2.xml.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.ConsoleHandler; import java.util.logging.FileHandler; import java.util.logging.Logger; public class MultipleHandlers2 { 

 private static Logger logger = Logger.getLogger("MultipleHandlers2");
 public static void main(String[] args) throws Exception {
   FileHandler logFile = new FileHandler("MultipleHandlers2.xml");
   logger.addHandler(logFile);
   logger.addHandler(new ConsoleHandler());
   logger.setUseParentHandlers(false);
   logger.warning("Output to multiple handlers");
 }

} ///:~ 



 </source>



Log To File with FileHandler

   <source lang="java">

//: c15:LogToFile.java // {Clean: LogToFile.xml,LogToFile.xml.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.*; public class LogToFile { 

 private static Logger logger = Logger.getLogger("LogToFile");
 
 public static void main(String[] args) throws Exception {
   logger.addHandler(new FileHandler("LogToFile.xml"));
   logger.info("A message logged to the file");
 }

} ///:~ 



 </source>



Log to file with FileHandler and SimpleFomatter

   <source lang="java">

// : c15:LogToFile2.java // {Clean: LogToFile2.txt,LogToFile2.txt.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.FileHandler; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; public class LogToFile2 { 

 private static Logger logger = Logger.getLogger("LogToFile2");
 public static void main(String[] args) throws Exception {
   FileHandler logFile = new FileHandler("LogToFile2.txt");
   logFile.setFormatter(new SimpleFormatter());
   logger.addHandler(logFile);
   logger.info("A message logged to the file");
 }

} ///:~ 



 </source>



Memory Handler Demo

   <source lang="java">

import java.util.logging.ConsoleHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class Main { 

 public static void main(String args[]) throws Exception {
   Logger logger = Logger.getLogger("your.logging");
   ConsoleHandler handler = new ConsoleHandler();
   MemoryHandler mHandler = new MemoryHandler(handler, 10, Level.ALL);
   logger.addHandler(mHandler);
   logger.setUseParentHandlers(false);
   LogRecord record1 = new LogRecord(Level.SEVERE, "This is SEVERE level message");
   LogRecord record2 = new LogRecord(Level.WARNING, "This is WARNING level message");
   logger.log(record1);
   logger.log(record2);
 }

} 


 </source>



Minimizing the Impact of Logging Code

   <source lang="java">

import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   int count = 123;
   Logger logger = Logger.getLogger("com.mycompany.MyClass");
   logger.finest("count: " + count);
 }

} 


 </source>



Override LogRecord toString()

   <source lang="java">

// : c15:PrintableLogRecord.java // Override LogRecord toString() // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Level; import java.util.logging.LogRecord; public class PrintableLogRecord extends LogRecord { 

 public PrintableLogRecord(Level level, String str) {
   super(level, str);
 }
 public String toString() {
   String result = "Level<" + getLevel() + ">\n" + "LoggerName<"
       + getLoggerName() + ">\n" + "Message<" + getMessage() + ">\n"
       + "CurrentMillis<" + getMillis() + ">\n" + "Params";
   Object[] objParams = getParameters();
   if (objParams == null)
     result += "<null>\n";
   else
     for (int i = 0; i < objParams.length; i++)
       result += "  Param # <" + i + " value "
           + objParams[i].toString() + ">\n";
   result += "ResourceBundle<" + getResourceBundle()
       + ">\nResourceBundleName<" + getResourceBundleName()
       + ">\nSequenceNumber<" + getSequenceNumber()
       + ">\nSourceClassName<" + getSourceClassName()
       + ">\nSourceMethodName<" + getSourceMethodName()
       + ">\nThread Id<" + getThreadID() + ">\nThrown<" + getThrown()
       + ">";
   return result;
 }
 public static void main(String[] args) {
   PrintableLogRecord logRecord = new PrintableLogRecord(Level.FINEST,
       "Simple Log Record");
   System.out.println(logRecord);
 }

} ///:~ 



 </source>



Preventing a Logger from Forwarding Log Records to Its Parent

   <source lang="java">

import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   Logger logger = Logger.getLogger("com.mycompany");
   // Stop forwarding log records to ancestor handlers
   logger.setUseParentHandlers(false);
   // Start forwarding log records to ancestor handlers
   logger.setUseParentHandlers(true);
 }

} 


 </source>



Remote ConfigReader with URLConnection

   <source lang="java">

import java.io.InputStream; import java.net.URL; import java.net.URLConnection; import java.util.logging.LogManager; public class Main { 

 public static void main(String[] argv) throws Exception {
   URLConnection urlConn = null;
   InputStream inStream = null;
   LogManager manager = null;
   URL url = new URL("http://www.xyz.ru/config.properties");
   urlConn = url.openConnection();
   inStream = urlConn.getInputStream();
   manager = LogManager.getLogManager();
   manager.readConfiguration(inStream);
 }

} 


 </source>



Return a message for logging.

   <source lang="java">

/** 

* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.io.PrintWriter; import java.io.StringWriter; import java.net.InetAddress; import java.net.URI; import java.net.URISyntaxException; import java.net.UnknownHostException; import java.text.DateFormat; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.StringTokenizer; import java.util.Collection;

/** 

* General string utils
*/

public class StringUtils { 

 /**
  * Return a message for logging.
  * @param prefix prefix keyword for the message
  * @param msg content of the message
  * @return a message for logging
  */
 private static String toStartupShutdownString(String prefix, String [] msg) {
   StringBuffer b = new StringBuffer(prefix);
   b.append("\n/************************************************************");
   for(String s : msg)
     b.append("\n" + prefix + s);
   b.append("\n************************************************************/");
   return b.toString();
 }

} 

 </source>



Setting a Filter on a Logger Handler

   <source lang="java">

import java.util.logging.ConsoleHandler; import java.util.logging.Filter; import java.util.logging.LogRecord; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   ConsoleHandler handler = new ConsoleHandler();
   handler.setFilter(new Filter() {
     public boolean isLoggable(LogRecord record) {
      return true;
     }
   });
   // Add the handler to a logger
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(handler);
 }

} 


 </source>



Setting the Formatter of a Logger Handler

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; public class Main{ 

 public static void main(String[] argv) throws Exception{
   Logger logger = Logger.getLogger("com.mycompany");
   FileHandler fh = new FileHandler("mylog.txt");
   fh.setFormatter(new SimpleFormatter());
   logger.addHandler(fh);
   // fh = new FileHandler("mylog.xml");
   // fh.setFormatter(new XMLFormatter());
   // logger.addHandler(fh);
   // Log a few messages
   logger.severe("my severe message");
   logger.warning("my warning message");
   logger.info("my info message");
   logger.config("my config message");
   logger.fine("my fine message");
   logger.finer("my finer message");
   logger.finest("my finest message");
 }

} 


 </source>



Simple Log Formatter Example

   <source lang="java">

// : c15:SimpleFormatterExample.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.ConsoleHandler; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.LogRecord; import java.util.logging.Logger; public class SimpleFormatterExample { 

 private static Logger logger = Logger.getLogger("SimpleFormatterExample");
 private static void logMessages() {
   logger.info("Line One");
   logger.info("Line Two");
 }
 public static void main(String[] args) {
   logger.setUseParentHandlers(false);
   Handler conHdlr = new ConsoleHandler();
   conHdlr.setFormatter(new Formatter() {
     public String format(LogRecord record) {
       return record.getLevel() + "  :  "
           + record.getSourceClassName() + " -:- "
           + record.getSourceMethodName() + " -:- "
           + record.getMessage() + "\n";
     }
   });
   logger.addHandler(conHdlr);
   logMessages();
 }

} ///:~ 



 </source>



Socket Handler Demo

   <source lang="java">

import java.util.logging.Logger; import java.util.logging.SocketHandler; public class Main { 

 public static void main(String args[]) throws Exception{
   SocketHandler handler = null;
   Logger logger = Logger.getLogger("your.logging");
   handler = new SocketHandler("127.0.0.1", 8080);
   logger.addHandler(handler);
   logger.warning("SocketHandler is working...");
 }

} 


 </source>



Stream Handler

   <source lang="java">

import java.io.OutputStream; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; import java.util.logging.StreamHandler; public class Main { 

 public static void main(String[] args) {
   Logger logger = Logger.getLogger("logging");
   OutputStream outStream = System.out;
   StreamHandler handler = new StreamHandler(outStream, new SimpleFormatter());
   logger.addHandler(handler);
   logger.setUseParentHandlers(false);
   logger.info("StreamHandler is working�");
 }

} 


 </source>



The Patterns in FileHandler

   <source lang="java">

Expression Meaning / The path separator of the local OS %t A directory suitable for storing temporary logging files, such as the temp directory of the OS %h A directory such as the "user.home" location, which is suitable to store user-specific data in the system %g A log generation number to rotate log files %u A number to make a log file unique to avoid any conflicts %% A literal percent sign 


 </source>



The Quintessential Logging Program

   <source lang="java">

import java.util.logging.Logger; //package com.mycompany; public class Main { 

 public static void main(String[] args) {
   Logger logger = Logger.getLogger("com.mycompany.BasicLogging");
   // Log a few message at different severity levels
   logger.severe("severe message");
   logger.warning("warning message");
   logger.info("info message");
   logger.config("config message");
   logger.fine("fine message");
   logger.finer("finer message");
   logger.finest("finest message");
 }

} 


 </source>



Use Logger with simple formatter and FileHandler

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; public class Main { 

 public static void main(String[] args) throws Exception {
   Logger logger = Logger.getLogger("MyLog");
   FileHandler fh;
   fh = new FileHandler("c:\\MyLogFile.log", true);
   logger.addHandler(fh);
   logger.setLevel(Level.ALL);
   SimpleFormatter formatter = new SimpleFormatter();
   fh.setFormatter(formatter);
   logger.log(Level.WARNING, "My first log");
 }

} 


 </source>



Using Regular Expressions based on StreamHandler

   <source lang="java">

import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.StreamHandler; import java.util.regex.Matcher; import java.util.regex.Pattern; public class MainClass { 

 public static void main(String args[]) {
   Logger log = Logger.getAnonymousLogger();
   setLoggerhandler(log);
   log.finest(new Exception().toString());
 }
 public static void setLoggerhandler(Logger logger) {
   Handler handler = new ExceptionHandler();
   logger.addHandler(handler);
   logger.setLevel(Level.ALL);
 }

} class ExceptionHandler extends StreamHandler { 

 public void publish(LogRecord record) {
   String msg = record.getMessage();
   int exceptionIndex = msg.indexOf("Exception");
   if (exceptionIndex > -1) {
     Pattern pattern = Pattern.rupile("(.*Exception.*)");
     Matcher matcher = pattern.matcher(msg);
     if (matcher != null && matcher.find()) {
       String err = "EXCEPTION FOUND " + matcher.group(1);
       System.out.println(err);
     }
   }
 }

} 


 </source>



Window Handler: display log message in a window(JFrame)

   <source lang="java">

import java.util.logging.ErrorManager; import java.util.logging.Filter; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTextArea; class LogWindow extends JFrame { 

 private JTextArea textArea = new JTextArea();
 public LogWindow() {
   super("");
   setSize(300, 300);
   add(new JScrollPane(textArea));
   setVisible(true);
 }
 public void showInfo(String data) {
   textArea.append(data);
   this.validate();
 }

} class WindowHandler extends Handler { 

 private LogWindow window = null;
 private Formatter formatter = null;
 private Level level = null;
 private static WindowHandler handler = null;
 private WindowHandler() {
   LogManager manager = LogManager.getLogManager();
   String className = this.getClass().getName();
   String level = manager.getProperty(className + ".level");
   setLevel(level != null ? Level.parse(level) : Level.INFO);
   if (window == null)
     window = new LogWindow();
 }
 public static synchronized WindowHandler getInstance() {
   if (handler == null) {
     handler = new WindowHandler();
   }
   return handler;
 }
 public synchronized void publish(LogRecord record) {
   String message = null;
   if (!isLoggable(record))
     return;
   message = getFormatter().format(record);
   window.showInfo(message);
 }
 public void close() {
 }
 public void flush() {
 }

} public class Main { 

 private WindowHandler handler = null;
 private Logger logger = null;
 public Main() {
   handler = WindowHandler.getInstance();
   logger = Logger.getLogger("logging.handler");
   logger.addHandler(handler);
 }
 public void logMessage() {
   logger.info("Hello from ...");
 }
 public static void main(String args[]) {
   Main demo = new Main();
   demo.logMessage();
   WindowHandler h = WindowHandler.getInstance();
   LogRecord r = new LogRecord(Level.WARNING, "The Handler publish method...");
   h.publish(r);
 }

} 


 </source>



Writing Log Records Only After a Condition Occurs

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class Main { 

 public static void main(String[] argv) throws Exception {
   FileHandler fhandler = new FileHandler("my.log");
   int numRec = 100;
   MemoryHandler mhandler = new MemoryHandler(fhandler, numRec, Level.SEVERE);
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(mhandler);
 }

} 


 </source>



Writing Log Records to a Log File

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   FileHandler handler = new FileHandler("my.log");
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(handler);
 }

} 


 </source>



Writing Log Records to Standard Error

   <source lang="java">

import java.util.logging.ConsoleHandler; import java.util.logging.Logger; public class Main { 

 public static void main(String[] argv) throws Exception {
   ConsoleHandler handler = new ConsoleHandler();
   // Add to logger
   Logger logger = Logger.getLogger("com.mycompany");
   logger.addHandler(handler);
 }

} 


 </source>



XMLFormatter based Logging

   <source lang="java">

import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.XMLFormatter; public class Main { 

 public static void main(String args[]) throws Exception{
   XMLFormatter formatter = new XMLFormatter();
   LogRecord record = new LogRecord(Level.INFO, "XML message..");
   FileHandler handler = new FileHandler("newxml.xml");
   handler.setFormatter(formatter);
   handler.publish(record);
   handler.flush();
 }

} 


 </source>
Источник — «http://jexp.ru/index.php?title=Java/Language_Basics/Log&oldid=7525»