Lew<noone@lewscanon.com> wrote in news:jibf3u$ee9$1@news.albasani.net:
Novice wrote:
Lew wrote:
Logging is a great use case for aspects. However, there are
alternatives to lessening logging's overhead, too. You have to weigh
costs and benefits.
What are other good ways to do logging?
log4j is my favorite.
Right now, the two main programs in my current project each create
their own logger and then pass it to the classes they call in their
parameters.
I don't think that's a good pattern. Which logging library are you
using?
I'm using Java Logging. Does that answer your question or are you asking
something else?
I have each class create its own logger (log4j style shown:
package eegee;
import org.apache.log4j.Logger;
import static org.apache.log4j.Logger.getLogger;
public class Foo
{
final Logger logger = getLogger(getClass());
public void foo()
{
logger.debug("");
// do the fooey stuff
try
{
// do the trying stuff
}
catch (FooException exc)
{
String msg = "trying stuff failed. "+
exc.getLocalizedMessage(); logger.error(msg, exc);
throw new IllegalStateException(msg, exc);
}
}
}
This boilerplate is what aspects aim to remove from the code and I
espouse retaining.
My code is not terribly different than that.
Here's the actual code minus the Javadoc comment:
================================================================
public static Logger configureLogger(String className, String
logFilePath, String logFileName, Locale locale, Formatter formatter,
Level loggingLevel) {
String METHOD_NAME = "configureLogger()"; //$NON-NLS-1$
/* Ensure that the mandatory parameters have all been specified. */
if (className == null) {
throw new IllegalArgumentException("The name of the class must
be provided."); //$NON-NLS-1$
}
if (logFilePath == null) {
throw new IllegalArgumentException("The log file path must be
provided."); //$NON-NLS-1$
}
if (logFileName == null) {
throw new IllegalArgumentException("The log file name must be
provided."); //$NON-NLS-1$
}
if (locale == null) {
throw new IllegalArgumentException("The locale must be
provided."); //$NON-NLS-1$
}
/* Create the logger. */
Logger logger = Logger.getLogger(className);
/* Create path identified by logFilePath if it does not exist. */
File path = new File(logFilePath);
if (!path.exists()) {
path.mkdir();
}
/* If the invoking class has specified a logging level, use it.
Otherwise, set a default level. */
if (loggingLevel != null) {
logger.setLevel(loggingLevel);
}
else {
logger.setLevel(Level.INFO);
}
/* Create a file handler for the logger. The log file name does NOT
need to exist prior to the execution of this method. */
String logFile = logFilePath + File.separator + logFileName;
Handler logFileHandler = null;
try {
logFileHandler = new FileHandler(logFile);
}
catch (IOException io_excp) {
String msg = CLASS_NAME + "." + METHOD_NAME + " - Couldn't
create FileHandler using file " + logFile + ".\n Details: " + io_excp +
". The stackTrace from this event has been written to the console."; //
$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
io_excp.printStackTrace();
JOptionPane.showMessageDialog(null, msg, CLASS_NAME,
JOptionPane.ERROR_MESSAGE);
return logger;
}
logger.addHandler(logFileHandler);
/* If the invoking class has specified a formatter, use it.
Otherwise, don't add a formatter. */
if (formatter != null) {
Handler[] handlers = logger.getHandlers();
for (Handler oneHandler : handlers) {
if (oneHandler.getClass().getName().equals
("java.util.logging.FileHandler")) { //$NON-NLS-1$
oneHandler.setFormatter(formatter);
}
}
}
return logger;
}
================================================================
I put that in a utility class in my Common project. Then any program that
wants a logger just executes this one method passing the appropriate
parameters.