Spring知识扫盲

2022-01-30 22:00:19 阅读：118 来源： 互联网

标签：code Spring 知识 springframework 扫盲 bean import org public

1、bean生命周期：看BeanFactory注释

翻译成中文

Bean工厂实现应该尽可能的支持标准的Bean生命周期接口。整套初始化方法及其标准顺序如下：
BeanNameAware{@code setBeanName}
BeanClassLoaderware{@code setBeanClassLoader}
BeanFactoryAware{@code setBeanFactory}
EnvironmentAware{@code setEnvironment}
EmbeddedValueResolverAware{@code setEmbeddedValueResolver}
ResourceLoaderware{@code setResourceLoader}（仅在应用程序上下文中运行时适用）
ApplicationEventPublisherAware{@code setApplicationEventPublisher}（仅在应用程序上下文中运行时适用）
MessageSourceAware{@code setMessageSource}（仅在应用程序上下文中运行时适用）
ApplicationContextAware{@code setApplicationContext}（仅在应用程序上下文中运行时适用）
ServletContextAware{@code setServletContext}（仅在web应用程序上下文中运行时适用）
BeanPostProcessor{@code postprocessabefore initialization}方法
初始化Bean的{@code afterPropertieSet}自定义init方法定义
BeanPostProcessor{@code postProcessAfterInitialization}方法


关闭Bean工厂时，以下生命周期方法适用：
{@code postprocessabeforedisplation}销毁方法Warebean后处理器
DisposableBean的{@code destroy}
自定义销毁方法

2、Aware接口的作用：如果自己创建的bean对象需要容器的内置对象，可以通过Aware接口把对象设置到这个bean里

package beans;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * 只要实现Aware接口，就可自动注入容器内置的某些属性，比如注入ApplicationContext、beanName
 */
public class MyAwareBean implements ApplicationContextAware, BeanNameAware {

    private ApplicationContext applicationContext;
    
    private String beanName;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
    }

    public String getBeanName() {
        return beanName;
    }
}

3、BeanPostProcessor与BeanProcessor
BeanPostProcessor：在bean实例化之前执行，可以在这一阶段增强（修改）BeanDefinition属性
BeanProcessor：在bean实例化之后执行，可以在这一阶段增强（修改）Bean对象属性

package beans;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor 用于增强（修改）BeanDefinition
 * 这里把org.springframework包下所有的bean设置了Lazy
 */
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

		String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
		for (String beanDefinitionName : beanDefinitionNames) {
			System.out.println(beanDefinitionName);
			if (beanDefinitionName.startsWith("org.springframework")) {
				continue;
			}

			BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName);
			beanDefinition.setLazyInit(true);
		}
	}
}

package beans;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * 每个bean实例化之后，都会触发该方法。用于增强（修改）bean对象
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("[BeanPostProcessor] 后置处理 " + beanName);
		if (bean instanceof User) {
			System.out.println(String.format("[BeanPostProcessor] 在bean初始化之后 init方法之前 beanName %s bean实例 %s 修改为 %s",
					beanName, bean, "Before修改的值"));
			User user = (User) bean;
			user.setName("Before修改的值");
		}

		return bean;
	}

	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (bean instanceof User) {
			System.out.println(String.format("[BeanPostProcessor] 在bean初始化之后 init方法之后 beanName %s bean实例 %s 修改为 %s",
					beanName, bean, "After修改的值"));
			User user = (User) bean;
			user.setName("After修改的值");
		}
		return bean;
	}

}

4、beanFactory与factoryBean区别？
1）都是用来创建对象的
2）使用beanFactory时，必须要遵循完整的创建过程，这个过程是由spring来控制的
3）当使用factoryBean只需要调用getObject()可以返回具体的对象，对象的创建过程由自己来控制，更加灵活

package beans;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

/**
 * 可以自定义FactoryBean来创建bean对象，避开beanFactory的创建过程
 *
 * 获取bean
 * Object user = ctx.getBean("userFactoryBean");
 * System.out.println(user);
 * 
 * 获取FactoryBean
 * Object userFactoryBean = ctx.getBean("&userFactoryBean");
 * System.out.println(userFactoryBean);
 */
@Component
public class UserFactoryBean implements FactoryBean<User> {

    @Override
    public User getObject() throws Exception {
        return new User();
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

标签：code,Spring,知识,springframework,扫盲,bean,import,org,public
来源： https://www.cnblogs.com/wwzyy/p/15857670.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Spring知识扫盲