The performance hit is not in executing the use method.

The hit comes form the fact the whist you are executing the closure the way in which the MetaClass resolves calls is changed. So whist you have a category applies all your calls will be slower (this includes calls to objects which the Category has not touched).

In addition this performance hit is taken by all the threads in the JVM not just the thread which is applying the Category.

The current implementation makes the method calls about three times slower when a Category is applied.

There is no intrinsic reason why the run time system should impose this overhead and I would expect future versions of Groovy to reduce this overhead to virtually nothing (I have written a working MetaClass implementation for another dynamic language for the JVM which supports Categories and imposes a call overhead of less than 1% and that overhead is only incurred by the thread which uses the Category).

If you suspect that a lot of calls to use() will be ensued the n it would be better to ‘bootstrap’ all your categories at once and enclose your code, this is the same approach groovlets have, as John previously commented too. Remember that you can declare more than one category with just one call to use() =)

I thought about putting the use code in a surrounding method, and it works ok. That is until some other client tries to call the method containing the category code without a use block… I wanted a way to guarantee that the method was inside a use block.

And, if nothing else, this can be treated as an example of how to use Groovy, annotations and aspects all together.

use(MeasurementCategory) {
…
}

Your annotation takes more keystrokes than that!

If you don’t want to put the use in your function you can just put it in your main function

static main(args) {
use(MeasurementCategory) {
new MyClass().start()
}
}

categories are inherited by methods called from within the closure.