Question

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?

Answer 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.