if (bd1.name().startsWith(prefix)) { if (bd2.name().startsWith(prefix)) { return bd1.name().compareTo(bd2.name()); if (bd2.name().startsWith(prefix)) { if (bd1.name().startsWith(prefix)) { return bd1.name().compareTo(bd2.name()); return bd1.name().compareTo(bd2.name()); }) .forEach(beanDefinition -> { Chalk256.chalk().green(), beanDefinition.name(), Chalk256.chalk().blue(), ClassUtil.getShortClassName(beanDefinition.type(), 2), width - 10 - 1 );
/** * Creates {@link jodd.petite.BeanDefinition} on * {@link #registerPetiteBean(Class, String, Class, WiringMode, boolean, Consumer) bean registration}. * This is a hook for modifying the bean data, like passing proxifed class etc. * By default returns new instance of {@link jodd.petite.BeanDefinition}. */ protected <T> BeanDefinition createBeanDefinitionForRegistration( final String name, final Class<T> type, final Scope scope, final WiringMode wiringMode, final Consumer<T> consumer) { return new BeanDefinition<>(name, type, scope, wiringMode, consumer); }
/** * 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); }
@Override public void register(final BeanDefinition beanDefinition, final Object bean) { instances.put(beanDefinition.name(), new BeanData(pc, beanDefinition, bean)); }
Class type = beanDefinition.type();
bean = def.scopeLookup(); if (bean == null) { injectParams(bean, def); invokeInitMethods(bean, def, Boolean.FALSE); def.scopeRegister(bean);
/** * Registers scope. */ public void scopeRegister() { beanDefinition.scopeRegister(bean); }
/** * Removes bean and returns definition of removed bean. * All resolvers references are deleted, too. * Returns bean definition of removed bean or <code>null</code>. */ public BeanDefinition removeBean(final String name) { BeanDefinition bd = beans.remove(name); if (bd == null) { return null; } bd.scopeRemove(); return bd; }
/** * 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); }
/** * Registers init method. * * @param beanName bean name * @param invocationStrategy moment of invocation * @param initMethodNames init method names */ public void registerPetiteInitMethods(final String beanName, final InitMethodInvocationStrategy invocationStrategy, String... initMethodNames) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); ClassDescriptor cd = ClassIntrospector.get().lookup(beanDefinition.type); if (initMethodNames == null) { initMethodNames = StringPool.EMPTY_ARRAY; } int total = initMethodNames.length; InitMethodPoint[] initMethodPoints = new InitMethodPoint[total]; int i; for (i = 0; i < initMethodNames.length; i++) { MethodDescriptor md = cd.getMethodDescriptor(initMethodNames[i], ClassUtil.EMPTY_CLASS_ARRAY, true); if (md == null) { throw new PetiteException("Init method not found: " + beanDefinition.type.getName() + '#' + initMethodNames[i]); } initMethodPoints[i] = new InitMethodPoint(md.getMethod(), i, invocationStrategy); } beanDefinition.addInitMethodPoints(initMethodPoints); }
beanDefinition.addMethodInjectionPoint(mip);
/** * Returns Petite bean instance. * Petite container will find the bean in corresponding scope and all its dependencies, * either by constructor or property injection. When using constructor injection, cyclic dependencies * can not be prevented, but at least they are detected. * * @see PetiteContainer#createBean(Class) */ public <T> T getBean(final String name) { // Lookup for registered bean definition. BeanDefinition def = lookupBeanDefinition(name); if (def == null) { // try provider ProviderDefinition providerDefinition = providers.get(name); if (providerDefinition != null) { return (T) invokeProvider(providerDefinition); } return null; } // Find the bean in its scope Object bean = def.scopeLookup(); if (bean == null) { // Create new bean in the scope initBeanDefinition(def); final BeanData beanData = new BeanData(this, def); registerBeanAndWireAndInjectParamsAndInvokeInitMethods(beanData); bean = beanData.bean(); } return (T) bean; }
@Override public void register(final BeanDefinition beanDefinition, final Object bean) { Map<String, BeanData> threadLocalMap = context.get(); threadLocalMap.put(beanDefinition.name(), new BeanData(pc, beanDefinition, bean)); }
beanDefinition.ctor = petiteResolvers.resolveCtorInjectionPoint(beanDefinition.type()); beanDefinition.properties = PropertyInjectionPoint.EMPTY; beanDefinition.methods = MethodInjectionPoint.EMPTY;
/** * Registers scope. */ public void scopeRegister() { beanDefinition.scopeRegister(bean); }
/** * Removes bean and returns definition of removed bean. * All resolvers references are deleted, too. * Returns bean definition of removed bean or <code>null</code>. */ public BeanDefinition removeBean(final String name) { BeanDefinition bd = beans.remove(name); if (bd == null) { return null; } bd.scopeRemove(); return bd; }
/** * 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 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 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); }
/** * Returns Petite bean instance. * Petite container will find the bean in corresponding scope and all its dependencies, * either by constructor or property injection. When using constructor injection, cyclic dependencies * can not be prevented, but at least they are detected. * * @see PetiteContainer#createBean(Class) */ public <T> T getBean(final String name) { // Lookup for registered bean definition. BeanDefinition def = lookupBeanDefinition(name); if (def == null) { // try provider ProviderDefinition providerDefinition = providers.get(name); if (providerDefinition != null) { return (T) invokeProvider(providerDefinition); } return null; } // Find the bean in its scope Object bean = def.scopeLookup(); if (bean == null) { // Create new bean in the scope initBeanDefinition(def); final BeanData beanData = new BeanData(this, def); registerBeanAndWireAndInjectParamsAndInvokeInitMethods(beanData); bean = beanData.bean(); } return (T) bean; }