How to use jodd.petite

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