Traditional logging vs AOP logging

I'm starting this new project and we are thrashing out our logging/debugging approach and I wanted to put the question to the rest of you on SO, given

private final static Logger logger = LoggerFactory.getLogger(getClass());
...
public void doSumething(){
...
if(logger.isDebugEnabled())
    logger.debug("...");
}

or

 @After("execution(* *.doSomething())")
    public void logAfter(JoinPoint jp){
        logger.debug("...");
    }

Is the AOP approach really any better than using the traditional approach? Or does AOP excel in a particular use case for logging/profiling?

Solution 1:

For performance, AOP approach certainly has a little overhead against the traditional one.

One of the many strengths of AOP is that it allows you to separate your non-business concerns from your business logic. It also helps you in mundane tasks such putting a logging logic in each of your method or place a try-catch statement on each method.

I think the real issue is that if the performance overhead (in my experience which is only minimal) would compensate on the mundane tasks that you have to go through while developing.

A friend told me before that it's better to have a slower app that is maintainable and scalable than having a faster app that would give you hell in maintenance. Slowness could be compensated in many ways, such as upgrading hardware and etc.

This is just my two cents, hope this helps.

Solution 2:

I dont think these should be viewed as mutually exclusive alternatives.

I think AOP is great for tracing (i.e. logging method entry/exit and parameter values).

I still use regular logging as well:

1. For Info/Warning/Error Messages
2. For debug messages during development to see the value of certain variables or to see which if/then path is used etc.