Unable to get the classname and method with #Before Aspect - aspectj

Question

I have implemented AOP for logging purpose.
LoggingAspect
#Aspect
public class LoggingAspect {
private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(LoggingAspect.class);
#Before("execution(public * *(..))")
public void logBefore(JoinPoint joinPoint) {
System.out.println("logBefore() is running!");
System.out.println("classname : " + joinPoint.getClass().getCanonicalName() + "," + joinPoint.getSignature().getName());
System.out.println("******");
}
}
and the following configuration in app-ctx.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:component-scan
base-package="com.pms" />
<aop:aspectj-autoproxy />
<bean id="loggingAspect"
class="com.pms.advice.LoggingAspect" />
</beans>
but it output for all classes I get
logBefore() is running!
classname : org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint,getConnection
******
please advice

Answer 1

I will never understand why so many developers call methods on JoinPoint in order to extract specific information they get for free when just logging the joinpoint instance itself. There is everything: the joinpoint type, the method signature with class name and return type. This is what you need if you really want to know what is going on in your aspects. Hiding information by just logging a part of it makes debugging so much more difficult. Plus, calling a lot of methods does not make the logging aspect faster. And then they complain AOP is "slow". ;-)
Anyway, for what it is worth, you want to use joinPoint.getSignature().getDeclaringTypeName() here. What you are logging instead are the joinpoint class and the name of the intercepted method.
Attention, joinPoint.getSignature().getDeclaringType() would give you the dynamic proxy's type which is probably not what you want.
Update: If you use ((MethodSignature) thisJoinPoint.getSignature()).get*() you have access to a couple more getters:
Method getMethod()
Class getReturnType()
Class[] getParameterTypes()
Class[] getExceptionTypes()
String[] getParameterNames()
String toString()
int getModifiers()
String getName()
String toShortString()
String toLongString()
Class getDeclaringType()
String getDeclaringTypeName()
And, interesting enough, in this case ((MethodSignature) thisJoinPoint.getSignature()).getDeclaringType() gives you the real class and not the proxy class.

Answer 2

I might be late to party but it might help someone.
I believe that #Aaruhi want its implemented classes to be logged. If answer is yes, then this will help:
#Before("execution(* <your_pakage_name>..*.*(..))")
public void logBefore(JoinPoint joinPoint) {
System.out.println("logBefore() is running!");
System.out.println("classname : " + joinPoint.getSignature().getDeclaringTypeName() + "," + joinPoint.getSignature().getName());
System.out.println("******");
}
This will print logs for all private, public and internal methods. Please update <your_pakage_name>, this enables logging for all classes that fall under given <your_pakage_name>.
joinPoint.getSignature().getDeclaringTypeName()
- This will print your implementing class name.
NOTE - Update pointcut expression to execution(public * <your_pakage_name>..*.*(..)) to enable logging for public methods only.