I want to trace the beginning [& ending] of functions called in Java, like the following code:
public void foo() {
System.out.println("begin of foo()");
...
System.out.println("e-n-d of foo()");
}
But maintaining of the dump code System.out.println is something tedious and error-prone, for there may be tens of thounds of function in an class.
Any good idea can ease this work? I don't want dump statements all over the file.
Implementation of both or one of the beginning & ending traces is perferd.
But, if impossible, recordings of that the function has been called is also helpful. I mean not care the exact beginnig and ending, just tell that the function has been called.
The easiest approach is the one you've chose.
An easy replacement for the System.out calls would be using a logging framework. Then you could switch the information on and off according to a selected "logging level"
More sophisticated solutions would use aspect oriented programming techniques (provide by AspectJ, for instance), but this puts you on a steep learning curve.
Maybe a tool-based a approach fits your needs: so called "profilers" can "instrument" your code and report exactly which method was called during a run.
Another approach would be using BTrace - it is kind of similar to AspectJ but can attach to a running java application and apply the logging code on-the-fly (it can also detach from the application, removing all the injected code but leaving the app running as it was before using BTrace)
In order to use BTrace you would write a simple tracing script which is POJO annotated with BTrace annotations (and some restrictions regarding what is possible to use to avoid crashing the target application).
In this case the the script would look like this:
@BTrace public class FooTracer {
@OnMethod(clazz="Bar", method="foo")
public static void onEntry() {
println("begin of foo()");
}
@OnMethod(clazz="Bar", method="foo", location=@Location(Kind.RETURN))
public static void onExit() {
println("end of foo");
}
}
There are many more things you can do with BTrace - just refer to the user guide and examples. Nominally, it is console application but there is integration into VisualVM making the experience of working with BTrace more pleasant.
If there are lots of methods to log, AOP could be used. For example, aspectJ.
You could use log4j for this:
static Logger log = Logger.getLogger(
log4jExample.class.getName());
public void loggedMethod() {
log.info("begin of loggedMethod()");
...
log.info("e-n-d of loggedMethod()");
}
