/** * Create component descriptors for the passed component implementation class and component role * class. There can be more than one descriptor if the component class has specified several * hints. * * @param componentClass the component implementation class * @param componentRoleClass the component role class * @return the component descriptors with resolved component dependencies */ public List<ComponentDescriptor> createComponentDescriptors( Class<?> componentClass, Class<?> componentRoleClass) { List<ComponentDescriptor> descriptors = new ArrayList<ComponentDescriptor>(); // If there's a @Named annotation, use it and ignore hints specified in the @Component // annotation. String[] hints; Named named = componentClass.getAnnotation(Named.class); if (named != null) { hints = new String[] {named.value()}; } else { // If the Component annotation has several hints specified ignore the default hint value and // for each // specified hint create a Component Descriptor Component component = componentClass.getAnnotation(Component.class); if (component != null && component.hints().length > 0) { hints = component.hints(); } else { if (component != null && component.value().trim().length() > 0) { hints = new String[] {component.value().trim()}; } else { hints = new String[] {"default"}; } } } // Create the descriptors for (String hint : hints) { descriptors.add(createComponentDescriptor(componentClass, hint, componentRoleClass)); } return descriptors; }
/** * If there are more more than 1 implementation Guice will complain, this is intentional because * we want an interface to have only 1 implementation * * @param holder */ private void bindInterfaceToImplementation(InterfaceAndImplementations holder) { // todo refactor this, maybe have two different streams in configure, one for named and one for // unnamed.. holder .getTheImplementations() .forEach( impl -> { final Annotation annotation = impl.getAnnotation(Named.class); if (annotation == null) { logger.debug( "binding {} to {}", holder.getTheInterface().getSimpleName(), impl.getSimpleName()); bind(holder.getTheInterface()).to(impl); return; } final Named namedAnnotation = (Named) annotation; final String name = namedAnnotation.value(); logger.debug( "binding {} named {} to {}", holder.getTheInterface().getSimpleName(), name, impl.getSimpleName()); bind(holder.getTheInterface()).annotatedWith(Names.named(name)).to(impl); }); }
/** * @param field * @return bean name */ private String getBeanName(final Field field) { SpringBean annot = field.getAnnotation(SpringBean.class); String name; boolean required; if (annot != null) { name = annot.name(); required = annot.required(); } else { Named named = field.getAnnotation(Named.class); name = named != null ? named.value() : ""; required = false; } if (Strings.isEmpty(name)) { name = beanNameCache.get(field.getType()); if (name == null) { name = getBeanNameOfClass(contextLocator.getSpringContext(), field.getType(), required); if (name != null) { beanNameCache.put(field.getType(), name); } } } return name; }
private String getKey(IObjectDescriptor descriptor) { if (descriptor.hasQualifier(Named.class)) { Named namedAnnotation = descriptor.getQualifier(Named.class); return namedAnnotation.value(); } Type elementType = descriptor.getDesiredType(); return typeToString(elementType); }
public boolean equals(Object o) { if (!(o instanceof Named)) { return false; } Named other = (Named) o; return value.equals(other.value()); }
@Nonnull public static String nameFor(@Nonnull Object instance, @Nonnull String suffix) { Named annotation = instance.getClass().getAnnotation(Named.class); if (annotation != null && !isBlank(annotation.value())) { return annotation.value(); } else { return getLogicalPropertyName(instance.getClass().getName(), suffix); } }
public void testJsrNamed() { final Named guiceNamed = Names.named("TEST"); final Injector injector = Guice.createInjector( new AbstractModule() { @Override protected void configure() { bindConstant().annotatedWith(guiceNamed).to("CONSTANT"); } }); @SuppressWarnings({"unchecked", "rawtypes"}) final LazyBeanEntry<javax.inject.Named, String> entry = new LazyBeanEntry(guiceNamed, injector.getBinding(Key.get(String.class, guiceNamed)), 0); final javax.inject.Named jsrNamed = entry.getKey(); assertTrue(jsrNamed.equals(jsrNamed)); assertTrue(jsrNamed.equals(entry.getKey())); assertTrue(jsrNamed.equals(T.class.getAnnotation(javax.inject.Named.class))); assertTrue(jsrNamed.equals(guiceNamed)); assertFalse(jsrNamed.equals(Names.named(""))); assertFalse(jsrNamed.equals("TEST")); assertEquals(javax.inject.Named.class, jsrNamed.annotationType()); assertEquals(T.class.getAnnotation(javax.inject.Named.class).hashCode(), jsrNamed.hashCode()); }
/** * Get the name of the bean for the given object. * * @param instance the object. * @return the name. */ private String getName(Object instance) { String name = instance.getClass().getSimpleName().substring(0, 1).toLowerCase() + instance.getClass().getSimpleName().substring(1); Named named = instance.getClass().getAnnotation(Named.class); if (named != null && named.value() != null && !named.value().trim().equals("")) { name = named.value(); } return name; }
private CallbackEntry(Class<?> beanClass, Class<? extends Annotation> callbackMarker) { this.targetBeanClass = beanClass; Named named = this.targetBeanClass.getAnnotation(Named.class); if (named != null && !"".equals(named.value())) { this.beanName = named.value(); } else { // fallback to the default (which might exist) -> TODO check meta-data of Bean<T> this.beanName = Introspector.decapitalize(targetBeanClass.getSimpleName()); } List<String> processedMethodNames = new ArrayList<String>(); findMethodWithCallbackMarker(callbackMarker, beanClass, processedMethodNames); }
public <I> void hear(TypeLiteral<I> injectableType, TypeEncounter<I> encounter) { Class<? super I> type = injectableType.getRawType(); Set<Field> loggerFields = getLoggerFieldsAnnotatedWithResource(type); if (loggerFields.size() == 0) return; Logger logger = loggerFactory.getLogger(type.getName()); for (Field field : loggerFields) { if (field.isAnnotationPresent(Named.class)) { Named name = field.getAnnotation(Named.class); encounter.register( new AssignLoggerToField<I>(loggerFactory.getLogger(name.value()), field)); } else { encounter.register(new AssignLoggerToField<I>(logger, field)); } } }
private void bindQueryNamedParameters( Query jpaQuery, JpaFinderProxy.FinderDescriptor descriptor, Object[] arguments) { for (int i = 0; i < arguments.length; i++) { Object argument = arguments[i]; Object annotation = descriptor.parameterAnnotations[i]; if (null == annotation) //noinspection UnnecessaryContinue { continue; // skip param as it's not bindable } else if (annotation instanceof Named) { Named named = (Named) annotation; jpaQuery.setParameter(named.value(), argument); } else if (annotation instanceof javax.inject.Named) { javax.inject.Named named = (javax.inject.Named) annotation; jpaQuery.setParameter(named.value(), argument); } else if (annotation instanceof FirstResult) { jpaQuery.setFirstResult((Integer) argument); } else if (annotation instanceof MaxResults) { jpaQuery.setMaxResults((Integer) argument); } } }
@Nonnull protected List<Annotation> harvestQualifiers(@Nonnull Field field) { List<Annotation> list = new ArrayList<>(); Annotation[] annotations = field.getAnnotations(); for (Annotation annotation : annotations) { if (AnnotationUtils.isAnnotatedWith(annotation, Qualifier.class)) { if (BindTo.class.isAssignableFrom(annotation.getClass())) { continue; } // special case for @Named if (Named.class.isAssignableFrom(annotation.getClass())) { Named named = (Named) annotation; if (isBlank(named.value())) { list.add(named(getPropertyName(field.getName()))); continue; } } list.add(annotation); } } return list; }
@Nonnull public static List<Annotation> harvestQualifiers(@Nonnull Class<?> klass) { requireNonNull(klass, "Argument 'class' must not be null"); List<Annotation> list = new ArrayList<>(); Annotation[] annotations = klass.getAnnotations(); for (Annotation annotation : annotations) { if (AnnotationUtils.isAnnotatedWith(annotation, Qualifier.class)) { // special case @BindTo is only used during tests if (BindTo.class.isAssignableFrom(annotation.getClass())) { continue; } // special case for @Named if (Named.class.isAssignableFrom(annotation.getClass())) { Named named = (Named) annotation; if (isBlank(named.value())) { list.add(named(getPropertyName(klass))); continue; } } list.add(annotation); } } return list; }
private void grabAnnotations( TreeLogger logger, ModelMagic models, HasModelFields fields, JMethod method, Annotation[] annos, JClassType type) { GetterFor getter = method.getAnnotation(GetterFor.class); ClientToServer c2s = method.getAnnotation(ClientToServer.class); ServerToClient s2c = method.getAnnotation(ServerToClient.class); Persistent persist = method.getAnnotation(Persistent.class); Serializable serial = method.getAnnotation(Serializable.class); Named name = method.getAnnotation(Named.class); for (Annotation annotation : annos) { if (getter == null && annotation.annotationType() == GetterFor.class) getter = (GetterFor) annotation; else if (serial == null && annotation.annotationType() == Serializable.class) serial = (Serializable) annotation; else if (persist == null && annotation.annotationType() == Persistent.class) persist = (Persistent) annotation; else if (c2s == null && annotation.annotationType() == ClientToServer.class) c2s = (ClientToServer) annotation; else if (s2c == null && annotation.annotationType() == ServerToClient.class) s2c = (ServerToClient) annotation; else if (name == null && annotation.annotationType() == Named.class) name = (Named) annotation; } String fieldName; if (name == null) { fieldName = ModelGeneratorGwt.fieldName(method, models); } else { fieldName = name.value(); if (X_Runtime.isDebug()) { logger.log( Type.TRACE, "Named method " + method.getJsniSignature() + " " + fieldName + ", from @Named attribute. Heuristic name: " + ModelGeneratorGwt.fieldName(method, models)); } } if ("".equals(fieldName)) fieldName = method.getName(); ModelField field = fields.getOrMakeField(fieldName); if (field.getPersistent() == null) { field.setPersistent(persist); } else { assert persist == null || (persist.patchable() == field.getPersistent().patchable()) : "Model annotation mismatch! Field " + field.getName() + " of type " + type.getQualifiedSourceName() + " contained multiple @Persistent annotations which did not match. " + "You may have to override an annotated supertype method with the correct " + "@Persistent annotation."; } if (field.getSerializable() == null) { field.setSerializable(serial); } else { // assert serial == null || // ( // this block is all assert, so it will compile out of production. // serial.clientToServer() == field.getSerializable().clientToServer() && // serial.serverToClient() == field.getSerializable().serverToClient() && // serial.obfuscated() == field.getSerializable().obfuscated() // ) : "Model annotation mismatch! Field "+field.getName()+" contained " + // "multiple @Serializable annotations which did not match. You may " + // "have to override an annotated supertype method with the correct " + // "@Serializable annotation."; } if (field.getServerToClient() == null) { field.setServerToClient(s2c); } else { assert s2c == null || s2c.enabled() == field.getServerToClient().enabled() : "Model annotation mismatch! Field " + field.getName() + " was marked as " + "both " + "serverToClient" + " enabled and disabled. Please correct this ambiguity;" + " your model is now undeterministic and may break unexpectedly."; } if (field.getClientToServer() == null) { field.setClientToServer(c2s); } else { assert c2s == null || c2s.enabled() == field.getClientToServer().enabled() : "Model annotation mismatch! Field " + field.getName() + " was marked as " + "both " + "clientToServer" + " enabled and disabled. Please correct this ambiguity;" + " your model is now undeterministic and may break unexpectedly."; } }
@Override public final InjectorImpl getInjector(Stage stage) { Binder binder = new AnnotationBinder(); Collection<Class<?>> components = new ArrayList<Class<?>>(); components.addAll(DSAnnotatedLoader.loadManagedBeans(packagePrefix)); components.addAll(DSAnnotatedLoader.loadSingletons(packagePrefix)); components.addAll(DSAnnotatedLoader.loadNamed(packagePrefix)); for (Class<?> clazz : components) { String name = null; Named named = clazz.getAnnotation(Named.class); if (named != null) { name = named.value(); } ProvidedBy providedBy = clazz.getAnnotation(ProvidedBy.class); Provider provider = null; try { if (providedBy != null) { provider = (Provider) providedBy.value().newInstance(); } } catch (Exception ex) { logger.log(Level.SEVERE, null, ex); } OnStage onStage = clazz.getAnnotation(OnStage.class); Stage stag = null; if (onStage != null) { stag = onStage.value(); } Annotation[] annotations = clazz.getAnnotations(); Class<? extends Annotation> qualifier = null; boolean qualifierPresent = false; for (Annotation anno : annotations) { if ((anno.annotationType().isAnnotationPresent(Qualifier.class)) && !(anno instanceof Named)) { if (qualifierPresent) { logger.log( Level.WARNING, new StringBuilder() .append("Class ") .append(clazz.getSimpleName()) .append(" has more than one qualifier.\n") .append("Qualifier @") .append(anno.annotationType().getSimpleName()) .append(" will override @") .append(qualifier.getSimpleName()) .append(".") .toString()); } else { qualifierPresent = true; } qualifier = anno.annotationType(); } } Class<?>[] superInterfaces = clazz.getSuperclass().getInterfaces(); Class<?> superType = clazz.getSuperclass(); Class<?>[] typeInterfaces = clazz.getInterfaces(); if (typeInterfaces.length > 0) { for (Class interf : typeInterfaces) { Binding binding = new Binding(qualifier, name, interf, clazz, provider, stag); binder.getBindings().put(binding, binding); } } else if (superInterfaces.length > 0) { Class superClass = superType; while (superInterfaces.length > 0) { for (Class interf : superInterfaces) { Binding binding = new Binding(qualifier, name, interf, clazz, provider, stag); binder.getBindings().put(binding, binding); } superClass = superClass.getSuperclass(); superInterfaces = superClass.getInterfaces(); } } else { while (superType != null) { if (!superType.equals(Object.class)) { Binding binding = new Binding(qualifier, name, superType, clazz, provider, stag); binder.getBindings().put(binding, binding); superType = superType.getSuperclass(); } else { superType = null; } } Binding binding = new Binding(qualifier, name, clazz, clazz, provider, stag); binder.getBindings().put(binding, binding); } } if (showBindings) { for (Binding b : binder.getBindings().values()) { System.out.println(b); } } return InjectorBuilder.makeInjector(binder, new PluginsLoader(), stage); }