4:49 p.m.
I have three classes like these:
public class SqtpSkeleton{
| protected Log objLog=null;
| // and so on...
| }
|
| public class SqtpService extends SqtpSkeleton{
| //other fields and methods.....
| }
|
| public class MyService extends SqtpService{
| public void init(){
| objLog = new Log("c:/logFile.log",255);
| }
| public void execute(){
| objLog.write("START");
| //do something
| }
| }
Now I want to intercept the logObject of MyService class, because I want to use the same
log object declared in MyService class, in a LogInterceptor. I want this behaviour because
the LogInterceptor have to log operations in the same file that the class use for its own
logging.
Initially I have created an aspect with two advices where the first advice intercept the
FieldWriteInvocation to the object Log objLog in MyService class, and the second advice to
intercept any other invocation such as MethodInvocation or ConstructorInvocation that uses
the intercepted log object by the first advice.
Here is the example of the code for my Aspect:
public class LogAspect {
| private static final String className = "LogAspect";
| private static final String DBG_ERROR = "ERROR";
| private static final String DBG_WARNING = "WARNING";
| private static final String DBG_INFO = "INFO";
| private static final String DBG_TRACE = "TRACE";
| private String propertyFile;
| private Log log;
|
|
| public void setPropertyFile(String propertyFile) {
| this.propertyFile = propertyFile;
| }
|
| public void setLog(Log log) {
| this.log = log;
| }
|
| public String getName() {
| return "LogAspect";
| }
|
| public Object getLogger(Invocation invocation) throws Throwable{
| try{
| System.out.println("INGRESSO nel getLogger() for " +
Thread.currentThread().getName());
| if (invocation instanceof FieldWriteInvocation) {
| FieldWriteInvocation fieldInvocation = (FieldWriteInvocation)invocation;
| setLog((Log)fieldInvocation.getValue());
| } else
| System.out.println("Unknown Invocation!!");
| return invocation.invokeNext();
| } finally {
| System.out.println("USCITA dal getLogger() for " +
Thread.currentThread().getName());
| }
| }
|
| public Object trace(Invocation invocation) throws Throwable{
| String proc = className + ".trace()";
| long startTime = System.currentTimeMillis();
| logInfo(proc, "START");
| logTrace(proc, invocationTypeValue(invocation));
| Object response = null;
| try {
| response = invocation.invokeNext();
| return response;
| }catch(Throwable t) {
| long endTime = System.currentTimeMillis();
| long elapsedTime = endTime - startTime;
| logErr(proc, t.getMessage() + " - Tempo di esecuzione (ms): " +
elapsedTime);
| throw t;
| }
| finally {
| long endTime = System.currentTimeMillis();
| long elapsedTime = endTime - startTime;
| logTrace(proc,dumpInvocationResponse(invocation, response) + " - Tempo
di esecuzione (ms): " + elapsedTime);
| logInfo(proc, "END");
| }
| }
|
|
| /**
| * visualizza informazioni utili circa la risposta della chiamata
| * @param l'oggetto invocation, contenente il tipo di chiamata intercettatta
dall'interceptor
| * @return la stringa indicante il valore di ritorno del metodo intercettato (se
presente)
| */
| public String dumpInvocationResponse(Invocation invocation, Object response) {
|
| StringBuffer buffer = new StringBuffer();
| String genericName;
| String returnType;
| String modifier;
| if (invocation instanceof MethodInvocation) {
| MethodInvocation methodInvocation = (MethodInvocation)invocation;
| genericName = methodInvocation.getMethod().getName();
| returnType = methodInvocation.getMethod().getReturnType().getName();
| modifier = Modifier.toString(methodInvocation.getMethod().getModifiers());
| buffer.append(modifier + " ").append(returnType + "
").append(genericName).append("()");
| buffer.append(" ( return ");
| if (response == null)
| buffer.append("NULL");
| else
|
buffer.append(response.getClass().getSimpleName()).append(":").append(response.toString());
| buffer.append(" )");
| }else if(invocation instanceof ConstructorInvocation) {
| ConstructorInvocation cInvocation = (ConstructorInvocation)invocation;
| genericName = cInvocation.getConstructor().getDeclaringClass().getSimpleName();
| modifier = Modifier.toString(cInvocation.getConstructor().getModifiers());
| buffer.append(modifier + "
").append(genericName).append("()");
| }
| return buffer.toString();
| }
|
| /**
| * Metodo che ritorna la stringa rappresentante la 'Signature' del metodo o
del costruttore
| * wrappato dalla MethodInvocation o ConstructorInvocation.
| * La 'Signature' è composta dal nome del metodo / costruttore, preceduto da
eventuali modificatori, e dalla lista di parametri
| * che lo compongono organizzata per 'tipo;valore', in cui il valore è
l'informazione a runtime del suddetto parametro
| * @param Invocation l'oggetto per il tipo di invocazione
| * @return la stringa contenente la signature del metodo / costruttore invocato
| */
| private String invocationTypeValue (Invocation invocation) {
|
| String genericName;
| String returnType;
| String modifier;
| Object[] argumentsValue;
| Class[] argumentsType;
| //Class[] exception;
| StringBuffer buffer = new StringBuffer();
|
| if (invocation instanceof MethodInvocation) {
| MethodInvocation mi = (MethodInvocation)invocation;
| genericName = mi.getMethod().getName();
| returnType = mi.getMethod().getReturnType().getName();
| modifier = Modifier.toString(mi.getMethod().getModifiers());
| argumentsValue = mi.getArguments();
| argumentsType = mi.getMethod().getParameterTypes();
| //exception = mi.getMethod().getExceptionTypes();
| buffer.append(modifier + " ").append(returnType + "
").append(genericName);
| if (argumentsType == null || argumentsType.length == 0) {
| buffer.append("()");
| return buffer.toString();
| }
| } else if (invocation instanceof ConstructorInvocation) {
| ConstructorInvocation ci = (ConstructorInvocation)invocation;
| genericName = ci.getConstructor().getDeclaringClass().getSimpleName();
| modifier = Modifier.toString(ci.getConstructor().getModifiers());
| argumentsValue = ci.getArguments();
| argumentsType = ci.getConstructor().getParameterTypes();
| //exception = ci.getConstructor().getExceptionTypes();
| buffer.append(modifier + " ").append(genericName);
| if (argumentsType == null || argumentsType.length == 0) {
| buffer.append("()");
| return buffer.toString();
| }
| } else {
| return "Unknown " + invocation;
| }
|
| //buffer.append(genericName.substring(0, genericName.indexOf('(')));
| if (argumentsValue.length != argumentsType.length)
| System.out.println("Type");//throw new RuntimeException(" Type and
Value mismatch");
| for (int i = 0; i < argumentsValue.length; i++) {
| if(i == 0)
| buffer.append(" (");
| if(argumentsType.isArray()){
| Object[] arrayArgument = (Object[])argumentsValue;
| buffer.append(argumentsType.getSimpleName()).append(":");
| if(arrayArgument.length > 20)
| buffer.append("Lenght = " + arrayArgument.length);
| else
| buffer.append(Arrays.toString(arrayArgument));
| }else
|
buffer.append(argumentsType.getSimpleName()).append(":").append(argumentsValue.toString());
| if( i == argumentsValue.length - 1){
| buffer.append(")");
| break;
| }
| buffer.append(", ");
| }
| /*
| if(exception != null && exception.length > 0){
| buffer.append(" throws ");
| for (int i = 0; i < exception.length; i++) {
| buffer.append(exception.getName());
| if (i == exception.length-1)
| break;
| buffer.append(", ");
| }
| }*/
| return buffer.toString();
| }
|
| private void logErr(String proc, String message) {
| System.out.println(DBG_ERROR + ": " + message);
| if (log != null) {
| log.logWrite(log.DBG_ERROR, proc, message);
| }
| }
|
| private void logWarning(String proc, String message) {
| System.out.println(DBG_WARNING + ": " + message);
| if (log != null) {
| log.logWrite(log.DBG_WARNING, proc, message);
| }
| }
|
| private void logInfo(String proc, String message) {
| System.out.println(DBG_INFO + ": " + message);
| if (log != null) {
| log.logWrite(log.DBG_INFO, proc, message);
| }
| }
|
| private void logTrace(String proc, String message) {
| System.out.println(DBG_TRACE + ": " + message);
| if (log != null) {
| log.logWrite(log.DBG_TRACE, proc, message);
| }
| }
|
| }
Here is my jboss-aop.xml for binding aspect to pointucts:
<aop>
| <!-- Declarigng pointucs -->
| <pointcut name="logObject" expr="set(util.log.Log
test.aop.MyService->objLog)"/>
| <pointcut name="logMethod" expr="execution(public *
test.aop.MyService->*(..))"/>
|
| <pointcut name="logObject_2" expr="set(util.log.Log
$instanceof{test.aop.SqtpSkeleton}->*)"/>
|
| <!-- Declaring Aspect -->
| <aspect name="LogAspect" class="test.aop.LogAspect"
scope="PER_INSTANCE"/>
|
| <!-- Bind pountcuts to aspects -->
| <bind pointcut="logObject">
| <advice name="getLogger" aspect="LogAspect"/>
| </bind>
|
| <bind pointcut="logMethod">
| <advice name="trace" aspect="LogAspect"/>
| </bind>
|
| </aop>
The main problem is that the LogAspect doesn't intercept the FieldWriteInvocation on
object objLog in MyService class, so I can't use this for logging operation in the
trace() advice. If I use the second pointcut expression :
<pointcut name="logObject_2" expr="set(util.log.Log
$instanceof{test.aop.SqtpSkeleton}->*)"/>
the Aspect intercept the invocation but, it only see the FieldWrite (objLog = null) in the
SqtpSkeleton class, and not in its inherited classes so If call
FieldWriteInvocation.getValue(), it returns null.
How can I solve this problem?
Do you have any suggestions or alternative strategy to avoid this problem?
Please help me!!!
View the original post :
http://www.jboss.com/index.html?module=bb&op=viewtopic&p=3995729#...
Reply to the post :
http://www.jboss.com/index.html?module=bb&op=posting&mode=reply&a...