Java高频重点面试题，看这一篇就够了。

一、基础篇

1. ==和equals区别？

1）对于==，比较的是值是否相等
如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
如果作用于引用类型的变量，则比较的是所指向的对象的地址

2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，所有类从Object类中继承equals方法，比较的是是否是同一个对象
　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
　　　　
也就是说:
equals本身和==没有区别，对于基本数据都是比较值，对于对象都是比较是否为内存地址，其他类在继承Object类之后对equals方法重写，所以String、Date等类比较里面的内容。

        Integer i1 = 130;
        Integer i2 = 130;

        System.out.println(i1 == i2);
        i1 = 13;
        i2 = 13;
        System.out.println(i1 == i2);

false
true

2. spring 有哪些主要模块？

1.Spring Core：Spring框架的核心模块，他提供了Spring框架的基本功能，例如提供 ioc 和依赖注入特性。
这个模块中最主要的一个组件为BeanFactory,它使用工厂模式来创建所需的对象。
同时BeanFactory使用IOC思想，通过读取XML文件的方式来实例化对象，可以说BeanFactory提供了组件生命周期的管理，组件的创建，装配以及销毁等功能;

2.Spring AOP：采用了面向切面编程的思想，使Spring框架管理的对象支持AOP，同时这个模块也提供了事务管理，可以不依赖具体的EJB组件，就可以将事务管理集成到应用程序中;

3.Spring Web MVC：提供了一个构建Web应用程序的MVC的实现

4.Spring Web：提供了Servlet监听器的Context和Web应用的上下文。同时还集成了一些现有的Web框架，例如Struts;

5.Spring Context：扩展核心容器，提供了Spring上下文环境，给开发人员提供了很多非常有用的服务，例如国际化,Email和JNDI访问等；

6.Spring ORM：提供了对现有的ORM框架的支持，例如Hibernate等；

7.Spring DAO：提供了对DAO（Data Access Object,数据访问对象）模式和JDBC的支持。
DAO可以实现将业务逻辑与数据库访问的代码分离，从而降低代码的耦合度。
通过对JDBC的抽象，简化了开发工作，同时简化了对异常的处理(可以很好的处理不同数据库厂商抛出的异常);

*E0E2-FA50-0312-52D4 DF79-48B8-8B10-3AAC BADA-ECB0-421C-EC3B 856C-6AC2-610E-8FE9

3. Spring中bean的生命周期

3.1 Spring Bean的生命周期指的是从一个普通的Java类变成Bean的过程

总体的创建过程

以注解类变成Spring Bean为例，

1. Spring会扫描指定包下面的Java类，然后将其变成beanDefinition对象
2. 然后Spring会根据beanDefinition来创建bean。

beanDefinition

上图就是beanDefinition所包含的内容，看到这些属性如果对Spring有所了解都应该知道几个，

1. 如lazyInit懒加载，在Spring中有一个@Lazy注解，用来标识其这个bean是否为懒加载的，
2. scope属性，相应的也有@scope注解来标识这个bean其作用域，是单例还是多例，
3. beanClass属性，在对象实例化时，会根据beanClass来创建对象、
4. 又比如autowireMode注入模型这个属性，这个属性用于记录使用怎样的注入模型，注入模型常用的有根据名称和根据类型、不注入三种注入模型。

总之大家要记住Spring会根据beanDefinition来完成bean的创建

3.2 为什么不直接使用对象的class对象来创建bean呢？

因为在class对象仅仅能描述一个对象的创建，它不足以用来描述一个Spring bean，而对于是否为懒加载、是否是首要的、初始化方法是哪个、销毁方法是哪个，这个Spring中特有的属性在class对象中并没有，所有Spring就定义了beanDefinition来完成bean的创建。

3.3 java类 -> beanDefinition对象

所以说如果要说Bean的生命周期，你不能不说Java类是在那一步变成beanDefinition的，我们先来看一下Spring中AbstractApplicationContext类中的refresh方法，这个方法就可以总结上面的图。

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			准备工作包括设置启动时间，是否激活标识位，
			// 初始化属性源(property source)配置
			prepareRefresh();
 
			// Tell the subclass to refresh the internal bean factory.
			//返回一个factory 为什么需要返回一个工厂
			//因为要对工厂进行初始化
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
			// Prepare the bean factory for use in this context.
			//准备工厂
			prepareBeanFactory(beanFactory);
 
			try {
				// Allows post-processing of the bean factory in context subclasses.
				//这个方法在当前版本的spring是没用任何代码的
				//可能spring期待在后面的版本中去扩展吧
				postProcessBeanFactory(beanFactory);
 
				// Invoke factory processors registered as beans in the context.
				//在spring的环境中去执行已经被注册的 factory processors
				//设置执行自定义的ProcessBeanFactory 和spring内部自己定义的
				invokeBeanFactoryPostProcessors(beanFactory);
 
				// Register bean processors that intercept bean creation.
				//注册beanPostProcessor
				registerBeanPostProcessors(beanFactory);
 
				// Initialize message source for this context.
				initMessageSource();
 
				// Initialize event multicaster for this context.
				//初始化应用事件广播器
				initApplicationEventMulticaster();
 
				// Initialize other special beans in specific context subclasses.
				onRefresh();
 
				// Check for listener beans and register them.
				registerListeners();
 
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);
 
				// Last step: publish corresponding event.
				finishRefresh();
			}
 
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
 
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();
 
				// Reset 'active' flag.
				cancelRefresh(ex);
 
				// Propagate exception to caller.
				throw ex;
			}
 
			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

有关Spring Bean生命周期最主要的方法有三个

1. invokeBeanFactoryPostProcessors、
2. registerBeanPostProcessors
3. finishBeanFactoryInitialization。

其中invokeBeanFactoryPostProcessors方法会执行BeanFactoryPostProcessors后置处理器及其子接口BeanDefinitionRegistryPostProcessor，
执行顺序先是

1. 执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法，
2. 然后执行BeanFactoryPostProcessor接口的postProcessBeanFactory方法。

对于BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法，
该步骤会扫描到指定包下面的标有注解的类，然后将其变成BeanDefinition对象，然后放到一个Spring中的Map中，用于下面创建Spring bean的时候使用这个BeanDefinition

其中registerBeanPostProcessors方法根据实现了PriorityOrdered、Ordered接口，排序后注册所有的BeanPostProcessor后置处理器，主要用于Spring Bean创建时，执行这些后置处理器的方法，这也是Spring中提供的扩展点，让我们能够插手Spring bean创建过程。

3.4 beanDefinition对象 -> Spring中的bean

finishBeanFactoryInitialization是完成非懒加载的Spring bean的创建的工作，你要想说Spring的生命周期，不要整其他没用的，直接告诉他在该步骤中会有8个后置处理的方法4个后置处理器的类贯穿在对象的实例化、赋值、初始化、和销毁的过程中，这4个后置处理器出现的地方分别为：

关于每个后置处理的作用如下：

首先看一下继承关系，InstantiationAwareBeanPostProcessor、SmartInstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor直接或间接的继承BeanPostProcessor，而SmartInitializingSingleton则是单独的一个接口。

一、InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor接口继承BeanPostProcessor接口，它内部提供了3个方法，再加上BeanPostProcessor接口内部的2个方法，所以实现这个接口需要实现5个方法。InstantiationAwareBeanPostProcessor接口的主要作用在于目标对象的实例化过程中需要处理的事情，包括实例化对象的前后过程以及实例的属性设置

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()方法的Object bean = resolveBeforeInstantiation(beanName, mbdToUse);方法里面执行了这个后置处理器

二、SmartInstantiationAwareBeanPostProcessor
智能实例化Bean后置处理器（继承InstantiationAwareBeanPostProcessor）

三、MergedBeanDefinitionPostProcessor

四、SmartInitializingSingleton
智能初始化Singleton，该接口只有一个方法，是在所有的非懒加载单实例bean都成功创建并且放到Spring IOC容器之后进行执行的。

下面按照图中的顺序进行说明每个后置处理的作用：

1、InstantiationAwareBeanPostProcessor# postProcessBeforeInstantiation

在目标对象实例化之前调用，方法的返回值类型是Object，我们可以返回任何类型的值。
由于这个时候目标对象还未实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例(一般都是代理对象)。
如果该方法的返回值代替原本该生成的目标对象，后续只有postProcessAfterInitialization方法会调用，其它方法不再调用；否则按照正常的流程走

2、SmartInstantiationAwareBeanPostProcessor# determineCandidateConstructors

检测Bean的构造器，可以检测出多个候选构造器

3、MergedBeanDefinitionPostProcessor# postProcessMergedBeanDefinition

缓存bean的注入信息的后置处理器，仅仅是缓存或者干脆叫做查找更加合适，没有完成注入，注入是另外一个后置处理器的作用

4、SmartInstantiationAwareBeanPostProcessor# getEarlyBeanReference

循环引用的后置处理器，这个东西比较复杂， 获得提前暴露的bean引用。主要用于解决循环引用的问题，只有单例对象才会调用此方法，以后如果有时间，我会写一篇关于Spring是怎么处理循环依赖的，会将这个，现在你就只需要知道他能提前暴露bean就行了。

5、InstantiationAwareBeanPostProcessor# postProcessAfterInstantiation

方法在目标对象实例化之后调用，这个时候对象已经被实例化，但是该实例的属性还未被设置，都是null。如果该方法返回false，会忽略属性值的设置；如果返回true，会按照正常流程设置属性值。方法不管postProcessBeforeInstantiation方法的返回值是什么都会执行

6、InstantiationAwareBeanPostProcessor# postProcessPropertie

方法对属性值进行修改(这个时候属性值还未被设置，但是我们可以修改原本该设置进去的属性值)。如果postProcessAfterInstantiation方法返回false，该方法不会被调用。可以在该方法内完成对属性的自动注入（注意：在Spring5.1之前，完成属性自动注入的方法是postProcessPropertyValues方法，在5.1就开始使用postProcessPropertie方法了，如果发现不同也不必惊慌，就是改了一下方法名，内部逻辑一样的）（在这一步，会完成标注了@Autowired、@Resource注解的自动装配，如果有兴趣的同学可以看一下：Spring源码分析@Autowired、@Resource注解的区别，是从源码角度分析他们之间装配的不同，不过需要一点Spring的功底）

调用invokeInitMethods方法

private void invokeAwareMethods(final String beanName, final 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);
			}
		}
	}

该方法就是查看这个bean是否实现应该的Aware接口，如果实现了，则调用相应的接口。

7.BeanPostProcessor# postProcessBeforeInitialization

该方法会在初始化之前进行执行，其中有一个实现类比较重要ApplicationContextAwareProcessor，该后置处理的一个作用就是当应用程序定义的Bean实现ApplicationContextAware接口时注入ApplicationContext对象：

class ApplicationContextAwareProcessor implements BeanPostProcessor {
 
	private final ConfigurableApplicationContext applicationContext;
 
	private final StringValueResolver embeddedValueResolver;
 
 
	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}
 
 
	@Override
	@Nullable
	public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;
 
		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}
 
		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction