private Map<Object, List<Method>> findAnnotatedMethods(final Map<Object, List<Method>> map, final Class<? extends Annotation> annotation) { for (final Map.Entry<Object, ClassFinder> finder : testClassFinders.entrySet()) { final Object key = finder.getKey(); final List<Method> newAnnotatedMethods = finder.getValue().findAnnotatedMethods(annotation); List<Method> annotatedMethods = map.get(key); if (annotatedMethods == null) { annotatedMethods = newAnnotatedMethods; map.put(key, annotatedMethods); } else { annotatedMethods.addAll(newAnnotatedMethods); } } return map; }
private static void add(final ClassFinder finder, final Set<Method> methods, final Class<? extends Annotation> annotation) { final List<Method> annotatedMethods = finder.findAnnotatedMethods(annotation); for (final Method method : annotatedMethods) { SetAccessible.on(method); methods.add(method); } }
private static void add(final ClassFinder finder, final Set<Method> methods, final Class<? extends Annotation> annotation) { final List<Method> annotatedMethods = finder.findAnnotatedMethods(annotation); for (final Method method : annotatedMethods) { SetAccessible.on(method); methods.add(method); } }
@Override public void run() { for (final Map.Entry<Object, ClassFinder> m : testClassFinders.entrySet()) { for (final Method mtd : m.getValue().findAnnotatedMethods(PreDestroy.class)) { if (mtd.getParameterTypes().length == 0) { if (!mtd.isAccessible()) { mtd.setAccessible(true); } try { mtd.invoke(mtd.getDeclaringClass() == type ? appInstance : m.getKey()); } catch (final IllegalAccessException | InvocationTargetException e) { // no-op } } } } } });
private Map<Object, List<Method>> findAnnotatedMethods(final Map<Object, List<Method>> map, final Class<? extends Annotation> annotation) { for (final Map.Entry<Object, ClassFinder> finder : testClassFinders.entrySet()) { final Object key = finder.getKey(); final List<Method> newAnnotatedMethods = finder.getValue().findAnnotatedMethods(annotation); List<Method> annotatedMethods = map.get(key); if (annotatedMethods == null) { annotatedMethods = newAnnotatedMethods; map.put(key, annotatedMethods); } else { for (final Method m : newAnnotatedMethods) { if (!annotatedMethods.contains(m)) { annotatedMethods.add(m); } } } } return map; }
private List<Method> retrieveAroundInvokes(final Class<?> interceptorClass) { final List<Method> cached = this.interceptorCache.get(interceptorClass); if (cached != null) { return cached; } final ClassFinder finder = new ClassFinder(interceptorClass); List<Method> annotated = finder.findAnnotatedMethods(AroundInvoke.class); if (StatelessContainer.class.getClassLoader() == interceptorClass.getClassLoader()) { // use cache only for server classes final List<Method> value = new CopyOnWriteArrayList<Method>(annotated); annotated = this.interceptorCache.putIfAbsent(interceptorClass, annotated); // ensure it to be thread safe if (annotated == null) { annotated = value; } } return annotated; }
public StatsInterceptor(final Class<?> componentClass) { monitor = componentClass.getAnnotation(Monitor.class); final ClassFinder finder = new ClassFinder(componentClass); for (final Method method : finder.findAnnotatedMethods(Monitor.class)) { map.put(method, new Stats(method, monitor)); } enabled = monitor != null || map.size() > 0; }
public StatsInterceptor(final Class<?> componentClass) { monitor = componentClass.getAnnotation(Monitor.class); final ClassFinder finder = new ClassFinder(componentClass); for (final Method method : finder.findAnnotatedMethods(Monitor.class)) { map.put(method, new Stats(method, monitor)); } enabled = monitor != null || map.size() > 0; }
private List<Method> retrieveAroundInvokes(final Class<?> interceptorClass) { final List<Method> cached = this.interceptorCache.get(interceptorClass); if (cached != null) { return cached; } final ClassFinder finder = new ClassFinder(interceptorClass); List<Method> annotated = finder.findAnnotatedMethods(AroundInvoke.class); if (StatelessContainer.class.getClassLoader() == interceptorClass.getClassLoader()) { // use cache only for server classes final List<Method> value = new CopyOnWriteArrayList<Method>(annotated); annotated = this.interceptorCache.putIfAbsent(interceptorClass, annotated); // ensure it to be thread safe if (annotated == null) { annotated = value; } } return annotated; } }
private void checkSessionSynchronization(final Class ejbClass, final SessionBean bean) { if (SessionSynchronization.class.isAssignableFrom(ejbClass)) { if (bean.getAfterBeginMethod() != null || bean.getBeforeCompletionMethod() != null || bean.getAfterCompletionMethod() != null) { fail(bean, "callback.sessionSynchronization.invalidUse", ejbClass.getName()); } else { final ClassFinder classFinder = new ClassFinder(ejbClass); if (classFinder.findAnnotatedMethods(AfterBegin.class).size() > 0 || classFinder.findAnnotatedMethods(BeforeCompletion.class).size() > 0 || classFinder.findAnnotatedMethods(AfterCompletion.class).size() > 0) { fail(bean, "callback.sessionSynchronization.invalidUse", ejbClass.getName()); } } } }
private void checkSessionSynchronization(final Class ejbClass, final SessionBean bean) { if (SessionSynchronization.class.isAssignableFrom(ejbClass)) { if (bean.getAfterBeginMethod() != null || bean.getBeforeCompletionMethod() != null || bean.getAfterCompletionMethod() != null) { fail(bean, "callback.sessionSynchronization.invalidUse", ejbClass.getName()); } else { final ClassFinder classFinder = new ClassFinder(ejbClass); if (classFinder.findAnnotatedMethods(AfterBegin.class).size() > 0 || classFinder.findAnnotatedMethods(BeforeCompletion.class).size() > 0 || classFinder.findAnnotatedMethods(AfterCompletion.class).size() > 0) { fail(bean, "callback.sessionSynchronization.invalidUse", ejbClass.getName()); } } } }
private void doInvoke(final String container, final Object instance, final Class<? extends Annotation> marker) { executeInContainer(container, () -> { final Class<?> instanceClass = instance.getClass(); new ClassFinder(instanceClass.getName().contains("$$") ? instanceClass.getSuperclass() : instanceClass) .findAnnotatedMethods(marker) .stream() // we don't limit to one for now .filter(m -> Modifier.isPublic(m.getModifiers())) .forEach(m -> { try { m.invoke(instance); } catch (final IllegalAccessException e) { throw new IllegalStateException(e); } catch (final InvocationTargetException e) { throw toRuntimeException(e); } }); return null; }); } }
public static void addWebServiceContextInjections(Holder holder, ClassFinder finder) { List<Field> fields = finder.findAnnotatedFields(Resource.class); for (Field field : fields) { Resource resource = field.getAnnotation(Resource.class); Class type = getInjectionType(resource.type(), null, field); if (WebServiceContext.class == type) { holder.addInjection(field.getDeclaringClass().getName(), new Injection(field.getDeclaringClass().getName(), getInjectionName(null, field), BINDING_WEBSERVICE_CONTEXR_JNDI_NAME, ReferenceType.RESOURCE_ENV)); } } List<Method> methods = finder.findAnnotatedMethods(Resource.class); for (Method method : methods) { Resource resource = method.getAnnotation(Resource.class); Class type = getInjectionType(resource.type(), method, null); if (WebServiceContext.class == type) { holder.addInjection(method.getDeclaringClass().getName(), new Injection(method.getDeclaringClass().getName(), getInjectionName(method, null), BINDING_WEBSERVICE_CONTEXR_JNDI_NAME, ReferenceType.RESOURCE_ENV)); } } }
private void scan(final Object target, final String prefix) { final ClassFinder finder = new ClassFinder(Classes.ancestors(target.getClass())); final List<Field> fields = finder.findAnnotatedFields(Managed.class); for (final Field field : fields) { attribute(new FieldMember(field, target, prefix)); } final List<Method> managed = finder.findAnnotatedMethods(Managed.class); for (final Method method : managed) { final MethodMember member = new MethodMember(method, target, prefix); if (!method.getName().matches("(get|is)([A-Z_].*|)")) { operationsMap.put(member.getName(), member); } else { attribute(new MethodMember(method, target, prefix)); } } final List<Method> collections = finder.findAnnotatedMethods(ManagedCollection.class); for (final Method method : collections) { dynamic.add(new MethodMember(method, target, prefix)); } }
private void scan(final Object target, final String prefix) { final ClassFinder finder = new ClassFinder(Classes.ancestors(target.getClass())); final List<Field> fields = finder.findAnnotatedFields(Managed.class); for (final Field field : fields) { attribute(new FieldMember(field, target, prefix)); } final List<Method> managed = finder.findAnnotatedMethods(Managed.class); for (final Method method : managed) { final MethodMember member = new MethodMember(method, target, prefix); if (!method.getName().matches("(get|is)([A-Z_].*|)")) { operationsMap.put(member.getName(), member); } else { attribute(new MethodMember(method, target, prefix)); } } final List<Method> collections = finder.findAnnotatedMethods(ManagedCollection.class); for (final Method method : collections) { dynamic.add(new MethodMember(method, target, prefix)); } }
private <A extends Annotation> void checkAttributes(AnnotationHandler<A> handler, String ejbName, EjbModule ejbModule, ClassFinder classFinder, String messageKey) { Map<String, List<MethodAttribute>> existingDeclarations = handler.getExistingDeclarations(); int xml = 0; for (List<MethodAttribute> methodAttributes : existingDeclarations.values()) { xml += methodAttributes.size(); } if (xml > 0) { ejbModule.getValidation().warn(ejbName, "xml." + messageKey, xml); } int ann = classFinder.findAnnotatedClasses(handler.getAnnotationClass()).size(); ann += classFinder.findAnnotatedMethods(handler.getAnnotationClass()).size(); if (ann > 0) { ejbModule.getValidation().warn(ejbName, "ann." + messageKey, ann); } }
private void checkInterface(RemoteBean b, Class<?> beanClass, String tag, String className) { Class<?> interfce = lookForClass(className, tag, b.getEjbName()); if (interfce == null) return; check_hasDependentClasses(b, className, tag); tag = Strings.lcfirst(Strings.camelCase(tag)); if (isValidInterface(b, interfce, beanClass, tag)); ClassFinder finder = new ClassFinder(interfce); for (Class<? extends Annotation> annotation : beanOnlyAnnotations) { if (interfce.isAnnotationPresent(annotation)){ warn(b, "interface.beanOnlyAnnotation", annotation.getSimpleName(), interfce.getName(), b.getEjbClass()); } for (Method method : finder.findAnnotatedMethods(annotation)) { warn(b, "interfaceMethod.beanOnlyAnnotation", annotation.getSimpleName(), interfce.getName(), method.getName(), b.getEjbClass()); } } }
private void checkInterface(final RemoteBean b, final Class<?> beanClass, String tag, final String className) { final Class<?> interfce = lookForClass(className, tag, b.getEjbName()); if (interfce == null) { return; } check_hasDependentClasses(b, className, tag); tag = Strings.lcfirst(Strings.camelCase(tag)); isValidInterface(b, interfce, beanClass, tag); final ClassFinder finder = new ClassFinder(interfce); for (final Class<? extends Annotation> annotation : beanOnlyAnnotations) { if (interfce.isAnnotationPresent(annotation)) { warn(b, "interface.beanOnlyAnnotation", annotation.getSimpleName(), interfce.getName(), b.getEjbClass()); } for (final Method method : finder.findAnnotatedMethods(annotation)) { warn(b, "interfaceMethod.beanOnlyAnnotation", annotation.getSimpleName(), interfce.getName(), method.getName(), b.getEjbClass()); } } }
private void checkInterface(final ClassLoader loader, final RemoteBean b, final Class<?> beanClass, String tag, final String className) { final Class<?> interfce = lookForClass(loader, className, tag, b.getEjbName()); if (interfce == null) { return; } check_hasDependentClasses(b, className, tag); tag = Strings.lcfirst(Strings.camelCase(tag)); isValidInterface(b, interfce, beanClass, tag); final ClassFinder finder = new ClassFinder(interfce); for (final Class<? extends Annotation> annotation : beanOnlyAnnotations) { if (interfce.isAnnotationPresent(annotation)) { warn(b, "interface.beanOnlyAnnotation", annotation.getSimpleName(), interfce.getName(), b.getEjbClass()); } for (final Method method : finder.findAnnotatedMethods(annotation)) { warn(b, "interfaceMethod.beanOnlyAnnotation", annotation.getSimpleName(), interfce.getName(), method.getName(), b.getEjbClass()); } } }
private void scan(Object managed, String prefix) { ClassFinder finder = new ClassFinder(managed.getClass()); List<Field> fields = finder.findAnnotatedFields(Managed.class); for (Field field : fields) { scan(new FieldMember(field, managed, prefix)); } List<Method> methods = finder.findAnnotatedMethods(Managed.class); for (Method method : methods) { scan(new MethodMember(method, managed, prefix)); } }