congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
jodd.petite
Code IndexAdd Tabnine to your IDE (free)

How to use jodd.petite

Best Java code snippets using jodd.petite (Showing top 20 results out of 315)

origin: oblac/jodd

/**
 * 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());
}
origin: oblac/jodd

/**
 * Starts with defining injection points (i.e. wiring) for existing bean.
 */
public BeanWire wire(final String beanName) {
  petiteContainer.lookupExistingBeanDefinition(beanName);
  return new BeanWire(beanName);
}
origin: oblac/jodd

/**
 * Starts registration of init method.
 */
public BeanInit init(final String beanName) {
  petiteContainer.lookupExistingBeanDefinition(beanName);
  return new BeanInit(beanName);
}
origin: oblac/jodd

/**
 * 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();
}
origin: oblac/jodd

/**
 * 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));
}
origin: oblac/jodd

@Test
void test243() {
  PetiteContainer pc = new PetiteContainer();
  new PetiteRegistry(pc).provider("provider").type(PetiteDemo.class).method("getOne").args().register();
}
origin: oblac/jodd

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();
}
origin: oblac/jodd

/**
 * 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;
}
origin: oblac/jodd

  @Override
  protected ActionResult createResult(final Class<? extends ActionResult> actionResultClass) {
    return petiteContainer.createBean(actionResultClass);
  }
}
origin: oblac/jodd

/**
 * 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);
}
origin: oblac/jodd

/**
 * Starts registration of destroy method.
 */
public BeanDestroy destroy(final String beanName) {
  petiteContainer.lookupExistingBeanDefinition(beanName);
  return new BeanDestroy(beanName);
}
origin: oblac/jodd

/**
 * 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;
}
origin: oblac/jodd

/**
 * Invokes single method injection point on given bean with given bean definition.
 */
protected void wireMethods() {
  for (final MethodInjectionPoint methodRef : definition().methods) {
    invokeMethodInjectionPoint(methodRef);
  }
}
origin: oblac/jodd

/**
 * 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;
}
/**
origin: oblac/jodd

  /**
   * Registers property injection point.
   */
  public void bind() {
    petiteContainer.registerPetitePropertyInjectionPoint(beanName, propertyName, reference);
  }
}
origin: oblac/jodd

  /**
   * Registers init methods.
   */
  public void register() {
    petiteContainer.registerPetiteInitMethods(beanName, strategy, methods);
  }
}
origin: oblac/jodd

public BeanData(final PetiteContainer petiteContainer, final BeanDefinition<T> beanDefinition) {
  this.pc = petiteContainer;
  this.beanDefinition = beanDefinition;
  this.bean = (T) newBeanInstance();
}
origin: oblac/jodd

/**
 * Wires beans constructor.
 * @see PetiteBeans#registerPetiteCtorInjectionPoint(String, Class[], String[])
 */
public BeanWireCtor ctor(final Class... ctorArgumentTypes) {
  return new BeanWireCtor(ctorArgumentTypes);
}
origin: oblac/jodd

/**
 * 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);
}
origin: oblac/jodd

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

Most used classes

  • PetiteContainer
    Petite IOC container. Consist of following layers:PetiteContainer - top layer that provides business
  • PetiteInject
  • BeanDefinition
    Petite bean definition and cache. Consist of bean data that defines a bean and cache, that might not
  • AutomagicPetiteConfigurator
    Auto-magically configures Petite container by analyzing the classpath. Scans all classes on classpat
  • PetiteConfig
    Petite configuration.
  • PetiteRegistry,
  • PetiteInitMethod,
  • ProxettaAwarePetiteContainer,
  • SessionScope,
  • ParamManager,
  • PetiteBeans,
  • PetiteException,
  • PetiteRegistry$BeanInit,
  • PetiteRegistry$BeanProvider,
  • PetiteRegistry$BeanRegister,
  • PetiteRegistry$BeanWire$BeanWireCtor,
  • PetiteRegistry$BeanWire$BeanWireMethod,
  • PetiteRegistry$BeanWire$BeanWireProperty,
  • PetiteRegistry$BeanWire
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now