Holger's Java API

## Package com.antelmann.util.logging

This package contains classes that implement a custom logging for this framework - separate from java.util.logging.

See:
Description

Interface Summary
LogEntryFormatter<T>: allows for several LogWriters to share the same formatting
LogExceptionHandler: A LogExceptionHandler is used to control the behavior of a Logger in regards to occuring LogException events.
LoggerProvider: denotes a class that provides a suitable Logger for itself that allows to log data within the context of the implementing class.
LogWriter: The LogWriter interface defines objects that can be used as a handler for the Logger class.

Class Summary
AbstractExceptionWriter: an abstract class to handle exceptions that occur in a LogEntry.
AbstractLogWriter<T>: provides filtering capabilities for a LogWriter.
AppendableLogWriter: writes to a given Appendable (PrintStream, StringBuffer, etc) using a String
AsynchLogWriter: allows to operate any LogWriter asynchronously.
BinaryFileLog: A LogWriter that logs the entries synchronously serialized to a file.
BinaryLogFormatter: formats the LogEntry as a serialized byte array.
ConsoleLog: ConsoleLog prints abbreviated log messages to the console using `System.out.println()`.
DBLineLogFormatter: formats a LogEntry into a format that can be easily imported into databases.
EmailWriter: uses email to send each LogEntry object over the Internet.
ExceptionDialogWriter: shows a dialog upon each Throwable encountered.
FileLog: writes entries to a file without continuously holding a lock on the file.
JDBCLogWriter: JDBCLogWriter provides a LogWriter that writes to a java.sql.Connection.
JTextAreaLog: a more efficient visible log as it uses JTextArea methods to append the text
JTextComponentLog: JTextComponentLog writes abbreviated log messages into a given JTextComponent synchronously.
Level: Level classifies the logging of LogEntry objects.
LevelFilter: filters LogEntry objects by their level using the natural order of Level objects
LogEntry: LogEntry represents a single record of a log logged by a Logger object and handled by a LogWriter object.
LogFile: LogFile provides great convenience for logging information from a program into a file.
Logger: Logger somewhat leans on the functionality of the java.util.logging functionality of J2SE 1.4, but it's not quite the same (and was implemented before J2SE 1.4).
LoggerCache: provides a simple mechanism to cache LogEntries from a Logger
LoggerHandler: provides a bridge to the java.util.logging facility
LoggerManager: a central point to manager different Logger instances
LoggerWriter: provides a writer that propagates the LogEntries to another logger
LogNetPropagator: can be registered to listen logging events and then propagates them as serialized byte arrays over its NetConnectionServer.
LogNetReceiver: can be used to easily listen to a LogNetPropagator; most easily used in conjunction with a MessageDispatcher.
MemoryLogger: allows to monitor memory usage through a Logger.
SocketLogListener: used to listen to LogEntry objects send through a NetConnection.
SocketWriter: simply used to write serialized LogEntry objects via network
StackTraceFileWriter: writes full stack trace of entries that log an exception to a given file.
StringLineFormatter: formats a LogEntry into a simple one-line String terminated by a line break.
XMLLogFormatter: formats LogEntry objects as XML.
XMLLogWriter: writes LogEntry objects formatted as XML to either a PrintStream or PrintWriter.

Exception Summary
LogException: LogException is thrown when a problem is encountered while writing to a LogWriter

## Package com.antelmann.util.logging Description

This package contains classes that implement a custom logging for this framework - separate from java.util.logging.

The classes in this package have been implemented prior to J2SE 1.4 when java.util.logging became available. However, they have been slightly changed since then and were finally put in this package (as they were in com.antelmann.util before), so that they are kept separate.

One difference between this com.antelmann.util.logging and java.util.logging is that this logging here can be synchronous, i.e. the log entry may be flushed to its destination every time before any of the logging methods return - done at the discretion of any given LogWriter object. Also, exceptions that may occur can be propagated into the thread that called the log method (alternatively, this can be handled by setting up a separate exception handler). In addition, the log entry here can include a full stack trace of the occurrence. Finally, this logging facility is somewhat simpler (naturally, as it is not as complex).

There are of course many more differences, but the above is the main thing.

(c) Holger Antelmann since 2001- all rights reserved (contact: info@antelmann.com)
see www.antelmann.com/developer for further details and available downloads