4.Spring面试题

1.什么是控制反转IOC？什么是依赖注入DI?
2.SpringIOC创建bean对象的生命周期
3.什么是Spring的AOP？
4.说下SpringAOP里面的几个名词
5.什么是Spring的自动装配？spring自动装配bean有哪些方式
6.Spring中的bean的初始化方式有几种？有什么区别？
7.@Autowired和@Resource的匹配规则
8.Spring IoC 的实现机制。
9.spring 提供了哪些配置方式？
10.Spring开启context:annotation-config和context:component-scan注解的区别
11.Spring中有多少个模块，它们分别是什么
12.SpringAOP中有哪些类型的通知
13.SpringAop的操作方法(纯注解)
14.声明式事务配置的三种方式
15.ApplicationContext和BeanFactory的区别
16.Spring框架中的单例bean是线程安全的吗
17.InitializingBean接口afterPropertiesSet(),DisposableBean接口的destroy()和自定义的init-method,destroy-method的区别
18.Spring中如何注入一个java集合
19.Spring支持的事务管理类型，你更倾向用那种事务管理类型？
20.Spring中@Transactional里的事务的隔离级别和事务传播特性
Spring循环依赖问题
- 1.什么是循环依赖？
- 2.为什么构造器注入无法解决循环依赖问题？
- 3.多例的情况下，循环依赖问题为什么无法解决？
- 4.三级缓存分别是什么？三个Map有什么异同
- 5.Spring解决循环依赖的流程
- 6.两个对象在三级缓存中的迁移说明
- 7.在给B注入的时候为什么要注入一个代理对象？
- 8.B中提前注入了一个没有经过初始化的A类型对象不会有问题吗？如果开启了AOP初始化的时候是对A对象本身进行初始化，而容器中以及注入到B中的是A的代理对象，这样不会有问题吗？
- 9.为什么要使用三级缓存呢？二级缓存能解决循环依赖吗？
- 10.那如果使用三级缓存不使用二级缓存呢？
- 11.三级缓存真的提高了效率了吗？
- 12.思考题为什么在下表中的第三种情况的循环依赖能被解决，而第四种情况不能被解决呢？

1.什么是控制反转IOC？什么是依赖注入DI?

IOC就是控制反转，是将组件对象的控制权由程序代码本身交给外部容器管理，所以叫控制反转。
控制反转的作用是:创建对象，维护对象的依赖关系，实现了解耦，降低了维护成本。
DI：我们使用Spring容器的时候，容器通过调用set方法或者是构造器来建立对象之间的依赖关系。控制反转是目标，依赖注入是我们实现控制反转的一种手段。

2.SpringIOC创建bean对象的生命周期

bean的生命周期初步分为四个阶段Bean的实例化阶段,Bean的设置属性阶段,Bean的初始化阶段,Bean的销毁阶段
1.Bean容器利用反射机制对bean进行实例化
2.Bean容器为实例化的bean设置属性值
3.如果bean实现了BeanNameAware接口,则执行setBeanName方法
4.如果bean实现了BeanClassLoaderAware接口，则执行setBeanClassLoader方法
5.如果bean实现了BeanFactoryAware接口,则执行setBeanFactory方法
6.如果bean实现了ApplicationContextAware接口,则执行setApplicationContext方法
7.如果加载了BeanPostProcessor相关实现类,则执行postProcessBeforeInitialization方法
8.如果bean实现了InitializationBean接口,则执行afterPropertiesSet方法
9.如果bean定义了初始化方法(配置文件配置init-method或者添加注解@PostConstruct),则执行定义的初始化方法
10.如果加载了BeanPostProcessor相关实现类,则执行postProcessAfterInitialization方法
11.当要销毁这个bean时，如果Bean实现了DisposableBean接口，则执行destroy方法
12.如果bean自定义了销毁方法(配置文件配置destroy-method或者添加注解@PreDestory),则执行定义的销毁方法
参考文章
源码补充:
Spring中bean的生命周期
AbstractAutowireCapableBeanFactory的doCreateBean方法是创建bean的开始
(1)首先我们要实例化bean,createBeanInstance方法就是采用反射机制生成实例对象。

if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

(2)接着需要给实例化的bean设置属性值,populateBean方法就是给属性赋值，如果注入过程中发现有要注入的对象还没有生成，就会先去生产要注入的对象

if (earlySingletonExposure) {
	if (logger.isTraceEnabled()) {
		logger.trace("Eagerly caching bean '" + beanName +
				"' to allow for resolving potential circular references");
	}
	//加入到三级缓存中
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// Initialize the bean instance.
Object exposedObject = bean;
try {
	//给bean设置属性值
	populateBean(beanName, mbd, instanceWrapper);
	//初始化bean
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}

(3)就是对bean进行初始化,调用initializeBean方法

(3.1)initializeBean方法中会先去调用Aware接口的方法invokeAwareMethods,如果bean实现了BeanNameAware,BeanClassLoaderAware,BeanFactoryAware接口的话，会依次调用setBeanName,setBeanClassLoader,setBeanFactory方法;

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 = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

(3.2)接着去调用applyBeanPostProcessorsBeforeInitlization方法，如果发现容器中有类实现了BeanPostProcessor接口,就会执行postProcessBeforeInitlization方法。(如果加载A类到Spring容器，A类也实现了BeanPostProcessor接口，不会调用A类的就会执行postProcessBeforeInitialization方法,因为A类未加载完成,还未完全放到singletonObjects一级缓存中)

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {
		
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

需要注意的是ApplicationContextAwareProcessor也实现了BeanPostProcessor接口，并重写了postProcessBeforeInitlization方法，方法里面调用了invokeAwareInterfaces方法，invokeAwareInterfaces方法也写着如果实现了众多的Aware接口，依次调用相应的方法，值得注意的是ApplicationContextAware接口

private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof EnvironmentAware) {
        ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
    }

    if (bean instanceof EmbeddedValueResolverAware) {
        ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
    }

    if (bean instanceof ResourceLoaderAware) {
        ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
    }

    if (bean instanceof ApplicationEventPublisherAware) {
        ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
    }

    if (bean instanceof MessageSourceAware) {
        ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
    }

    if (bean instanceof ApplicationStartupAware) {
        ((ApplicationStartupAware)bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
    }

    if (bean instanceof ApplicationContextAware) {
        ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
    }

}

(3.3)接着调用invokeInitMethods方法，发现如果实现了InitlizingBean接口，则会调用afterPropertiesSet方法；最后还会判断是否指定了init-method方法，如果指定了会调用自己定义的初始化方法

boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
	if (logger.isTraceEnabled()) {
		logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
	}
	if (System.getSecurityManager() != null) {
		try {
			AccessController.doPrivileged((PrivilegedExceptionAction

4.Spring面试题

Java相关栏目本月热门文章