How to use

BeanDefinition

in

jodd.petite

  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;
}