This week book give away

[Thomas Paul]

Please give a great big JavaRanch welcome to: Ramnivas Laddad, author of "AspectJ in Action".
This week we are giving away copies of this book to four lucky winners who participate in this forum.
So say hi and start asking your questions!

[Lasse Koskela]

Welcome Ramnivas!
We'll see whether this book promotion gets my aspects going... (I have to admit I haven't put as much effort as I would've liked into learning what it's all about)

[Ant Burge]

Hi Ramnivas,
I am not as well read in Java and design developments as I should be and the "JavaRanch Book Promotion" was pretty much the first I had heard of AOD and AspectJ. Having been brought up on OOAD, I would appreciate it if you could either list the salient differences/similarities between AspectJ and the "traditional" way of creating objects, or (if you think that is too lazy ), suggest some articles to get me started.
Many Thanks,
Ant
[ September 16, 2003: Message edited by: Ant B ]

[Ernest Friedman-Hill]

Hi Ramnivas,
Welcome to the Ranch, from a fellow Manning author!

[Pradeep bhatt]

Hi Ramnivas

[Ramnivas Laddad]

Thanks Everybody,
I am very delighted to be here and discuss your AOP/AspectJ questions.
About Ant Burge's question:
Crosscutting concerns � requirement, design, or implementation that span multiple modules are abound in practice: logging, tracing, dynamic profiling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. For example, a simple Account class may incorporate some code to address all of the above concerns. With aspect-oriented programming, you can implement each of the concern in a separate module called aspect.
Consider logging concern as an example. Traditional implementation may look something like:

public class Account {
static Logger _logger = Logger.getLogger(�banking�);
public void credit(float amount, �) throws � {
_logger.logp(Level.INFO, �Account�, �credit�, �Entering�);
� core logic (JDBC calls etc.)
}
� debit/getBalance implemented in a similar way with embedded logging 
}
� Other classes such as Customer implemented in a similar way

With AspectJ, you can keep you core classes oblivious of logging:

public class Account {
public void credit(float amount, �) throws � {
� core logic (JDBC calls etc.)
}
� debit/getBalance implemented in a similar way without embedded logging 
}
� Other classes such as Customer implemented in a similar way (without embedded logging)
import java.util.logging.*;
import org.aspectj.lang.*;
public aspect LoggerAspect {
    private Logger _logger = Logger.getLogger("banking");
    LoggerAspect () {
_logger.setLevel(Level.ALL);
    }
    pointcut loggedMethods()
: execution(* *.*(..)) && !within(LoggerAspect);
    before() : loggedMethods() {
if (_logger.isLoggable(Level.INFO)) {
    Signature sig = thisJoinPointStaticPart.getSignature();
    _logger.logp(Level.INFO,
 sig.getDeclaringType().getName(),
 sig.getName(),
 "Entering");
}
    }
}

That�s it. You can put this aspect into any Java program, compile using AspectJ compiler, and start seeing log output generated (which will be the same as the output generated by traditional implementation).
Now imagine a typical project with 100s, if not 1000s of classes and imagine a typical project with many other crosscutting present in a system. AspectJ can make life vastly simple by separating each individual concerns away from core business logic. Please read sample chapters (http://www.manning.com/laddad).
-Ramnivas

[Julio Cesar C Neto]

Hi Ramnivas,
I�m finished reading your book and its just great(advice for Javaranchers: buy it!). But a friend of mine asked me something that I really couldn�t answer. The question is about the fine-grained granularity about logging. For example, supose I have the following class:
public class {
public someMethod(String foo) {
String myVar = "java";
// do some stuff

//At this point I would like to know the value of myVar.
// How can I do this (with aspectj)?

// do some more stuff

}
}
The question is how aspectj can show the value of some private variables for some method, just for logging (to know if its value, in the middle of a computation, is right)?
Thank you,
Julio Cesar

[Lasse Koskela]

I doubt that you can define pointcuts in the middle of a method. Could someone confirm this?

[Ramnivas Laddad]

Julio Cesar,
Thanks for buying and reading my book.
Lasse is right. You cannot define a poincut to capture join points that modify a local variable. The reason for such constraint is (while perhaps useful for very fine grained logging) it can lead to unstable crosscutting. You can, however, access assignment or read-access to a instance and class data member inside a method as well as calls to other methods.
-Ramnivas

[Ant Burge]

Ramnivas,
thanks very much for the in depth answer: I was just expecting a link and a "go and work it out for yourself" type comment!
I can see now why you would want to use this over standard OOP. Time to get learning!
Thanks again,
Ant