Package org.springframework.beans.factory.config

# Interface SmartInstantiationAwareBeanPostProcessor

All Superinterfaces:
  `BeanPostProcessor`, `InstantiationAwareBeanPostProcessor`

All Known Implementing Classes:
  `AutowiredAnnotationBeanPostProcessor`

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor
Extension of the `InstantiationAwareBeanPostProcessor` interface, adding a callback for predicting the eventual type of a processed bean.

NOTE: This interface is a special purpose interface, mainly for internal use within the framework. In general, application-provided post-processors should simply implement the plain `BeanPostProcessor` interface.

Since:
  2.0.3
Author:
  Juergen Hoeller

## Method Summary

Modifier and Type
Method
Description
`default Class<?>`
`determineBeanType(Class<?> beanClass, String beanName)`
Determine the type of the bean to be eventually returned from this processor's `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` callback.
`default Constructor<?>[]`
`determineCandidateConstructors(Class<?> beanClass, String beanName)`
Determine the candidate constructors to use for the given bean.
`default Object`
`getEarlyBeanReference(Object bean, String beanName)`
Obtain a reference for early access to the specified bean, typically for the purpose of resolving a circular reference.
`default Class<?>`
`predictBeanType(Class<?> beanClass, String beanName)`
Predict the type of the bean to be eventually returned from this processor's `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` callback.

### Methods inherited from interface org.springframework.beans.factory.config.BeanPostProcessor

`postProcessAfterInitialization, postProcessBeforeInitialization`

### Methods inherited from interface org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor

`postProcessAfterInstantiation, postProcessBeforeInstantiation, postProcessProperties`

## Method Details

### predictBeanType

@Nullable default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException
Predict the type of the bean to be eventually returned from this processor's `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` callback.

The default implementation returns `null`. Specific implementations should try to predict the bean type as far as known/cached already, without extra processing steps.

Parameters:
  `beanClass` - the raw class of the bean
  `beanName` - the name of the bean
Returns:
  the type of the bean, or `null` if not predictable
Throws:
  `BeansException` - in case of errors

### determineBeanType

default Class<?> determineBeanType(Class<?> beanClass, String beanName) throws BeansException
Determine the type of the bean to be eventually returned from this processor's `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` callback.

The default implementation returns the given bean class as-is. Specific implementations should fully evaluate their processing steps in order to create/initialize a potential proxy class upfront.

Parameters:
  `beanClass` - the raw class of the bean
  `beanName` - the name of the bean
Returns:
  the type of the bean (never `null`)
Throws:
  `BeansException` - in case of errors
Since:
  6.0

### determineCandidateConstructors

@Nullable default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException
Determine the candidate constructors to use for the given bean.

The default implementation returns `null`.

Parameters:
  `beanClass` - the raw class of the bean (never `null`)
  `beanName` - the name of the bean
Returns:
  the candidate constructors, or `null` if none specified
Throws:
  `BeansException` - in case of errors

### getEarlyBeanReference

default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException
Obtain a reference for early access to the specified bean, typically for the purpose of resolving a circular reference.

This callback gives post-processors a chance to expose a wrapper early - that is, before the target bean instance is fully initialized. The exposed object should be equivalent to what `BeanPostProcessor.postProcessBeforeInitialization(java.lang.Object, java.lang.String)` / `BeanPostProcessor.postProcessAfterInitialization(java.lang.Object, java.lang.String)` would expose otherwise. Note that the object returned by this method will be used as the bean reference unless the post-processor returns a different wrapper from said post-process callbacks. In other words, those post-process callbacks may either eventually expose the same reference or alternatively return the raw bean instance from those subsequent callbacks (if the wrapper for the affected bean has been built for a call to this method already, it will be exposed as the final bean reference by default).

The default implementation returns the given `bean` as-is.

Parameters:
  `bean` - the raw bean instance
  `beanName` - the name of the bean
Returns:
  the object to expose as the bean reference (typically the passed-in bean instance as default)
Throws:
  `BeansException` - in case of errors