/** * Resolves bean's name from bean annotation or type name. May be used for resolving bean name * of base type during registration of bean subclass. */ public String resolveBeanName(final Class type) { return annotationResolver.resolveBeanName(type, petiteConfig.getUseFullTypeNames()); }
/** * Starts with defining injection points (i.e. wiring) for existing bean. */ public BeanWire wire(final String beanName) { petiteContainer.lookupExistingBeanDefinition(beanName); return new BeanWire(beanName); }
/** * Starts registration of init method. */ public BeanInit init(final String beanName) { petiteContainer.lookupExistingBeanDefinition(beanName); return new BeanInit(beanName); }
/** * Wires bean, injects parameters and invokes init methods. * Such a loooong name :) */ protected void registerBeanAndWireAndInjectParamsAndInvokeInitMethods(final BeanData beanData) { initBeanDefinition(beanData.definition()); beanData.scopeRegister(); beanData.invokeInitMethods(InitMethodInvocationStrategy.POST_CONSTRUCT); beanData.wireBean(); beanData.invokeInitMethods(InitMethodInvocationStrategy.POST_DEFINE); beanData.injectParams(paramManager, petiteConfig.isImplicitParamInjection()); beanData.invokeInitMethods(InitMethodInvocationStrategy.POST_INITIALIZE); beanData.invokeConsumerIfRegistered(); }
/** * Adds object instance to the container as singleton bean. */ public void addBean(final String name, final Object bean, WiringMode wiringMode) { wiringMode = petiteConfig.resolveWiringMode(wiringMode); registerPetiteBean(bean.getClass(), name, SingletonScope.class, wiringMode, false, null); BeanDefinition def = lookupExistingBeanDefinition(name); registerBeanAndWireAndInjectParamsAndInvokeInitMethods(new BeanData(this, def, bean)); }
@Test void test243() { PetiteContainer pc = new PetiteContainer(); new PetiteRegistry(pc).provider("provider").type(PetiteDemo.class).method("getOne").args().register(); }
protected PetiteBeans(final PetiteConfig petiteConfig) { this.petiteConfig = petiteConfig; this.referencesResolver = new ReferencesResolver(petiteConfig); this.petiteResolvers = new PetiteResolvers(referencesResolver); this.paramManager = new ParamManager(); this.annotationResolver = new AnnotationResolver(); }
/** * Lookups for existing {@link jodd.petite.BeanDefinition bean definition}. * Throws exception if bean is not found. */ protected BeanDefinition lookupExistingBeanDefinition(final String name) { BeanDefinition beanDefinition = lookupBeanDefinition(name); if (beanDefinition == null) { throw new PetiteException("Bean not found: " + name); } return beanDefinition; }
@Override protected ActionResult createResult(final Class<? extends ActionResult> actionResultClass) { return petiteContainer.createBean(actionResultClass); } }
/** * Creates {@link jodd.petite.BeanDefinition} for all external beans. */ protected <T> BeanDefinition createBeandDefinitionForExternalBeans( final Class<T> type, final WiringMode wiringMode) { final String name = resolveBeanName(type); return new BeanDefinition<>(name, type, null, wiringMode, null); }
/** * Starts registration of destroy method. */ public BeanDestroy destroy(final String beanName) { petiteContainer.lookupExistingBeanDefinition(beanName); return new BeanDestroy(beanName); }
/** * Returns <code>true</code> if bean is destroyable. */ protected boolean isBeanDestroyable(final BeanData beanData) { DestroyMethodPoint[] dmp = beanData.definition().destroyMethodPoints(); return dmp != null && dmp.length != 0; }
/** * Invokes single method injection point on given bean with given bean definition. */ protected void wireMethods() { for (final MethodInjectionPoint methodRef : definition().methods) { invokeMethodInjectionPoint(methodRef); } }
/** * Specifies default wiring mode. */ public PetiteConfig setDefaultWiringMode(final WiringMode defaultWiringMode) { if ((defaultWiringMode == null) || (defaultWiringMode == WiringMode.DEFAULT)) { throw new PetiteException("Invalid default wiring mode: " + defaultWiringMode); } this.defaultWiringMode = defaultWiringMode; return this; } /**
/** * Registers property injection point. */ public void bind() { petiteContainer.registerPetitePropertyInjectionPoint(beanName, propertyName, reference); } }
/** * Registers init methods. */ public void register() { petiteContainer.registerPetiteInitMethods(beanName, strategy, methods); } }
public BeanData(final PetiteContainer petiteContainer, final BeanDefinition<T> beanDefinition) { this.pc = petiteContainer; this.beanDefinition = beanDefinition; this.bean = (T) newBeanInstance(); }
/** * Wires beans constructor. * @see PetiteBeans#registerPetiteCtorInjectionPoint(String, Class[], String[]) */ public BeanWireCtor ctor(final Class... ctorArgumentTypes) { return new BeanWireCtor(ctorArgumentTypes); }
/** * Creates and wires a bean within the container using default wiring mode and default init methods flag. * Bean is <b>not</b> registered. */ public <E> E createBean(final Class<E> type) { return createBean(type, null); }
/** * Defines bean name. */ public BeanProvider bean(final String beanName) { if (type != null) { throw new PetiteException("Petite provider type already defined"); } this.beanName = beanName; return this; }