How to match on type OR method annotation only once
up vote
0
down vote
favorite
I want to have a Guice interceptor that intercepts calls either to a class that is annotated, or a method that is annotated. I'd like to be able to combine both, ie. override the class annotation with a method annotation with different properties.
I have this working like this:
// Intercept all METHODS annotated with @MyAnnotation
bindInterceptor(
Matchers.any(),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.any(),
new TracingInterceptor());
However when I annotate a class like this:
@MyAnnotation
class MyClass {
@MyAnnotation
public void myMethod() {}
}
The interceptor gets called twice, which is bad!
Is there any way to avoid triggering the interceptor twice, but having the same behaviour?
aop guice interceptor
add a comment |
up vote
0
down vote
favorite
I want to have a Guice interceptor that intercepts calls either to a class that is annotated, or a method that is annotated. I'd like to be able to combine both, ie. override the class annotation with a method annotation with different properties.
I have this working like this:
// Intercept all METHODS annotated with @MyAnnotation
bindInterceptor(
Matchers.any(),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.any(),
new TracingInterceptor());
However when I annotate a class like this:
@MyAnnotation
class MyClass {
@MyAnnotation
public void myMethod() {}
}
The interceptor gets called twice, which is bad!
Is there any way to avoid triggering the interceptor twice, but having the same behaviour?
aop guice interceptor
add a comment |
up vote
0
down vote
favorite
up vote
0
down vote
favorite
I want to have a Guice interceptor that intercepts calls either to a class that is annotated, or a method that is annotated. I'd like to be able to combine both, ie. override the class annotation with a method annotation with different properties.
I have this working like this:
// Intercept all METHODS annotated with @MyAnnotation
bindInterceptor(
Matchers.any(),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.any(),
new TracingInterceptor());
However when I annotate a class like this:
@MyAnnotation
class MyClass {
@MyAnnotation
public void myMethod() {}
}
The interceptor gets called twice, which is bad!
Is there any way to avoid triggering the interceptor twice, but having the same behaviour?
aop guice interceptor
I want to have a Guice interceptor that intercepts calls either to a class that is annotated, or a method that is annotated. I'd like to be able to combine both, ie. override the class annotation with a method annotation with different properties.
I have this working like this:
// Intercept all METHODS annotated with @MyAnnotation
bindInterceptor(
Matchers.any(),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.any(),
new TracingInterceptor());
However when I annotate a class like this:
@MyAnnotation
class MyClass {
@MyAnnotation
public void myMethod() {}
}
The interceptor gets called twice, which is bad!
Is there any way to avoid triggering the interceptor twice, but having the same behaviour?
aop guice interceptor
aop guice interceptor
asked Nov 21 at 11:31
Dieter Van de Walle
10516
10516
add a comment |
add a comment |
1 Answer
1
active
oldest
votes
up vote
0
down vote
accepted
You can achieve this by making your binders mutually exclusive, like this:
// Intercept all METHODS annotated with @MyAnnotation in classes not annotated with @MyAnnotation
bindInterceptor(
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
new TracingInterceptor());
// Intercept all METHODS not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
add a comment |
1 Answer
1
active
oldest
votes
1 Answer
1
active
oldest
votes
active
oldest
votes
active
oldest
votes
up vote
0
down vote
accepted
You can achieve this by making your binders mutually exclusive, like this:
// Intercept all METHODS annotated with @MyAnnotation in classes not annotated with @MyAnnotation
bindInterceptor(
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
new TracingInterceptor());
// Intercept all METHODS not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
add a comment |
up vote
0
down vote
accepted
You can achieve this by making your binders mutually exclusive, like this:
// Intercept all METHODS annotated with @MyAnnotation in classes not annotated with @MyAnnotation
bindInterceptor(
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
new TracingInterceptor());
// Intercept all METHODS not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
add a comment |
up vote
0
down vote
accepted
up vote
0
down vote
accepted
You can achieve this by making your binders mutually exclusive, like this:
// Intercept all METHODS annotated with @MyAnnotation in classes not annotated with @MyAnnotation
bindInterceptor(
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
new TracingInterceptor());
// Intercept all METHODS not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
You can achieve this by making your binders mutually exclusive, like this:
// Intercept all METHODS annotated with @MyAnnotation in classes not annotated with @MyAnnotation
bindInterceptor(
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
// Intercept all methods not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.not(Matchers.annotatedWith(company.MyAnnotation)),
new TracingInterceptor());
// Intercept all METHODS not annotated with @MyAnnotation in CLASSES annotated with @MyAnnotation
bindInterceptor(
Matchers.annotatedWith(company.MyAnnotation),
Matchers.annotatedWith(company.MyAnnotation),
new TracingInterceptor());
edited Nov 21 at 22:49
answered Nov 21 at 21:13
Matthew Pope
959512
959512
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
add a comment |
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
A bit cumbersome, but it gets the job done! Thanks!
– Dieter Van de Walle
Nov 22 at 1:18
add a comment |
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53411162%2fhow-to-match-on-type-or-method-annotation-only-once%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown