private void recordAnnotatedGaugeSite(@Observes @WithAnnotations(Gauge.class) ProcessAnnotatedType<?> pat) { LOGGER.log(Level.FINE, () -> "### recordAnnoatedGaugeSite for class " + pat.getAnnotatedType().getJavaClass()); AnnotatedType<?> type = pat.getAnnotatedType(); LOGGER.log(Level.FINE, () -> "### Processing annotations for " + type.getJavaClass().getName()); // Register metrics based on annotations AnnotatedTypeConfigurator<?> configurator = pat.configureAnnotatedType(); Class<?> clazz = configurator.getAnnotated().getJavaClass(); // If abstract class, then handled by concrete subclasses if (Modifier.isAbstract(clazz.getModifiers())) { return; } // Process @Gauge methods keeping non-private declared on this class configurator.filterMethods(method -> method.getJavaMember().getDeclaringClass().equals(clazz) && !Modifier.isPrivate(method.getJavaMember().getModifiers()) && method.isAnnotationPresent(Gauge.class)) .forEach(method -> { Method javaMethod = method.getAnnotated().getJavaMember(); String explicitGaugeName = method.getAnnotated().getAnnotation(Gauge.class).name(); String gaugeName = String.format("%s.%s", clazz.getName(), explicitGaugeName != null && explicitGaugeName.length() > 0 ? explicitGaugeName : javaMethod.getName()); annotatedGaugeSites.put(gaugeName, method); LOGGER.log(Level.FINE, () -> String.format("### Recorded annotated gauge with name %s", gaugeName)); }); }
AnnotatedTypeConfigurator<?> configurator = pat.configureAnnotatedType(); Class<?> clazz = configurator.getAnnotated().getJavaClass();
void execute() { event.configureAnnotatedType(); } }.run();
void observesFooPAT(@Observes ProcessAnnotatedType<Foo> event) { AnnotatedTypeConfigurator<Foo> annotatedTypeConfigurator = event.configureAnnotatedType(); annotatedTypeConfigurator.remove(p -> p.annotationType().equals(RequestScoped.class)); sameATConfiguratorReturned.set(annotatedTypeConfigurator.equals(event.configureAnnotatedType())); }
public void processAnnotatedType(@Observes ProcessAnnotatedType<Bravo> event){ event.configureAnnotatedType().add(ProcessedByExtension.ProcessedByExtensionLiteral.INSTANCE); }
public void processAnnotatedType(@Observes ProcessAnnotatedType<Alpha> event){ event.configureAnnotatedType().add(ProcessedByExtension.ProcessedByExtensionLiteral.INSTANCE); }
void observesDogProducerPAT(@Observes ProcessAnnotatedType<DogProducer> event) { // remove all @Produces from DogProducer AnnotatedTypeConfigurator<DogProducer> annotatedTypeConfigurator = event.configureAnnotatedType(); annotatedTypeConfigurator.methods().stream().forEach(am -> am.remove(a -> a.annotationType().equals(Produces.class))); annotatedTypeConfigurator.fields().stream().forEach(am -> am.remove(a -> a.annotationType().equals(Produces.class))); }
void processAnnotatedType(@Observes ProcessAnnotatedType<DefaultHystrixConcurrencyStrategy> event) { event.configureAnnotatedType() .filterFields(field -> "managedThreadFactory".equals(field.getJavaMember().getName())) .forEach(field -> { field.remove(annotation -> Resource.class.equals(annotation.annotationType())); field.add(ResourceLiteral.lookup("java:jboss/ee/concurrency/factory/default")); }); }
void observesCountrysidePAT(@Observes ProcessAnnotatedType<Countryside> event) { AnnotatedConstructorConfigurator<Countryside> annotatedConstructorConfigurator = event.configureAnnotatedType() .filterConstructors(constructor -> constructor.isAnnotationPresent(Inject.class)).findFirst().get(); //add qualifier to each constructor param annotatedConstructorConfigurator.params().forEach(annotatedParam -> annotatedParam.add(Wild.WildLiteral.INSTANCE)); }
void observesDogPAT(@Observes ProcessAnnotatedType<Dog> event) { annotatedTypesEqual.set(AnnotatedTypes.compareAnnotatedTypes(event.configureAnnotatedType().getAnnotated(), event.getAnnotatedType())); AnnotatedTypeConfigurator<Dog> annotatedTypeConfigurator = event.configureAnnotatedType(); // add @RequestScoped to Dog and @Inject and @Dogs to its Feed field annotatedTypeConfigurator.add(RequestScoped.Literal.INSTANCE) .filterFields(af -> (af.getJavaMember() .getName().equals("feed"))).findFirst().get().add(InjectLiteral.INSTANCE).add(Dogs.DogsLiteral.INSTANCE); // add @Inject to Dog constructor and @Dogs to its param annotatedTypeConfigurator.constructors().iterator().next().add(InjectLiteral.INSTANCE) .filterParams(ap -> ap.getPosition() == 0).findFirst().get().add(Dogs.DogsLiteral.INSTANCE); }
void observePATReverse(@Observes ProcessAnnotatedType<Box> event) { event.setAnnotatedType(new TestAnnotatedType<>(event.getAnnotatedType())); try { event.configureAnnotatedType().add(Sorted.SortedLiteral.INSTANCE); } catch (IllegalStateException e) { // expected should blow up with ISE PAT_REVERSE_ISE_CAUGHT = true; } }
private void recordAnnotatedGaugeSite(@Observes @WithAnnotations(Gauge.class) ProcessAnnotatedType<?> pat) { LOGGER.log(Level.FINE, () -> "### recordAnnoatedGaugeSite for class " + pat.getAnnotatedType().getJavaClass()); AnnotatedType<?> type = pat.getAnnotatedType(); LOGGER.log(Level.FINE, () -> "### Processing annotations for " + type.getJavaClass().getName()); // Register metrics based on annotations AnnotatedTypeConfigurator<?> configurator = pat.configureAnnotatedType(); Class<?> clazz = configurator.getAnnotated().getJavaClass(); // If abstract class, then handled by concrete subclasses if (Modifier.isAbstract(clazz.getModifiers())) { return; } // Process @Gauge methods keeping non-private declared on this class configurator.filterMethods(method -> method.getJavaMember().getDeclaringClass().equals(clazz) && !Modifier.isPrivate(method.getJavaMember().getModifiers()) && method.isAnnotationPresent(Gauge.class)) .forEach(method -> { Method javaMethod = method.getAnnotated().getJavaMember(); String explicitGaugeName = method.getAnnotated().getAnnotation(Gauge.class).name(); String gaugeName = String.format("%s.%s", clazz.getName(), explicitGaugeName != null && explicitGaugeName.length() > 0 ? explicitGaugeName : javaMethod.getName()); annotatedGaugeSites.put(gaugeName, method); LOGGER.log(Level.FINE, () -> String.format("### Recorded annotated gauge with name %s", gaugeName)); }); }
void observePAT(@Observes ProcessAnnotatedType<Box> event) { event.configureAnnotatedType().add(Sorted.SortedLiteral.INSTANCE); try { event.setAnnotatedType(new TestAnnotatedType<>(event.getAnnotatedType())); } catch (IllegalStateException e) { // expected should blow up with ISE PAT_ISE_CAUGHT = true; } }
void observesDogDependenciesProducerPAT(@Observes ProcessAnnotatedType<DogDependenciesProducer> event) { AnnotatedTypeConfigurator<DogDependenciesProducer> annotatedTypeConfigurator = event.configureAnnotatedType(); // add @Produces and @Created to DogDependenciesProducer.produceFeed getAMConfiguratorByName(annotatedTypeConfigurator, "produceFeed").add(ProducesLiteral.INSTANCE) .add(Dogs.DogsLiteral.INSTANCE); // add @Produces and @Created to DogDependenciesProducer.dogName annotatedTypeConfigurator.filterFields(af -> af.getJavaMember().getName().equals("dogName")).findFirst().get().add(ProducesLiteral.INSTANCE) .add(Dogs.DogsLiteral.INSTANCE); // add @Disposes to DogDependenciesProducer.disposeFeed getAMConfiguratorByName(annotatedTypeConfigurator, "disposeFeed") .filterParams(ap -> ap.getPosition() == 0).findFirst().get().add(DisposesLiteral.INSTANCE).add(Dogs.DogsLiteral.INSTANCE); }
void registerLoggedIn(@Observes @WithAnnotations(LoggedIn.class) ProcessAnnotatedType<?> pat) { if (pat.getAnnotatedType().isAnnotationPresent(LoggedIn.class)) { pat.configureAnnotatedType().methods().forEach(amc -> { amc.add(LoggedIn.INSTANCE); amc.add(Secured.INSTANCE); }); } else { pat.configureAnnotatedType() .filterMethods(m -> m.isAnnotationPresent(LoggedIn.class)) .forEach(amc -> { amc.add(Secured.INSTANCE); }); } }
void observesAnimalShelterPAT(@Observes ProcessAnnotatedType<AnimalShelter> event) { AnnotatedTypeConfigurator<AnimalShelter> annotatedTypeConfigurator = event.configureAnnotatedType();
void registerHasAllRoles(@Observes @WithAnnotations(HasAllRoles.class) ProcessAnnotatedType<?> pat) { if (pat.getAnnotatedType().isAnnotationPresent(HasAllRoles.class)) { HasAllRoles hasAllRoles = pat.getAnnotatedType().getAnnotation(HasAllRoles.class); pat.configureAnnotatedType().methods().forEach(amc -> { amc.add(hasAllRoles); amc.add(Secured.INSTANCE); }); } else { pat.configureAnnotatedType() .filterMethods(m -> m.isAnnotationPresent(HasAllRoles.class)) .forEach(amc -> { amc.add(Secured.INSTANCE); }); } }
void registerRolesAllowed(@Observes @WithAnnotations(RolesAllowed.class) ProcessAnnotatedType<?> pat) { if (pat.getAnnotatedType().isAnnotationPresent(RolesAllowed.class)) { RolesAllowed roles = pat.getAnnotatedType().getAnnotation(RolesAllowed.class); pat.configureAnnotatedType().methods().forEach(amc -> { amc.add(roles); amc.add(Secured.INSTANCE); }); } else { pat.configureAnnotatedType() .filterMethods(m -> m.isAnnotationPresent(RolesAllowed.class)) .forEach(amc -> { amc.add(Secured.INSTANCE); }); } } }
void observesCatPAT(@Observes ProcessAnnotatedType<Cat> event) { AnnotatedTypeConfigurator<Cat> annotatedTypeConfigurator = event.configureAnnotatedType(); originalCatAT = annotatedTypeConfigurator.getAnnotated(); // remove @RequestScoped from Cat annotatedTypeConfigurator.remove(a -> a.annotationType().equals(RequestScoped.class)); // remove @Produces and @Cats Cat.produceCatName() getAMConfiguratorByName(annotatedTypeConfigurator, "produceCatFeed").remove(a -> a.equals(ProducesLiteral.INSTANCE)) .remove(a -> a.equals(Cats.CatsLiteral.INSTANCE)); // remove @Inject from Cat.feed annotatedTypeConfigurator.filterFields(af -> af.getJavaMember().getName().equals("feed")).findFirst().get() .remove(a -> a.equals(InjectLiteral.INSTANCE)); // remove @Inject and @Cats from constructor with parameter annotatedTypeConfigurator.filterConstructors(ac -> ac.getParameters().size() == 1 && ac.getParameters().get(0).getBaseType().equals(Feed.class)) .findFirst().get().remove(a -> a.equals(InjectLiteral.INSTANCE)).params().get(0).remove(a -> a.equals(Cats.CatsLiteral.INSTANCE)); // remove @Observes from Cat.observesCatsFeed method parameter getAMConfiguratorByName(annotatedTypeConfigurator, "observesCatsFeed") .filterParams(ap -> ap.getPosition() == 0).findFirst().get().remove(a -> a.annotationType().equals(Observes.class)); }
event.configureAnnotatedType().methods().forEach(m -> { Id id = routes.get(m.getAnnotated().getJavaMember().toGenericString()); if (id != null) {