如何将方法拦截器绑定到提供程序？

Guice 不允许在不是由 Guice 构建的实例上使用 AOP：Guice AOP 限制

“实例必须由 Guice 通过@Inject注释或无参数构造函数创建”

这意味着使用提供程序创建的实例不会是 AOP 的候选实例。

另一方面，只要 Guice 在上述条件下实例化您的提供程序，您的提供程序就可能是 AOP 的候选者。

下面是一个示例来演示这一点：

AOP 注释：

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
@interface AOPExample {}

供应商：

public class ExampleProvider implements Provider<Example> {

    @AOPExample
    public Example get() {
        System.out.println("Building...");
        return new Example();
    }
}

目标示例：

public class Example {

    @AOPExample
    public void tryMe() {
        System.out.println("example working...");
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

模块：

public class ExampleModule extends AbstractModule {
    @Override
    protected void configure() {
        bindInterceptor(Matchers.any(), Matchers.annotatedWith(AOPExample.class), new LoggingAOP());

        bind(Example.class).toProvider(ExampleProvider.class);
    }
}

测试代码：

public class Test {

    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new TestModule());

        ExampleProvider exampleProvider = injector.getInstance(ExampleProvider.class);
        Example example = exampleProvider.get();

        example.tryMe();

        Example directExample = injector.getInstance(Example.class);

        directExample.tryMe();

    }
}

测试输出：

start
Building...
end took: 3
example working...
start
Building...
end took: 0
example working...

请注意，“示例正在工作...”不被计时器代码包围。然而，Provider.get（“Building...”）是。

如果你的问题是：拦截器（新的 INTERCEPTOR（））可以通过Guice提供程序提供，答案是否定的。最接近此功能的是调用模块配置方法中的 requestInjection（）。这将为您的拦截器注入适当的代码。从拦截器中，您可以使用提供程序来避免在启动期间导致您速度变慢的任何开销。

这就是我的意思：

模块：

public class TestModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(String.class).toInstance("One");
        bind(String.class).annotatedWith(Names.named("two")).toInstance("Two");

        LoggingAOP loggingAOP = new LoggingAOP();

        bindInterceptor(Matchers.any(), Matchers.annotatedWith(AOPExample.class), loggingAOP);

        requestInjection(loggingAOP);

        bind(Example.class).toProvider(ExampleProvider.class);
    }
}

拦截 器：

public class LoggingAOP implements MethodInterceptor {

    @Inject
    private Provider<SomethingThatTakesALongTimeToInit> provider;

    public Object invoke(MethodInvocation invocation) throws Throwable {
        provider.get()...
        System.out.println("start");
        long start = System.currentTimeMillis();
        Object value =  invocation.proceed();
        System.out.println("end took: " + (System.currentTimeMillis() - start));
        return value;
    }
}

希望这能回答您的问题。

正如我所读到的，问题是，如何将拦截器类型本身绑定到提供程序，而不必在配置时实例化拦截器。

我不认为有一个简单的方法来做到这一点，但是可以编写一个拦截器，它本身接受实现类型的提供者。Guice AOP 文档中显示了这方面的一个示例：

public class NotOnWeekendsModule extends AbstractModule {
    protected void configure() {
    bindInterceptor(any(),
                    annotatedWith(NotOnWeekends.class),
                    new WeekendBlocker(getProvider(Calendar.class)));
    }
}