How to use different logging
api with Apache Commons
Logging?:
In an Enterprise application, where there are many different
components and modules are getting involved in a request
processing task, finding bug or defect is very difficult
so long as logging mechanism is not configured with the
application. During development phase, importance of logging may
not be realized, but in production and/or deployment
environment it comes out to be of great relief, when some task
as planned, not function properly.
There are many logging framework available, some of these are open source
and some of these are commercial, and some of these are free. But the decision
of using a proper logging framework can change in future, depending on various
facts, one of these I can think of could be type of logging mechanism. Suppose
a need for sending an email on some critical bug to administrator arises. If
this type of logging mechanism is supported by the logging framework used today,
then it is alright, but if not, then, one has to implement their own logging api
with the desired feature. But in this way, there will be changes in many files,
starting from UI to the data layer. Imagine the type of impact in terms of
changes will be.
Apache commons logging provides a solution to this problem of code change with
logging mechanism or framework change.
I am going to show how it is helping us by providing simple to use API,
those can be configured externally without application code change (logging code).
There are three JAR files, to be placed in CLASSPATH (it depends on type of application)
in case of web application these could be placed in WEB-INF/lib folder.
In case of EAR enterprise application, these could be placed in common project
and entries in MANIFEST.MF file as "Class-path"(Open for Discussion).
Let us take an existing sample code from another discussion from "Using Log4j"
and changing it as shown below:
CommonsLoggingUsage.java
------------------------------------------------------------------------------
/**
* This code is provided "AS IS", user caution advised.
* Copyright: guddumails@yahoo.com
*/
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class CommonsLoggingUsage
{
private static Log logger = LogFactory.getLog(CommonsLoggingUsage.class);
public CommonsLoggingUsage()
{
analyse();
}
public void analyse()
{
logger.trace("Entering method analyse");
try{
String str = null;
System.out.println(str.toString());
}catch(Exception ex){
logger.error("In method analyse",ex);
}finally{
logger.trace("Exiting method analyse");
}
}
public static void main(String args[])
{
new CommonsLoggingUsage();
}
}
------------------------------------------------------------------------------
Here in this sample, instead of implementing Log4j or JDK1.4 logging related code,
we can see here one interface org.apache.commons.logging.Log and another
Factory abstract class org.apache.commons.logging.LogFactory is used. This makes
the above piece of code independent/not bound to any of the logging api/implementation,
but is configurable by some properties files as shown below:
One point I would like to say here is that, apache commons logging presently
not able to work with multiple logging api together, this means commons
logging uses only one logging api at a time, that can be configured in one of the
many ways as follows:
1. By defining a log implementation in a commons-logging.properties file.
2. By defining system environment variable such as
-Djava.util.logging.config.file=logging.properties, where logging.properties
has configuration settings for JDK1.4 logging api, such as,
--------------------------------
1.1 handlers=java.util.logging.FileHandler
1.2 java.util.logging.FileHandler.pattern=testjdklog.log
1.3 java.util.logging.FileHandler.append=true
--------------------------------
Line 1.1 defines type of Handler, ConsoleHandle - to output logged statement on
console, or FileHandler - to send logged statement to a file.
Line 1.2 defines the log file name in case of FileHandler.
Line 1.3 defines whether to append logged statement or not, generally append
is used as default setting.
As preference is given to point number 1 first and if no log implementation found then
point 2 is consider. So it is advisable to keep only one Log implementation to be used
with commons logging at a time, that is either Log4j or JDK1.4 Logging.
Steps used in this example are:
1. Sample code "CommonsLoggingUsage.java"
This Java code shows a very basic implementation of commons logging.
2. A properties file "commons-logging.properties"
This properties file is read by commons logging first, to read if any logging
framework is configured.
3. If our application is to use Log4j, then a configuration setting is required
as follows:
log4j.configuration=log4j.properties
4. So Log4j should be included in ClassPath, to use it. Or else
5. If JDK1.4 logging to be used, then follow steps as mentioned above:
Define a logging.properties file with following properties:
----------------------------------
handlers=java.util.logging.FileHandler
java.util.logging.FileHandler.pattern=testjdklog.log
java.util.logging.FileHandler.append=true
----------------------------------
6. Place this logging.properties file as System environment variable as
java -Djava.util.logging.config.file=logging.properties CommonsLoggingUsage
This makes CommonsLoggingUsage to use java.util.logging implementation from JDK
to be used as the log implementation for commons logging.
All contents of this site are copyrighted by the Author, Contact Author
Reproduction of any of these material from this site, in any form, is strictly prohibited.
 | Author of this article/writeup has expressed his/her willingness |
to help or guide users with any technical difficulties he/she faces
while working with the example code environment setting up, running
and resolving any such exception raised during compile or at runtime.
You may ask for any technical doubt or seek technical help related to
this article by using following form to reach for technical help
from the Author for FREE.
This article's Author shall be reading your request and responding
within reasonable time (no resolution timeframe defined as such).
|
|
<- requires login
