Coverage Report

Coverage Report - org.apache.onami.autobind.aop.feature.InterceptorFeature

Classes in this File

Line Coverage

Branch Coverage

Complexity

InterceptorFeature

0/54

0/30

7.667

InterceptorFeature$1

0/2

N/A

7.667

 package org.apache.onami.autobind.aop.feature;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javax.inject.Singleton;
 import javax.interceptor.Interceptor;
 
 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
 import org.apache.onami.autobind.aop.ClassMatcher;
 import org.apache.onami.autobind.aop.GuiceMethodInterceptor;
 import org.apache.onami.autobind.aop.Invoke;
 import org.apache.onami.autobind.aop.MethodMatcher;
 import org.apache.onami.autobind.install.BindingStage;
 import org.apache.onami.autobind.scanner.features.BindingScannerFeature;
 
 import com.google.inject.matcher.Matcher;
 import com.google.inject.matcher.Matchers;
 
 
 @Singleton
 public class InterceptorFeature extends BindingScannerFeature {
         private Logger _logger = Logger.getLogger(InterceptorFeature.class.getName());
 
         @Override
         public BindingStage accept(Class<Object> annotatedClass, Map<String, Annotation> annotations) {
                 if (annotations.containsKey(Interceptor.class.getName())) {
                         return BindingStage.BOOT;
                 }
                 return BindingStage.IGNORE;
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public void process(Class<Object> annotatedClass, Map<String, Annotation> annotations) {
                 MethodInterceptor interceptor;
                 final Object possibleInterceptor = injector.getInstance(annotatedClass);
 
                 Matcher<? super Class<?>> classMatcher = null;
                 Matcher<? super Method> methodMatcher = null;
                 if (possibleInterceptor instanceof GuiceMethodInterceptor) {
                         interceptor = (MethodInterceptor) possibleInterceptor;
                         GuiceMethodInterceptor guiceInterceptor = (GuiceMethodInterceptor) interceptor;
                         classMatcher = guiceInterceptor.getClassMatcher();
                         methodMatcher = guiceInterceptor.getMethodMatcher();
                 } else {
                         Method[] declaredMethods = annotatedClass.getDeclaredMethods();
                         Map<Class<? extends Annotation>, Method> methods = new HashMap<Class<? extends Annotation>, Method>();
 
                         for (Method method : declaredMethods) {
                                 Annotation[] methodAnnotations = method.getAnnotations();
                                 for (Annotation methodAnnotation : methodAnnotations) {
                                         methods.put(methodAnnotation.annotationType(), method);
                                 }
                         }
                         try {
                                 if (methods.containsKey(ClassMatcher.class)) {
                                         Method method = methods.get(ClassMatcher.class);
                                         Type genericReturnType = method.getGenericReturnType();
                                         if (GuiceMethodInterceptor.CLASS_MATCHER_TYPE.equals(genericReturnType)) {
                                                 classMatcher = (Matcher<? super Class<?>>) method.invoke(
                                                         possibleInterceptor, new Object[0]);
                                         } else {
                                                 _logger.log(Level.WARNING,
                                                         "Return Type of the annotated @ClassMatcher-Method, does not return: "
                                                                         + GuiceMethodInterceptor.CLASS_MATCHER_TYPE
                                                                         + " instead it returns " + genericReturnType);
                                         }
                                 }
 
                                 if (methods.containsKey(MethodMatcher.class)) {
                                         Method method = methods.get(MethodMatcher.class);
                                         Type genericReturnType = method.getGenericReturnType();
                                         if (GuiceMethodInterceptor.METHOD_MATCHER_TYPE.equals(genericReturnType)) {
                                                 methodMatcher = (Matcher<? super Method>) method.invoke(
                                                         possibleInterceptor, new Object[0]);
                                         } else {
                                                 _logger.log(Level.WARNING,
                                                         "Return Type of the annotated @MethodMatcher-Method, does not return: "
                                                                         + GuiceMethodInterceptor.METHOD_MATCHER_TYPE
                                                                         + " instead it returns " + genericReturnType);
                                         }
                                 }
                         } catch (Exception e) {
                                 _logger
                                         .log(
                                                 Level.WARNING,
                                                 "Skipping process(..) of \""
                                                                 + annotatedClass
                                                                 + "\", because an Exception occured while trying to invoke a Method of the found Intercepter.",
                                                 e);
                                 return;
                         }
 
                         if (possibleInterceptor instanceof MethodInterceptor) {
                                 interceptor = (MethodInterceptor) possibleInterceptor;
                         } else {
                                 if (methods.containsKey(Invoke.class)) {
                                         final Method method = methods.get(Invoke.class);
                                         Class<?>[] parameterTypes = method.getParameterTypes();
                                         if (parameterTypes != null && parameterTypes.length == 1
                                                         && parameterTypes[0] == MethodInvocation.class) {
                                                 interceptor = new MethodInterceptor() {
                                                         @Override
                                                         public Object invoke(MethodInvocation invocation) throws Throwable {
                                                                 return method.invoke(possibleInterceptor, invocation);
                                                         }
                                                 };
                                         } else {
                                                 _logger
                                                         .log(
                                                                 Level.WARNING,
                                                                 "Skipping \""
                                                                                 + annotatedClass
                                                                                 + "\", because the Parameter of the with @Invoke annotated Method \""
                                                                                 + method.getName()
                                                                                 + "\" doesn't match the expected one. "
                                                                                 + method.getName() + "(MethodInvocation invocation)");
                                                 return;
                                         }
                                 } else {
                                         _logger.log(Level.WARNING, "Skipping \"" + annotatedClass
                                                         + "\" is either Child of \""
                                                         + GuiceMethodInterceptor.class.getName() + "\" / \""
                                                         + MethodInterceptor.class.getName()
                                                         + "\" nor has a Method annotated with \"" + Invoke.class.getName()
                                                         + "\"");
                                         return;
                                 }
                         }
                 }
 
                 if (classMatcher == null) {
                         classMatcher = Matchers.any();
                 }
 
                 if (methodMatcher == null) {
                         methodMatcher = Matchers.any();
                 }
 
                 _binder.bindInterceptor(classMatcher, methodMatcher, interceptor);
         }
 }

1		package org.apache.onami.autobind.aop.feature;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one or more
5		* contributor license agreements. See the NOTICE file distributed with
6		* this work for additional information regarding copyright ownership.
7		* The ASF licenses this file to You under the Apache License, Version 2.0
8		* (the "License"); you may not use this file except in compliance with
9		* the License. You may obtain a copy of the License at
10		*
11		* http://www.apache.org/licenses/LICENSE-2.0
12		*
13		* Unless required by applicable law or agreed to in writing, software
14		* distributed under the License is distributed on an "AS IS" BASIS,
15		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16		* See the License for the specific language governing permissions and
17		* limitations under the License.
18		*/
19
20		import java.lang.annotation.Annotation;
21		import java.lang.reflect.Method;
22		import java.lang.reflect.Type;
23		import java.util.HashMap;
24		import java.util.Map;
25		import java.util.logging.Level;
26		import java.util.logging.Logger;
27
28		import javax.inject.Singleton;
29		import javax.interceptor.Interceptor;
30
31		import org.aopalliance.intercept.MethodInterceptor;
32		import org.aopalliance.intercept.MethodInvocation;
33		import org.apache.onami.autobind.aop.ClassMatcher;
34		import org.apache.onami.autobind.aop.GuiceMethodInterceptor;
35		import org.apache.onami.autobind.aop.Invoke;
36		import org.apache.onami.autobind.aop.MethodMatcher;
37		import org.apache.onami.autobind.install.BindingStage;
38		import org.apache.onami.autobind.scanner.features.BindingScannerFeature;
39
40		import com.google.inject.matcher.Matcher;
41		import com.google.inject.matcher.Matchers;
42
43
44		@Singleton
45	0	public class InterceptorFeature extends BindingScannerFeature {
46	0	private Logger _logger = Logger.getLogger(InterceptorFeature.class.getName());
47
48		@Override
49		public BindingStage accept(Class<Object> annotatedClass, Map<String, Annotation> annotations) {
50	0	if (annotations.containsKey(Interceptor.class.getName())) {
51	0	return BindingStage.BOOT;
52		}
53	0	return BindingStage.IGNORE;
54		}
55
56		@SuppressWarnings("unchecked")
57		@Override
58		public void process(Class<Object> annotatedClass, Map<String, Annotation> annotations) {
59		MethodInterceptor interceptor;
60	0	final Object possibleInterceptor = injector.getInstance(annotatedClass);
61
62	0	Matcher<? super Class<?>> classMatcher = null;
63	0	Matcher<? super Method> methodMatcher = null;
64	0	if (possibleInterceptor instanceof GuiceMethodInterceptor) {
65	0	interceptor = (MethodInterceptor) possibleInterceptor;
66	0	GuiceMethodInterceptor guiceInterceptor = (GuiceMethodInterceptor) interceptor;
67	0	classMatcher = guiceInterceptor.getClassMatcher();
68	0	methodMatcher = guiceInterceptor.getMethodMatcher();
69	0	} else {
70	0	Method[] declaredMethods = annotatedClass.getDeclaredMethods();
71	0	Map<Class<? extends Annotation>, Method> methods = new HashMap<Class<? extends Annotation>, Method>();
72
73	0	for (Method method : declaredMethods) {
74	0	Annotation[] methodAnnotations = method.getAnnotations();
75	0	for (Annotation methodAnnotation : methodAnnotations) {
76	0	methods.put(methodAnnotation.annotationType(), method);
77		}
78		}
79		try {
80	0	if (methods.containsKey(ClassMatcher.class)) {
81	0	Method method = methods.get(ClassMatcher.class);
82	0	Type genericReturnType = method.getGenericReturnType();
83	0	if (GuiceMethodInterceptor.CLASS_MATCHER_TYPE.equals(genericReturnType)) {
84	0	classMatcher = (Matcher<? super Class<?>>) method.invoke(
85		possibleInterceptor, new Object[0]);
86		} else {
87	0	_logger.log(Level.WARNING,
88		"Return Type of the annotated @ClassMatcher-Method, does not return: "
89		+ GuiceMethodInterceptor.CLASS_MATCHER_TYPE
90		+ " instead it returns " + genericReturnType);
91		}
92		}
93
94	0	if (methods.containsKey(MethodMatcher.class)) {
95	0	Method method = methods.get(MethodMatcher.class);
96	0	Type genericReturnType = method.getGenericReturnType();
97	0	if (GuiceMethodInterceptor.METHOD_MATCHER_TYPE.equals(genericReturnType)) {
98	0	methodMatcher = (Matcher<? super Method>) method.invoke(
99		possibleInterceptor, new Object[0]);
100		} else {
101	0	_logger.log(Level.WARNING,
102		"Return Type of the annotated @MethodMatcher-Method, does not return: "
103		+ GuiceMethodInterceptor.METHOD_MATCHER_TYPE
104		+ " instead it returns " + genericReturnType);
105		}
106		}
107	0	} catch (Exception e) {
108	0	_logger
109		.log(
110		Level.WARNING,
111		"Skipping process(..) of \""
112		+ annotatedClass
113		+ "\", because an Exception occured while trying to invoke a Method of the found Intercepter.",
114		e);
115	0	return;
116	0	}
117
118	0	if (possibleInterceptor instanceof MethodInterceptor) {
119	0	interceptor = (MethodInterceptor) possibleInterceptor;
120		} else {
121	0	if (methods.containsKey(Invoke.class)) {
122	0	final Method method = methods.get(Invoke.class);
123	0	Class<?>[] parameterTypes = method.getParameterTypes();
124	0	if (parameterTypes != null && parameterTypes.length == 1
125		&& parameterTypes[0] == MethodInvocation.class) {
126	0	interceptor = new MethodInterceptor() {
127		@Override
128		public Object invoke(MethodInvocation invocation) throws Throwable {
129	0	return method.invoke(possibleInterceptor, invocation);
130		}
131		};
132		} else {
133	0	_logger
134		.log(
135		Level.WARNING,
136		"Skipping \""
137		+ annotatedClass
138		+ "\", because the Parameter of the with @Invoke annotated Method \""
139		+ method.getName()
140		+ "\" doesn't match the expected one. "
141		+ method.getName() + "(MethodInvocation invocation)");
142	0	return;
143		}
144	0	} else {
145	0	_logger.log(Level.WARNING, "Skipping \"" + annotatedClass
146		+ "\" is either Child of \""
147		+ GuiceMethodInterceptor.class.getName() + "\" / \""
148		+ MethodInterceptor.class.getName()
149		+ "\" nor has a Method annotated with \"" + Invoke.class.getName()
150		+ "\"");
151	0	return;
152		}
153		}
154		}
155
156	0	if (classMatcher == null) {
157	0	classMatcher = Matchers.any();
158		}
159
160	0	if (methodMatcher == null) {
161	0	methodMatcher = Matchers.any();
162		}
163
164	0	_binder.bindInterceptor(classMatcher, methodMatcher, interceptor);
165	0	}
166		}