/** * Returns <code>true</code> if bean name is registered. */ public boolean isBeanNameRegistered(final String name) { return lookupBeanDefinition(name) != null; }
/** * Registers a bean using provided class that is annotated. */ public <T> BeanDefinition<T> registerPetiteBean(final Class<T> type, final Consumer<T> consumer) { return registerPetiteBean(type, null, null, null, false, consumer); }
/** * Resolves and registers scope from a scope type. */ @SuppressWarnings("unchecked") public <S extends Scope> S resolveScope(final Class<S> scopeType) { S scope = (S) scopes.get(scopeType); if (scope == null) { try { scope = newInternalInstance(scopeType, (PetiteContainer) this); } catch (Exception ex) { throw new PetiteException("Invalid Petite scope: " + scopeType.getName(), ex); } registerScope(scopeType, scope); scopes.put(scopeType, scope); } return scope; }
/** * Iterates all beans. Iteration occurs over the {@link #beanNames() snapshot of bean names}. */ public void forEachBean(final Consumer<BeanDefinition> beanDefinitionConsumer) { final Set<String> names = beanNames(); for (String beanName : names) { BeanDefinition beanDefinition = lookupBeanDefinition(beanName); if (beanDefinition != null) { beanDefinitionConsumer.accept(beanDefinition); } } }
name = resolveBeanName(type); BeanDefinition existing = removeBean(name); if (existing != null) { if (petiteConfig.getDetectDuplicatedBeanNames()) { Scope scope = resolveScope(scopeType); BeanDefinition<T> beanDefinition = createBeanDefinitionForRegistration(name, type, scope, wiringMode, consumer); registerBean(name, beanDefinition);
/** * Registers set injection point. * * @param beanName bean name * @param property set property name */ public void registerPetiteSetInjectionPoint(final String beanName, final String property) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); ClassDescriptor cd = ClassIntrospector.get().lookup(beanDefinition.type); PropertyDescriptor propertyDescriptor = cd.getPropertyDescriptor(property, true); if (propertyDescriptor == null) { throw new PetiteException("Property not found: " + beanDefinition.type.getName() + '#' + property); } SetInjectionPoint sip = new SetInjectionPoint(propertyDescriptor); beanDefinition.addSetInjectionPoint(sip); }
/** * Single point of bean definition. */ protected void definePetiteBean(String name, Class type, Class<? extends Scope> scopeType, WiringMode wiringMode) { BeanDefinition def = registerPetiteBean(name, type, scopeType, wiringMode); def.ctor = resolveCtorInjectionPoint(type); def.properties = PropertyInjectionPoint.EMPTY; def.methods = MethodInjectionPoint.EMPTY; def.initMethods = InitMethodPoint.EMPTY; }
/** * Single point of init method registration. */ protected void registerPetiteInitMethods(String beanName, String[] beforeMethodNames, String[] afterMethodNames) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); InitMethodPoint[] methods = defineInitMethods(beanDefinition.type, beforeMethodNames, afterMethodNames); beanDefinition.addInitMethodPoints(methods); }
/** * Single point of property injection point registration. */ protected void registerPetiteSetInjectionPoint(String beanName, String property) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); SetInjectionPoint sip = defineSetInjectionPoint( beanDefinition.type, property); beanDefinition.addSetInjectionPoint(sip); }
/** * Single point of constructor injection point registration. */ protected void registerPetiteCtorInjectionPoint(String beanName, Class[] paramTypes, String[] references) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); String[][] ref = PetiteUtil.convertRefToReferences(references); beanDefinition.ctor = defineCtorInjectionPoint(beanDefinition.type, paramTypes, ref); }
/** * Single point of property injection point registration. */ protected void registerPetitePropertyInjectionPoint(String beanName, String property, String reference) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); PropertyInjectionPoint pip = definePropertyInjectionPoint( beanDefinition.type, property, reference == null ? null : new String[] {reference}); beanDefinition.addPropertyInjectionPoint(pip); }
/** * Single point of method injection point registration. */ protected void registerPetiteMethodInjectionPoint(String beanName, String methodName, Class[] arguments, String[] references) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); String[][] ref = PetiteUtil.convertRefToReferences(references); MethodInjectionPoint mip = defineMethodInjectionPoint(beanDefinition.type, methodName, arguments, ref); beanDefinition.addMethodInjectionPoint(mip); }
scopeType = petiteConfig.getDefaultScope(); BeanDefinition existing = removeBeanDefinition(name); if (existing != null) { if (petiteConfig.getDetectDuplicatedBeanNames()) { Scope scope = resolveScope(scopeType); BeanDefinition beanDefinition = new BeanDefinition(name, type, scope, wiringMode); beans.put(name, beanDefinition);
/** * Resolves scope from scope type. */ protected Scope resolveScope(Class<? extends Scope> scopeType) { Scope scope = scopes.get(scopeType); if (scope == null) { try { scope = scopeType.newInstance(); registerScope(scopeType, scope); scopes.put(scopeType, scope); } catch (Exception ex) { throw new PetiteException("Unable to create Petite scope: '" + scopeType.getName(), ex); } } return scope; }
/** * Defines many parameters at once from {@link jodd.props.Props}. */ public void defineParameters(final Props props) { Map<?, ?> map = new HashMap<>(); props.extractProps(map); defineParameters(map); }
/** * Iterates all beans that are of given type. */ public void forEachBeanType(final Class type, final Consumer<String> beanNameConsumer) { forEachBean(bd -> { if (ClassUtil.isTypeOf(bd.type, type)) { beanNameConsumer.accept(bd.name); } }); }
/** * Defines many parameters at once. */ public void defineParameters(final Map<?, ?> properties) { for (Map.Entry<?, ?> entry : properties.entrySet()) { defineParameter(entry.getKey().toString(), entry.getValue()); } }
name = resolveBeanName(type); BeanDefinition existing = removeBean(name); if (existing != null) { if (petiteConfig.getDetectDuplicatedBeanNames()) { Scope scope = resolveScope(scopeType); BeanDefinition<T> beanDefinition = createBeanDefinitionForRegistration(name, type, scope, wiringMode, consumer); registerBean(name, beanDefinition);
/** * Registers property injection point. * * @param beanName bean name * @param property property name * @param reference explicit injection reference, may be <code>null</code> */ public void registerPetitePropertyInjectionPoint(final String beanName, final String property, final String reference) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); ClassDescriptor cd = ClassIntrospector.get().lookup(beanDefinition.type); PropertyDescriptor propertyDescriptor = cd.getPropertyDescriptor(property, true); if (propertyDescriptor == null) { throw new PetiteException("Property not found: " + beanDefinition.type.getName() + '#' + property); } BeanReferences ref = referencesResolver.resolveReferenceFromValue(propertyDescriptor, reference); PropertyInjectionPoint pip = new PropertyInjectionPoint(propertyDescriptor, ref); beanDefinition.addPropertyInjectionPoint(pip); }
/** * Iterates all beans. Iteration occurs over the {@link #beanNames() snapshot of bean names}. */ public void forEachBean(final Consumer<BeanDefinition> beanDefinitionConsumer) { final Set<String> names = beanNames(); for (String beanName : names) { BeanDefinition beanDefinition = lookupBeanDefinition(beanName); if (beanDefinition != null) { beanDefinitionConsumer.accept(beanDefinition); } } }