Tabnine Logo
ConstructorResolver.<init>
Code IndexAdd Tabnine to your IDE (free)

How to use
org.springframework.beans.factory.support.ConstructorResolver
constructor

Best Java code snippets using org.springframework.beans.factory.support.ConstructorResolver.<init> (Showing top 12 results out of 315)

origin: spring-projects/spring-framework

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 * on a factory object itself configured using Dependency Injection.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 * @see #getBean(String, Object[])
 */
protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}
origin: spring-projects/spring-framework

/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
origin: org.springframework/spring-beans

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 * on a factory object itself configured using Dependency Injection.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 * @see #getBean(String, Object[])
 */
protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}
origin: org.springframework/spring-beans

/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
origin: spring-projects/spring-framework

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
    DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
  String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  resolveBeanClass(mbd, beanDefinitionName);
  if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
    new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
  }
  return resolver.isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}
origin: org.springframework/spring-beans

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
    DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
  String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  resolveBeanClass(mbd, beanDefinitionName);
  if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
    new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
  }
  return resolver.isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}
origin: camunda/camunda-bpm-platform

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 * on a factory object itself configured using Dependency Injection.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or <code>null</code> if none (-> use constructor argument values from bean definition)
 * @return BeanWrapper for the new instance
 * @see #getBean(String, Object[])
 */
protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {
  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}
origin: camunda/camunda-bpm-platform

/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or <code>null</code> if none (-> use constructor argument values from bean definition)
 * @return BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, Constructor[] ctors, Object[] explicitArgs) {
  return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
origin: camunda/camunda-bpm-platform

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor) {
  resolveBeanClass(mbd, beanName);
  if (mbd.isFactoryMethodUnique) {
    boolean resolve;
    synchronized (mbd.constructorArgumentLock) {
      resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
    }
    if (resolve) {
      new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
    }
  }
  return getAutowireCandidateResolver().isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanName)), descriptor);
}
origin: org.mule.modules/mule-module-spring-config

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
                   DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
  String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  resolveBeanClass(mbd, beanDefinitionName);
  if (mbd.isFactoryMethodUnique) {
    boolean resolve;
    synchronized (mbd.constructorArgumentLock) {
      resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
    }
    if (resolve) {
      new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
    }
  }
  return resolver.isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}
origin: org.mule.runtime/mule-module-spring-config

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate, to be injected into other beans which
 * declare a dependency of matching type.
 *
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor,
                   AutowireCandidateResolver resolver) {
 String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
 resolveBeanClass(mbd, beanDefinitionName);
 if (mbd.isFactoryMethodUnique) {
  boolean resolve;
  synchronized (mbd.constructorArgumentLock) {
   resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
  }
  if (resolve) {
   new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
  }
 }
 return resolver.isAutowireCandidate(new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}
origin: apache/servicemix-bundles

new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
org.springframework.beans.factory.supportConstructorResolver<init>

Javadoc

Create a new ConstructorResolver for the given factory and instantiation strategy.

Popular methods of ConstructorResolver

  • resolveFactoryMethodIfPossible
    Resolve the factory method in the specified bean definition, if possible. RootBeanDefinition#getReso
  • autowireConstructor
    "autowire constructor" (with constructor arguments by type) behavior. Also applied if explicit const
  • createArgumentArray
    Create an array of arguments to invoke a constructor or factory method, given the resolved construct
  • getUserDeclaredConstructor
  • instantiateUsingFactoryMethod
    Instantiate the bean using a named factory method. The method may be static, if the bean definition
  • resolveAutowiredArgument
    Template method for resolving the specified argument which is supposed to be autowired.
  • resolveConstructorArguments
    Resolve the constructor arguments for this bean into the resolvedValues object. This may involve loo
  • resolvePreparedArguments
    Resolve the prepared arguments stored in the given bean definition.
  • getCandidateMethods
    Retrieve all candidate methods for the given class, considering the RootBeanDefinition#isNonPublicAc
  • instantiate
  • setCurrentInjectionPoint
  • setCurrentInjectionPoint

Popular in Java

  • Reading from database using SQL prepared statement
  • getApplicationContext (Context)
  • notifyDataSetChanged (ArrayAdapter)
  • getExternalFilesDir (Context)
  • FlowLayout (java.awt)
    A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
  • MalformedURLException (java.net)
    This exception is thrown when a program attempts to create an URL from an incorrect specification.
  • UnknownHostException (java.net)
    Thrown when a hostname can not be resolved.
  • NoSuchElementException (java.util)
    Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
  • ReentrantLock (java.util.concurrent.locks)
    A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor
  • JFrame (javax.swing)
  • PhpStorm for WordPress
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

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