springboot InstantiationAwareBeanPostProcessor说明

最新推荐文章于 2024-09-14 18:27:12 发布
最新推荐文章于 2024-09-14 18:27:12 发布
阅读量360 收藏
点赞数
分类专栏： springboot 文章标签： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/119395415
版权

springboot InstantiationAwareBeanPostProcessor说明

                       

                                

*******************

相关类与接口

               

InstantiationAwareBeanPostProcessor

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    /** @deprecated */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

                    

BeanPostProcessor

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

                  

                        

CommonAnnotationBeanPostProcessor：@PostProcessor、@PreDestroy、@Resource

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
    @Nullable
    private static final Class<? extends Annotation> webServiceRefClass = loadAnnotationType("javax.xml.ws.WebServiceRef");
    @Nullable
    private static final Class<? extends Annotation> ejbClass = loadAnnotationType("javax.ejb.EJB");
    private static final Set<Class<? extends Annotation>> resourceAnnotationTypes = new LinkedHashSet(4);
    private final Set<String> ignoredResourceTypes = new HashSet(1);
    private boolean fallbackToDefaultTypeMatch = true;
    private boolean alwaysUseJndiLookup = false;
    private transient BeanFactory jndiFactory = new SimpleJndiBeanFactory();
    @Nullable
    private transient BeanFactory resourceFactory;
    @Nullable
    private transient BeanFactory beanFactory;
    @Nullable
    private transient StringValueResolver embeddedValueResolver;
    private final transient Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap(256);

    public CommonAnnotationBeanPostProcessor() {
        this.setOrder(2147483644);
        this.setInitAnnotationType(PostConstruct.class);     //初始化注解：PostConstruct
        this.setDestroyAnnotationType(PreDestroy.class);     //销毁注解：PreDestroy
        this.ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

    public void ignoreResourceType(String resourceType) {
    public void setFallbackToDefaultTypeMatch(boolean fallbackToDefaultTypeMatch) {
    public void setAlwaysUseJndiLookup(boolean alwaysUseJndiLookup) {
    public void setJndiFactory(BeanFactory jndiFactory) {
    public void setResourceFactory(BeanFactory resourceFactory) {
    public void setBeanFactory(BeanFactory beanFactory) {


    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    public void resetBeanDefinition(String beanName) {


    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        return null;
    }  //实例化之前不做处理

    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;
    }  //属性填充时，使用postProcessProperties返回的PropertyValues

    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        InjectionMetadata metadata = this.findResourceMetadata(beanName, bean.getClass(), pvs);

        try {
            metadata.inject(bean, beanName, pvs);
            return pvs;
        } catch (Throwable var6) {
            throw new BeanCreationException(beanName, "Injection of resource dependencies failed", var6);
        }
    }

    /** @deprecated */
    @Deprecated
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
        return this.postProcessProperties(pvs, bean, beanName);
    }


    private InjectionMetadata findResourceMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
    private InjectionMetadata buildResourceMetadata(Class<?> clazz) {

    protected Object buildLazyResourceProxy(final CommonAnnotationBeanPostProcessor.LookupElement element, @Nullable final String requestingBeanName) {

    protected Object getResource(CommonAnnotationBeanPostProcessor.LookupElement element, @Nullable String requestingBeanName) throws NoSuchBeanDefinitionException {
    protected Object autowireResource(BeanFactory factory, CommonAnnotationBeanPostProcessor.LookupElement element, @Nullable String requestingBeanName) throws NoSuchBeanDefinitionException {


    @Nullable
    private static Class<? extends Annotation> loadAnnotationType(String name) {
        try {
            return ClassUtils.forName(name, CommonAnnotationBeanPostProcessor.class.getClassLoader());
        } catch (ClassNotFoundException var2) {
            return null;
        }
    }


    static {
        resourceAnnotationTypes.add(Resource.class);  //静态语句块中添加注解：Resource
        if (webServiceRefClass != null) {             //如果类加载器中有注解：javax.xml.ws.WebServiceRef，则加入注解WebServiceRefClass
            resourceAnnotationTypes.add(webServiceRefClass);
        }

        if (ejbClass != null) {                       //如果类加载器中有注解：javax.ejb.EJB，则加入注解EJB
            resourceAnnotationTypes.add(ejbClass);
        }

    }   


************
内部类：LookupDependencyDescriptor

    private static class LookupDependencyDescriptor extends DependencyDescriptor {
        private final Class<?> lookupType;

        public LookupDependencyDescriptor(Field field, Class<?> lookupType) {
        public LookupDependencyDescriptor(Method method, Class<?> lookupType) {

        public Class<?> getDependencyType() {
            return this.lookupType;
        }
    }



************
内部类：EjbRefElement

    private class EjbRefElement extends CommonAnnotationBeanPostProcessor.LookupElement {
        private final String beanName;

        public EjbRefElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {

        protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {


************
内部类：WebServiceRefElement

    private class WebServiceRefElement extends CommonAnnotationBeanPostProcessor.LookupElement {
        private final Class<?> elementType;
        private final String wsdlLocation;

        public WebServiceRefElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {

        protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {


************
内部类：ResourceElement

    private class ResourceElement extends CommonAnnotationBeanPostProcessor.LookupElement {
        private final boolean lazyLookup;

        public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {

        protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {


************
内部类：LookupElement

    protected abstract static class LookupElement extends InjectedElement {
        protected String name = "";
        protected boolean isDefaultName = false;
        protected Class<?> lookupType = Object.class;
        @Nullable
        protected String mappedName;

        public LookupElement(Member member, @Nullable PropertyDescriptor pd) {


        public final String getName() {
        public final Class<?> getLookupType() {

        public final DependencyDescriptor getDependencyDescriptor() {

                 

InitDestroyAnnotationBeanPostProcessor：初始化、销毁处理器

public class InitDestroyAnnotationBeanPostProcessor implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {

    private final transient InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata emptyLifecycleMetadata = new InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata(Object.class, Collections.emptyList(), Collections.emptyList()) {
        public void checkConfigMembers(RootBeanDefinition beanDefinition) {
        }

        public void invokeInitMethods(Object target, String beanName) {
        }

        public void invokeDestroyMethods(Object target, String beanName) {
        }

        public boolean hasDestroyMethods() {
            return false;
        }
    };
    protected transient Log logger = LogFactory.getLog(this.getClass());

    @Nullable
    private Class<? extends Annotation> initAnnotationType;    //初始化注解
    @Nullable
    private Class<? extends Annotation> destroyAnnotationType; //销毁注解
    private int order = 2147483647;
    @Nullable
    private final transient Map<Class<?>, InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap(256);

    public InitDestroyAnnotationBeanPostProcessor() {
    }

    public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
    public void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType) {

    public void setOrder(int order) {
    public int getOrder() {

    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(beanType);
        metadata.checkConfigMembers(beanDefinition);
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(bean.getClass());

        try {
            metadata.invokeInitMethods(bean, beanName);
            return bean;
        } catch (InvocationTargetException var5) {
            throw new BeanCreationException(beanName, "Invocation of init method failed", var5.getTargetException());
        } catch (Throwable var6) {
            throw new BeanCreationException(beanName, "Failed to invoke init method", var6);
        }
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(bean.getClass());

        try {
            metadata.invokeDestroyMethods(bean, beanName);
        } catch (InvocationTargetException var6) {
            String msg = "Destroy method on bean with name '" + beanName + "' threw an exception";
            if (this.logger.isDebugEnabled()) {
                this.logger.warn(msg, var6.getTargetException());
            } else {
                this.logger.warn(msg + ": " + var6.getTargetException());
            }
        } catch (Throwable var7) {
            this.logger.warn("Failed to invoke destroy method on bean with name '" + beanName + "'", var7);
        }

    }

    public boolean requiresDestruction(Object bean) {
        return this.findLifecycleMetadata(bean.getClass()).hasDestroyMethods();
    }

    private InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
    private InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata buildLifecycleMetadata(Class<?> clazz) {

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {


**************
内部类：LifecycleElement

    private static class LifecycleElement {
        private final Method method;
        private final String identifier;

        public LifecycleElement(Method method) {


        public Method getMethod() {
        public String getIdentifier() {

        public void invoke(Object target) throws Throwable {

        public boolean equals(@Nullable Object other) {
        public int hashCode() {


**************
内部类：LifecycleMetadata

    private class LifecycleMetadata {
        private final Class<?> targetClass;
        private final Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> initMethods;
                              //初始化方法，可为多个
        private final Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> destroyMethods;
                              //销毁方法，可为多个
        @Nullable
        private volatile Set<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> checkedInitMethods;
        @Nullable
        private volatile Set<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> checkedDestroyMethods;

        public LifecycleMetadata(Class<?> targetClass, Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> initMethods, Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> destroyMethods) {

        public void checkConfigMembers(RootBeanDefinition beanDefinition) {

        public void invokeInitMethods(Object target, String beanName) throws Throwable {
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> checkedInitMethods = this.checkedInitMethods;
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> initMethodsToIterate = checkedInitMethods != null ? checkedInitMethods : this.initMethods;
            InitDestroyAnnotationBeanPostProcessor.LifecycleElement element;
            if (!((Collection)initMethodsToIterate).isEmpty()) {
                for(Iterator var5 = ((Collection)initMethodsToIterate).iterator(); var5.hasNext(); element.invoke(target)) {
                        //调用注解的初始化方法
                    element = (InitDestroyAnnotationBeanPostProcessor.LifecycleElement)var5.next();
                    if (InitDestroyAnnotationBeanPostProcessor.this.logger.isTraceEnabled()) {
                        InitDestroyAnnotationBeanPostProcessor.this.logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
                    }
                }
            }

        }

        public void invokeDestroyMethods(Object target, String beanName) throws Throwable {
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> destroyMethodsToUse = checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods;
            InitDestroyAnnotationBeanPostProcessor.LifecycleElement element;
            if (!((Collection)destroyMethodsToUse).isEmpty()) {
                for(Iterator var5 = ((Collection)destroyMethodsToUse).iterator(); var5.hasNext(); element.invoke(target)) {
                        //调用注解的销毁方法
                    element = (InitDestroyAnnotationBeanPostProcessor.LifecycleElement)var5.next();
                    if (InitDestroyAnnotationBeanPostProcessor.this.logger.isTraceEnabled()) {
                        InitDestroyAnnotationBeanPostProcessor.this.logger.trace("Invoking destroy method on bean '" + beanName + "': " + element.getMethod());
                    }
                }
            }

        }

        public boolean hasDestroyMethods() {

               

DestructionAwareBeanPostProcessor：销毁接口

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
    void postProcessBeforeDestruction(Object var1, String var2) throws BeansException;

    default boolean requiresDestruction(Object bean) {
        return true;
    }
}

                           

                           

AutowiredAnnotationBeanPostProcessor：@Autowired、@Value、@Inject

public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    protected final Log logger = LogFactory.getLog(this.getClass());
    private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet(4);

    private String requiredParameterName = "required";
    private boolean requiredParameterValue = true;       //是否需要参数值，默认为true
    private int order = 2147483645;

    @Nullable
    private ConfigurableListableBeanFactory beanFactory;
    private final Set<String> lookupMethodsChecked = Collections.newSetFromMap(new ConcurrentHashMap(256));
    private final Map<Class<?>, Constructor<?>[]> candidateConstructorsCache = new ConcurrentHashMap(256);
    private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap(256);

    public AutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(Autowired.class);  //添加注解：Autowired
        this.autowiredAnnotationTypes.add(Value.class);      //添加注解：Value

        try {
            this.autowiredAnnotationTypes.add(ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
                                          //如果类加载器有javax.inject.Inject，则添加注解Inject
            this.logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
        } catch (ClassNotFoundException var2) {
        }

    }

    public void setAutowiredAnnotationType(Class<? extends Annotation> autowiredAnnotationType) {
    public void setAutowiredAnnotationTypes(Set<Class<? extends Annotation>> autowiredAnnotationTypes) {

    public void setRequiredParameterName(String requiredParameterName) {
    public void setRequiredParameterValue(boolean requiredParameterValue) {

    public void setOrder(int order) {
    public int getOrder() {

    public void setBeanFactory(BeanFactory beanFactory) {

    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, beanType, (PropertyValues)null);
        metadata.checkConfigMembers(beanDefinition);
    }

    public void resetBeanDefinition(String beanName) {
        this.lookupMethodsChecked.remove(beanName);
        this.injectionMetadataCache.remove(beanName);
    }

    @Nullable
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeanCreationException {


    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);

        try {
            metadata.inject(bean, beanName, pvs);
            return pvs;
        } catch (BeanCreationException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
        }
    }

    public void processInjection(Object bean) throws BeanCreationException {

    private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
    private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
    private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {


    protected boolean determineRequiredStatus(MergedAnnotation<?> ann) {
    protected <T> Map<String, T> findAutowireCandidates(Class<T> type) throws BeansException {

    private void registerDependentBeans(@Nullable String beanName, Set<String> autowiredBeanNames) {
    private Object resolvedCachedArgument(@Nullable String beanName, @Nullable Object cachedArgument) {


***********
内部类：ShortcutDependencyDescriptor

    private static class ShortcutDependencyDescriptor extends DependencyDescriptor {
        private final String shortcut;
        private final Class<?> requiredType;

        public ShortcutDependencyDescriptor(DependencyDescriptor original, String shortcut, Class<?> requiredType) {

        public Object resolveShortcut(BeanFactory beanFactory) {


***********
内部类：AutowiredMethodElement

    private class AutowiredMethodElement extends InjectedElement {
        private final boolean required;
        private volatile boolean cached;
        @Nullable
        private volatile Object[] cachedMethodArguments;

        public AutowiredMethodElement(Method method, boolean required, @Nullable PropertyDescriptor pd) {

        protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {

        private Object[] resolveCachedArguments(@Nullable String beanName) {
        private Object[] resolveMethodArguments(Method method, Object bean, @Nullable String beanName) {


***********
内部类：AutowiredFieldElement

    private class AutowiredFieldElement extends InjectedElement {
        private final boolean required;
        private volatile boolean cached;
        @Nullable
        private volatile Object cachedFieldValue;

        public AutowiredFieldElement(Field field, boolean required) {

        protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {

        private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {

                    

SmartInstantiationAwareBeanPostProcessor

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
    @Nullable
    default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    @Nullable
    default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

                      

MergedBeanDefinitionPostProcessor

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
    void postProcessMergedBeanDefinition(RootBeanDefinition var1, Class<?> var2, String var3);

    default void resetBeanDefinition(String beanName) {
    }
}

                      

AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {


*********
createBean

    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }

        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var9) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
        }

        Object beanInstance;
        try {
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
                           //实例化之前解析
            if (beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var10) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
        }

        try {
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            throw var7;
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
        }
    }



    @Nullable
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
                     //实例化之前解析
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                                
                Class<?> targetType = this.determineTargetType(beanName, mbd);
                if (targetType != null) {
                               //判断targetType是否有InstantiationAwareBeanPostProcessor，
                               //如果有，则调用postProcessBeforeInstantiation方法
                    bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }  //如果bean不为null，调用postProcessAfterInitialization
                }
            }

            mbd.beforeInstantiationResolved = bean != null;
        }

        return bean;
    }

    @Nullable
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        Iterator var3 = this.getBeanPostProcessorCache().instantiationAware.iterator();

        Object result;
        do {
            if (!var3.hasNext()) {
                return null;
            }

            InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var3.next();
            result = bp.postProcessBeforeInstantiation(beanClass, beanName);
                        //调用postProcessBeforeInstantiation
        } while(result == null);

        return result;
    }

    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

        Object current;
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            current = processor.postProcessAfterInitialization(result, beanName);
                                //调用postProcessAfterInitialization方法
            if (current == null) {
                return result;
            }
        }

        return result;
    }



    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }   //创建bean实例

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }

                mbd.postProcessed = true;
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }

        Object exposedObject = bean;

        try {
            this.populateBean(beanName, mbd, instanceWrapper);                  //属性填充
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);  //初始化
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }

                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }


*************
属性填充

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator var4 = this.getBeanPostProcessorCache().instantiationAware.iterator();

                while(var4.hasNext()) {
                    InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var4.next();
                    if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        return;
                    }
                }
            }

            PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
            int resolvedAutowireMode = mbd.getResolvedAutowireMode();
            if (resolvedAutowireMode == 1 || resolvedAutowireMode == 2) {
                MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
                if (resolvedAutowireMode == 1) {
                    this.autowireByName(beanName, mbd, bw, newPvs);
                }

                if (resolvedAutowireMode == 2) {
                    this.autowireByType(beanName, mbd, bw, newPvs);
                }

                pvs = newPvs;
            }

            boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
            boolean needsDepCheck = mbd.getDependencyCheck() != 0;
            PropertyDescriptor[] filteredPds = null;
            if (hasInstAwareBpps) {
                if (pvs == null) {
                    pvs = mbd.getPropertyValues();
                }

                PropertyValues pvsToUse;
                for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {                    
                    InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();
                    pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                        //InstantiationAwareBeanPostProcessor返回的PropertyValues
                        //pvs = pvsToUse，待注入的属性值

                    if (pvsToUse == null) {
                        if (filteredPds == null) {
                            filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                        }

                        pvsToUse = bp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            return;
                        }
                    }
                }
            }

            if (needsDepCheck) {
                if (filteredPds == null) {
                    filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                }

                this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
            }

            if (pvs != null) {
                this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
            }   //如果pvs不为空则注入属性值

        }
    }



*************
初始化

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareMethods(beanName, bean);
                return null;
            }, this.getAccessControlContext());
        } else {
            this.invokeAwareMethods(beanName, bean);
        }  //调用aware方法（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }  //初始化前调用applyBeanPostProcessorsBeforeInitialization

        try {
            this.invokeInitMethods(beanName, wrappedBean, mbd);
                 //调用initMethod（InitializingBean、指定的initMethodName）
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
        }

        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }        //调用applyBeanPostProcessorsAfterInitialization

        return wrappedBean;
    }

    private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

        Object current;
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            current = processor.postProcessBeforeInitialization(result, beanName);
                               //调用postProcessBeforeInitialization
            if (current == null) {
                return result;
            }
        }

        return result;
    }

    protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
        boolean isInitializingBean = bean instanceof InitializingBean;
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }

            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(() -> {
                        ((InitializingBean)bean).afterPropertiesSet();
                        return null;
                    }, this.getAccessControlContext());
                } catch (PrivilegedActionException var6) {
                    throw var6.getException();
                }
            } else {
                ((InitializingBean)bean).afterPropertiesSet();
            }
        }

        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
                this.invokeCustomInitMethod(beanName, bean, mbd);
            }
        }

    }

    protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd) throws Throwable {
        String initMethodName = mbd.getInitMethodName();
        Assert.state(initMethodName != null, "No init method set");
        Method initMethod = mbd.isNonPublicAccessAllowed() ? BeanUtils.findMethod(bean.getClass(), initMethodName, new Class[0]) : ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName, new Class[0]);
        if (initMethod == null) {
            if (mbd.isEnforceInitMethod()) {
                throw new BeanDefinitionValidationException("Could not find an init method named '" + initMethodName + "' on bean with name '" + beanName + "'");
            } else {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("No default init method named '" + initMethodName + "' found on bean with name '" + beanName + "'");
                }

            }
        } else {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
            }

            Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(() -> {
                    ReflectionUtils.makeAccessible(methodToInvoke);
                    return null;
                });

                try {
                    AccessController.doPrivileged(() -> {
                        return methodToInvoke.invoke(bean);
                    }, this.getAccessControlContext());
                } catch (PrivilegedActionException var10) {
                    InvocationTargetException ex = (InvocationTargetException)var10.getException();
                    throw ex.getTargetException();
                }
            } else {
                try {
                    ReflectionUtils.makeAccessible(methodToInvoke);
                    methodToInvoke.invoke(bean);
                } catch (InvocationTargetException var9) {
                    throw var9.getTargetException();
                }
            }

        }
    }

    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

        Object current;
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
        }

        return result;
    }

                    

                    

*******************

示例

                       

*****************

pojo 层

              

Person

@Data
public class Person {

    private String name;
    private Integer age;
}

              

People

@Data
public class People {

    private String name;
    private Integer age;
}

                 

Student

@Data
public class Student implements InitializingBean, DisposableBean {

    private String name;
    private Integer age;

    @PostConstruct
    public void fun(){
        System.out.println("student postConstruct");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("student afterPropertiesSet："+ this);
    }

    public void customInit(){
        System.out.println("student 自定义初始化方法：customInit");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("student preDestroy");
    }

    public void customDestroy(){
        System.out.println("student 自定义销毁方法：customDestroy");
    }
}

              

*****************

config 层

               

DataConfig

@Configuration
public class DataConfig {

    @Bean("person")
    public Person initPerson(){
        Person person=new Person();
        person.setName("初始化名称 瓜田李下");
        person.setAge(20);

        return person;
    }

    @Bean(name = "student",initMethod = "customInit",destroyMethod = "customDestroy")
    public Student initStudent(){
        Student student=new Student();
        student.setName("初始化名称 海贼王");
        student.setAge(20);

        return student;
    }

    @Bean("people")
    public People initPeople(){
        People people=new People();
        people.setName("初始化名称 火影忍者");
        people.setAge(20);

        return people;
    }
}

                    

CustomInstantiationAwareBeanPostProcessor

@Configuration
public class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanClass.getSimpleName().equals("Person")){
            Person person=new Person();
            person.setName("修改后名称 瓜田李下");
            person.setAge(20);
            System.out.println(person);

            return person;
        }

        return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (bean instanceof People){
            return true;
        }

        return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if (bean instanceof People){
            System.out.println(beanName+"  "+bean+"  "+pvs.getPropertyValues().length);
            MutablePropertyValues mutablePropertyValues=(MutablePropertyValues)pvs;
            mutablePropertyValues.addPropertyValue("name","修改后名称 火影忍者");

            return mutablePropertyValues;
        }

        return InstantiationAwareBeanPostProcessor.super.postProcessProperties(pvs, bean, beanName);
    }
}

                  

*****************

controller 层

                

HelloController

@RestController
public class HelloController {

    @Resource
    private Person person;

    @Resource
    private People people;

    @Resource
    private Student student;

    @RequestMapping("/hello")
    public String hello(){
        System.out.println(person);
        System.out.println(people);
        System.out.println(student);

        return "success";
    }
}

                      

                                  

*******************

测试输出

              

启动后，控制台输出

2021-08-07 19:49:48.008  INFO 15652 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-08-07 19:49:48.008  INFO 15652 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1443 ms
Person(name=修改后名称 瓜田李下, age=20)
people  People(name=初始化名称 火影忍者, age=20)  0

# 执行顺序：@PostConstruct、afterpropertiesSet、自定义初始化方法（initMethod）
student postConstruct
student afterPropertiesSet：Student(name=初始化名称 海贼王, age=20)
student 自定义初始化方法：customInit

2021-08-07 19:49:48.625  INFO 15652 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-08-07 19:49:48.635  INFO 15652 --- [           main] tiationAwareBeanPostProcessorApplication : Started SpringbootInstantiationAwareBeanPostProcessorApplication in 2.505 seconds (JVM running for 3.54)

                    

localhost:8080/hello，控制台输出：

Person(name=修改后名称 瓜田李下, age=20)
People(name=修改后名称 火影忍者, age=20)
Student(name=初始化名称 海贼王, age=20)

# person属性在postProcessBeforeInstantiation中修改
# people属性在postProcessAfterInstantiation、postProcessProperties中修改

                                 

                                         

o_瓜田李下_o
关注
专栏目录
扩展点系列之SmartInstantiationAwareBeanPostProcessor确定执行哪一个构造方法 - 第432篇
悟纤学院
06-27 768
SmartInstantiationAwareBeanPostProcessor 继承自InstantiationAwareBeanPostProcessor；
SpringBoot/Spring扩展点系列之FactoryBean让你不在懵逼 - 第435篇
悟纤学院
07-18 485
当Bean的创建过程比较复杂的话，通过FactoryBean来实现实现Bean的复杂创建过程，这个时候FactoryBean的话，可以让使用者使用起来很简单无需关心Bean的创建过程，听起来是不是很像工厂设计模型。
Springboot扩展点之InstantiationAwareBeanPostProcessor
凡夫编程
02-08 4116
前面介绍了Springboot的扩展点之BeanPostProcessor，再来介绍另一个扩展点InstantiationAwareBeanPostProcessor就容易多了。因为InstantiationAwareBeanPostProcessor也属于Bean级的后置处理器，还继于BeanPostProcessor，因此InstantiationAwareBeanPostProcessor除了可以实现BeanPostProcessor的扩展外，又额外增加了三个扩展点，这篇文章也是围绕这三个扩展点展示，
Spring扩展点系列-SmartInstantiationAwareBeanPostProcessor
最新发布
qq_32590535的博客
09-14 1166
提到SmartInstantiationAwareBeanPostProcessor，这里就要说到三级缓存的话题，spring引入一个三级缓存来解决循环依赖和AOP的问题。三级缓存的key还是为beanName，但是value是一个函数（ObjectFactory#getBean方法），在该函数中执行获取早期对象的逻辑：getEarlyBeanReference方法。 在getEarlyBeanReference方法中，Spring会调用所有SmartInstantiationAwareBeanPostPr
Springboot扩展点系列_InstantiationAwareBeanPostProcessor
皮球
10-24 561
最后一步内容很长，不过很简单，即按第二步分成的三类，依次注册，具体的顺序是：1：实现PriorityOrdered接口BeanPostProcessor接口的实现类、2：实现实现Ordered接口BeanPostProcessor接口的实现类、3：其他的BeanPostProcessor接口的实现类，其中MyInstantiationAwareBeanPostProcessor属于第三类；（lambda表达式的应用在Spirng的源码中应用很广泛，所以对这块不太熟悉的小伙伴可以着重研究一下）
Spring扩展接口InstantiationAwareBeanPostProcessor解析
zyc920716的博客
12-03 188
添加链接描述
Spring中Bean实例化之后做的增强 InstantiationAwareBeanPostProcessor
雾里看花叹朦胧
02-12 2368
package sping.analysis.postprocessor; import java.beans.PropertyDescriptor; import org.springframework.beans.BeansException; import org.springframework.beans.PropertyValues; import org.springframewo...
SpringBoot-2.7.6自动装配过程
qq_38127559的博客
01-15 1031
SpringBoot的自动装配是拆箱即用的基础，也是微服务化的前提。我们在熟练使用springboot的时候，能否也能熟悉它完整的自动装配的过程？接下来我们就透过源代码来把握自动装配的来龙去脉。以下所有内容都是基于SpringBoot-2.7.6版本来的，版本不同自动装配的流程或许会有差异，在参照本文调试源码时要注意本地的SpringBoot版本。
Springboot源码分析之EnableAspectJAutoProxy
a3959678的博客
08-23 695
Spring Framwork的两大核心技术就是IOC和AOP，AOP在Spring的产品线中有着大量的应用。如果说反射是你通向高级的基础，那么代理就是你站稳高级的底气。AOP的本质也就是大家所熟悉的CGLIB动态代理技术，在日常工作中想必或多或少都用过但是它背后的秘密值得我们去深思。本文主要从Spring AOP运行过程上，结合一定的源码整体上介绍Spring AOP的一个运行过程。知其然，知其...
SpringBoot源码之容器刷新 refreshContext 方法详解
my的博客
08-23 528
highlight: androidstudio 上一篇我们聊了Springboot的run方法，今天我们聊下关于容器刷新(refresh) 本文很长，请各位同学要忍一下~~~ 好了，废话不多说，直接开干 !!! 1.refresh 主方法 (重要) ``` java public void refresh() throws BeansException, IllegalStateE...
Spring之InstantiationAwareBeanPostProcessor
JustinNeil的博客
07-10 1939
InstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口，该接口的作用是感知Bean实例化的处理器。 该接口除了继承自父接口的两个方法外，还定义了三个方法 方法 描述 postProcessBeforeInstantiation 自身方法，是最先执行的方法，它在目标对象实例化之前调用，方法到的返回值是Object类型，我们可...
4、Spring源码之InstantiationAwareBeanPostProcessor
u014647223的专栏
12-09 558
Spring源码之InstantiationAwareBeanPostProcessor
[SpringMVC] InstantiationAwareBeanPostProcessor
墨秋
10-19 231
简介 InstantiationAwareBeanPostProcessor 继承自 BeanPostProcessor 是 Spring 非常重要的拓展接口，监听 Bean 的一段生命周期：实例化(Instantiation) 前置 指定 Bean 初始化方法（方式：注解）：创建后执行这些操作 @Component public class Color { @PostConstruct public void init(){ System.out.println("车生
Spring之InstantiationAwareBeanPostProcessor接口介绍
热门推荐
波波烤鸭的博客
03-03 1万+
  InstantiationAwareBeanPostProcessor接口讲解
InstantiationAwareBeanPostProcessor
luzhensmart的专栏
05-06 3620
一、InstantiationAwareBeanPostProcessor简述与demo示例 InstantiationAwareBeanPostProcessor继承自BeanPostProcessor 是spring非常重要的拓展接口，代表这bean的一段生命周期:实例化(Instantiation) public interface InstantiationAwareBean...
SpringBoot java.lang.InstantiationException
这就是快乐嘛
07-19 268
原因是从数据库查出值返回到实体类时，需要有一个无参数的构造函数，如果通过lombok的@Data注解会帮你实现这个类。如果没使用，就需要自己在实体类里写一个无参构造函数，否则抛异常
InstantiationAwareBeanPostProcessor 学习
A_java_c的博客
08-08 349
简介 注意：我使用的是SpringBoot版本：2.5.3 BeanPostProcessor包括二个初始化相关方法，InstantiationAwareBeanPostProcessor：包括这个实例化相关方法，以及一个属性值相关方法，postProcessProperties（postProcessPropertyValues在此版本中被标记为过时） 先整体看一下，这个五个方法执行的顺序，如流程图 测试例子 相关文件 <?xml version="1.0" encoding="UTF-8"?&
Springboot扩展点之SmartInstantiationAwareBeanPostProcessor
凡夫编程
02-10 2326
这是Springboot扩展点系列的第5篇了，主要介绍一下SmartInstantiationAwareBeanPostProcessor扩展点的功能特性、和实现方式。SmartInstantiationAwareBeanPostProcessor与其他扩展点最明显的不同，就是在实际的业务开发场景中应用到的机会并不多，主要是在Spring内部应用，但是为什么还要了解呢？遇到能力强的人要学他三分，遇到优秀的应用模式，同样也应该学他三分，这便是我依然要花一些时间把他分享给大家的原因。
SmartInstantiationAwareBeanPostProcessor
chuixue24的博客
01-15 3157
BeanPostProcessor是spring的bean后置处理器，这个接口定义了两个方法分别在bean的初始化前、初始化后执行。 InstantiationAwareBeanPostProcessor继承自BeanPostProcessor，添加了两个方法，这两个方法分别在bean的实例化前、实例化后执行。 SmartInstantiationAwareBeanPostProcessor又继承自InstantiationAwareBeanPostProcessor，添加了几个方法，其中有...
nginx 和 springboot 配置说明
10-24
在与springboot的配合中，我们可以通过nginx来提供静态资源的服务，并将请求转发给springboot应用程序进行处理。 首先，我们需要在nginx的配置文件中指定静态资源的路径。可以使用`root`或`alias`指令来设置静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值