Guice won't intercept annotated methods

Question

I have a situation where Guice is working for some bindings, and not at all for others. Clearly I am using the API incorrectly. In part, it's probably because I'm trying to get too "fancy" with how I'm using Guice. I've created an inheritance tree of `Module`s and I think I've gotten too clever (or foolish!) for my own good. Before you look at the code below, just please understand my intention, which was to provide a reusable `Module` that I can place in a JAR and share across multiple projects. This abstract, reusable `Module` would provide so-called "default bindings" that any implementing `Module` would automatically honor. Things like an AOP `MethodInterceptor` called `Profiler`, which looks for methods annotated with `@Calibrated` and automatically logs how long it took for that method to execute, etc. Observe the following: ``` @Target({ ElementType.METHOD }) @RetentionPolicy(RetentionPolicy.RUNTIME) @BindingAnnotation public @interface Calibrated{} public class Profiler implem…

Accepted Answer

Interception only works on Objects created by Guice (see "Limitations" http://code.google.com/p/google-guice/wiki/AOP#Limitations). You are using "new" to create the DummyObj, so no matter how clever your Module is Set up, the instance is created Outside guice.

Here's a little snipplet based on your coding. (I use your Calibrated Annotation, but had everything else in one class. You should have a look at "AbstractModule". It saves a lot of manual stuff you did with your Module-Hierarchy.

```
public class MyModule extends AbstractModule implements MethodInterceptor {

@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {

System.out.println("Intercepted@invoke!");

return methodInvocation.proceed();
}

@Override
protected void configure() {
    bind(Integer.class).annotatedWith(Names.named("nonsense")).toInstance(29);
    bindInterceptor(Matchers.any(), Matchers.annotatedWith(Calibrated.class), this);
}

public static void main(String... args) {
    Dummy dummy = Guice.createInjector(new MyModule()).getInstance(Dummy.class);

dummy.doSomething();

System.out.println(dummy.getNonsense());
}
}
```

And my Dummy:

```
public class Dummy {

@Inject
@Named("nonsense")
private int nonsense;

public int getNonsense() {
    return nonsense;
}

public void setNonsense(int nonsense) {
    this.nonsense = nonsense;
}

@Calibrated
public void doSomething() {
    System.out.println("I have been intercepted!");
}
}
```

So you see? I never use the word "new" (except for the Module ....). I let Guice handle the Dummy-Object and just configure the value for the nonsense int, which is then injected.

Output:

```
Intercepted@invoke!
I have been intercepted!
29
```

Guice won't intercept annotated methods

Solution

Problem