Spring面试题总结

摘抄一些面试题

Spring是什么？

Spring是一个轻量级的Ioc（控制反转）和Aop（面向切面编程）容器框架。是为Java程序提供基础性服务的一套框架，目的是简化企业应用程序的开发，使得开发者更专注与业务需求。常见的配置方式有三种：1、基于xml配置文件的配置。2、基于注解的配置。3、基于Java的配置。
主要有以下模块组成：
Spring Core:核心类库，提供IOC服务。
Spring Context:提供框架式的Bean访问方式，以及企业级功能（定时任务、JNDI等）
Spring AOP:AOP服务
Spring DAO:对jdbc的抽象，简化了数据访问异常的处理。
Spring ORM:对先有的ORM框架的支持
Spring Web：提供了基本的面向web的综合特征，例如文件上传等。
Spring MVC：提供面向web应用的Model-view-controller实现。

Spring的优点

1、Spring属于低侵入式设计，代码的污染极低。
2、Spring的DI（依赖注入）机制，使得对象之间的依赖关系交由框架处理，降低组件之间的耦合度
3、Spring提供了AOP技术，支持将一些通用任务，如安全，日志，事务，权限等集中管理，从而更好的复用
4、Spring对主流的应用框架提供了支持

SpringAOP

OOP，面向对象编程，允许开发者定义纵向的关系，但不适用与定于横向的关系，导致了大量代码的重复，不利于各个模块的重用。
AOP，面向切面编程，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被称为切面（Aspect），减少系统中的重复代码，降低了代码间的耦合度，同时提高了系统的可维护性。可用于权限认证，事务，日志处理等。
AOP实现的关键在于动态代理，主要分为静态代理与动态代理。静态代理的代表为AspectJ，动态代理则以SpringAOP为代表。
1、AspectJ是静态代理的增强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也成为编译时增强，他会在编译时将切面织入到Java字节码中，运行时就是增强后的AOP对象。
2、SpringAOP使用的是动态代理，所谓动态代理就是说AOP框架不会去修改字节码，而是在每次运行时，在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象那个的全部方法，并且在特定的切点做增强处理，并回调原对象的方法。
3、静态代理与动态代理的区别在于生成AOP代理对象的时机不同，相对来说静态代理AspectJ有更好的性能，但是AspectJ需要特定的编译器来进行处理，而SpringAOP无需特定的编译器处理。

SpringIOC

• IOC就是控制反转，是指创建对象时控制权的转移，之前创建对象的时间和控制权是由用户自己控制的，现在把这种控制交由Spring容器中，并由容器根据配置文件去创建实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用。DI依赖注入，和控制反转是一个概念的不同描述，即应用程序在运行时依赖IOC容器来动态注入对象所需要的外部资源。
• IOC让对象不用去new了，可以由Spring自动生成，使用Java的反射机制，根据配置文件在运行时动态的创建对象以及管理对象，并调用对象的方法。
• Spring IOC有三种注入方式：setter注入，构造器注入，根据注解注入
• IOC使相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。

BeanFactory和ApplicationContext有什么区别

BeanFactory和ApplicationContext是Spring的量大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。
1、Beanfactory，是Spring里面最底层的接口，包含了各种bean的定义，读取bean的配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系，ApplicationContext作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能。

• 继承messageSource，因此支持国际化。
• 统一的资源文件访问方式。
• 提供在监听器中注册bean的事件。
• 同时加载多个配置文件。
• 载入多个（有继承关系）上下文，使得每一个上下文都专注与一个特定的层次，如应用的web层。
  2、
• BeanFactory采用的是延迟加载形式来注册bean的，即只有在使用到某个bean（调用getBean()）时，才对该bean进行加载实例化。这样我们就不能发现一些存在的Spring的配置问题。如果bean的某个属性没有注入，Beanfactory加载后，直到第一次调用getBean()时才抛出异常。
• ApplicationContext，它是在容器启动时，一次性创建所有的Bean。这样在容器启动时，就可以发现Spring中存在的配置错误，这样有助于检查所依赖属性是否注入。ApplicationContext启动后预载入所有的单实例bean，通过预载入单实例bean，确保在需要的时候就不需要等待，因为已经创建好了。
• 相对于beanfactory，ApplicationContext唯一的不足是占用内存空间，当应用程序配置bean较多时，程序启动较慢。
  3、Beanfactory通常以编程的方式被创建，ApplicationContext还能以声明的方式进行创建，如使用ContextLoader。
  4、Beanfactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，ApplicationContext自动注册。

请解释Spring bean的生命周期

首先说一下Servlet的生命周期：实例化，初始init，接受请求service,销毁destroy。
Spring上下文的Bean生命周期也类似，如下：
（1）实例化bean
对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。
（2）设置对象属性（依赖注入）
实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息以及BeanWrapper提供的设置属性的接口完成依赖注入。
（3）处理Aware接口
Spring会检测该对象是否实现了XXXAware接口，并将相关的XXXAware实例注入给bean。

• 如果这个bean实现了BeanNameAware接口，会调用它实现的setBeanName(String beanid)方法，此处传递的就是Spring配置文件中bean的id值。
• 如果这个Bean实现了BeanFactoryAware接口，会调用它实现的SetBeanFactory()方法，传递的是Spring工厂自身。
• 如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文。

（4）beanPostProcessor:
如果想对Bean进行一些自定义的处理，那么可以让bean实现BeanPostProcessor接口，将会调用postProcessBeforeInitialization(Object obj,String s)方法，由于这个方法是在Bean初始化结束时调用的，所以可以被用于内存或缓存技术。
（5）InitializingBean与init-method：
如果Bean在Spring配置文件中配置了init-method属性，则会自动调用其配置的初始化方法。
（6）如果这个Bean实现了BeanPostProcessor接口，将会调用postprocessbeforeInitialization(Object obj,String s)方法
完后上面方法后Bean就被正确创建了，之后就可以使用这个bean了。
（7）DisposableBean
当bean不需要时，会经过清理阶段，如果bean实现了disposableBean接口，会调用其实现的destory()方法。
（8）destory-method
最后，如果这个bean的Spring配置中配置了destory-method属性，会自动调用其配置的销毁方法。

解释Spring支持的几种bean的作用域

Spring容器中的bean可以分为5个范围

• singleton:默认，每个容器只有一个bean的实例，单例的模式由beanFactory自身来维护。
• prototype:为每一个bean请求提供一个实例。
• request:为每一个网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。
• session:与request范围类似，确保每一个session中只有一个bean的实例，session过期后，bean被垃圾回收器回收。
• global-session:全局作用域，gloabal-session和Protlet应用相关，当你的应用部署在protlet容器中工作时，它包含很多protlet。如果想要声明让所有的protlet共用全局的存储变量的话，那么这个全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

Spring框架中的单例Beans是线程安全的吗？

Spring框架中并没有对单例bean进行任何多线程的封装处理，关于单例bean的线程安全和并发问题需要开发者自行去搞定，但实际上，大部分的Spring bean并没有可变的状态（比如Serview和DAO类），所以某种程度上说Spring的单例bean是线程安全的，如果你的bean有多种状态的话(比如View Model对象)，就要自行保证线程安全，最浅显的解决办法是将多态bean的作用域由singleton变为prototype。

Spring如何处理线程并发问题

在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分bean都可以声明为singleton作用域，因为Spring对一些bean中非线程安全状态采用Threadlocal进行处理，解决线程安全问题。
Threadlocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式，仅提供一份变量，不同的线程在访问前需要获得锁，没获得锁的线程则需要排队，而Threadlocal采用了“空间换时间”的方式。
Threadlocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突，因为每一个线程都有自己的变量副本，从而也就没有必要对该变量进行同步了。Threadlocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进threadlocal中。

Spring基于xml的注入bean的方式

https://blog.youkuaiyun.com/lyt_7cs1dn9/article/details/65631479
（1）Set方法注入
最简单的注入方式，假设有一个SpringAction，类中需要实例化一个SpringDao对象，那么久可以定义一个private的SpringDao成员变量，然后创建SpringDao的set方法：

package com.bless.springdemo.action; 
public class SpringAction { 
    //注入对象springDao 
    private SpringDao springDao; 
    //一定要写被注入对象的set方法 
    public void setSpringDao(SpringDao springDao) { 
    this.springDao = springDao; 
} 

public void ok(){ 
    springDao.ok(); 
} 
}

然后编写spring的xml文件，中的name属性是class属性的一个别名，class属性指类的全名。

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(1)依赖注入,配置当前类中相应的属性--> 
<property name="springDao" ref="springDao"></property> 
</bean> 
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

（2）构造器注入：通过index设置参数的位置，通过type设置参数的类型
这种方式的注入是指带有参数的构造函数注入，看例，创建了两个成员变量SpringDao和User，但未设置相应的set方法，所以不能set方法注入，这里的注入方式是在SpringAction的构造函数中注入，也就是说在创建SpringAction对象时，需要把SpringDao和User两个参数值传递进来。

public class SpringAction { 
    //注入对象springDao 
    private SpringDao springDao; 
    private User user; 

    public SpringAction(SpringDao springDao,User user){ 
   		this.springDao = springDao; 
   	 	this.user = user; 
    System.out.println("构造方法调用springDao和user"); 
} 

public void save(){ 
    user.setName("卡卡"); 
    springDao.save(user); 
} 
} 

在xml文件中同样不用的形式，而是使用标签，ref属性同样指向其他标签的name属性。

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置--> 
<constructor-arg ref="springDao"></constructor-arg> 
<constructor-arg ref="user"></constructor-arg> 
</bean> 
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean> 
<bean name="user" class="com.bless.springdemo.vo.User"></bean> 

解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的为了分清哪个该赋对应的值，则需要进行一些小处理

<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<constructor-arg index="0" ref="springDao"></constructor-arg> 
<constructor-arg index="1" ref="user"></constructor-arg> 
</bean> 

index就是参数的位置。
另一种是设置参数的类型

<constructor-arg type="java.lang.String" ref=""/>

（3）静态工厂注入
静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让Spring管理所有的对象，我们不能直接通过“工程类.静态方法（）”来获取对象，而是依然通过Spring注入的形式获取。

package com.bless.springdemo.factory; 

import com.bless.springdemo.dao.FactoryDao; 
import com.bless.springdemo.dao.impl.FactoryDaoImpl; 
import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl; 

public class DaoFactory { 
//静态工厂 
public static final FactoryDao getStaticFactoryDaoImpl(){ 
    return new StaticFacotryDaoImpl(); 
    } 
}

同样看关键类，这里需要注入一个FactoryDao对象，看起来跟set注入一样，但其实不同：

public class SpringAction { 
//注入对象 
private FactoryDao staticFactoryDao; 

public void staticFactoryOk(){ 
    staticFactoryDao.saveFactory(); 
} 
//注入对象的set方法 
public void setStaticFactoryDao(FactoryDao staticFactoryDao) { 
    this.staticFactoryDao = staticFactoryDao; 
} 
} 

Spring的IOC配置文件，注意看指向的class并不是FactoryDao的实现类，而是指向静态工厂DaoFactory，并配置factory-method=“getStaticfactoryDaoImpl”，指定调用哪个工厂方法。

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction" > 
<!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)--> 
<property name="staticFactoryDao" ref="staticFactoryDao"></property> 
</bean> 
<!--(3)此处获取对象的方式是从工厂类中获取静态方法--> 
<bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean> 

（4）实例工厂
实例工厂的意思是获取对象实例的方法不是静态的，所以首先需要new工厂类，再调用普通的实例方法。

public class DaoFactory { 
//实例工厂 
public FactoryDao getFactoryDaoImpl(){ 
    return new FactoryDaoImpl(); 
} 
}

通过实例工厂创建FactoryDao对象。

public class SpringAction { 
//注入对象 
private FactoryDao factoryDao; 

public void factoryOk(){ 
    factoryDao.saveFactory(); 
} 

public void setFactoryDao(FactoryDao factoryDao) { 
    this.factoryDao = factoryDao; 
    } 
} 

Spring文件

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)--> 
<property name="factoryDao" ref="factoryDao"></property> 
</bean> 


<!--(4)此处获取对象的方式是从工厂类中获取实例方法--> 
<bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean> 
<bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean> 

Spring的自动装配

在Spring中，对象无需自己查找或创建与其关联的其他对象，由容器负责把需要相互协作的对象引用赋予各个对象，使用autowire来配置自动装载模式。
1、no：默认的方式是不进行自动装配的，通过手工设置ref属性来进行装配bean。
2、byName:通过bean的名称进行自动装配，如果一个bean的property的name与另一个bean的name相同，就进行自动装配。
3、byType:通过参数的数据类型进行自动装配。
4、constructor:利用构造函数进行装配，并且构造函数的参数通过byType进行装配。
5、autodetect:自动探测，如果有构造方法，通过constructor进行装配，否则使用byType的方式自动装配。

解释一下SpringAOP中的几个名词

• 切面（Aspect）:被抽取的公共模块，可能会横切多个对象，在SpringAOP中，切面可以使用通用类（基于模式的风格）或者在普通类上以@Aspect注解来实现。
• 连接点（join point）：指方法，在SpringAOP中，一个连接点总是代表一个发放的执行。
• 通知（Advice）:在切面的某个特定的连接点（Join point）上执行的动作。通知有各种类型，其中包括around、before、after等通知。
• 切入点（Pointcut）:切入点是指我们要对那些连接点进行拦截的定义，通过切入点表达式，制定拦截的方法，比如制定拦截的add*，search*等方法。
• 引入（Introduction）:声明额外的方法或者某个类型的字段。
• 目标对象（target Object）:被一个或者多个切面所通知的对象，也有人把他叫做被通知对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理的对象
• 织入（Weaving）:指把增强应用到目标对象来创建新的代理对象的过程。Spring是在运行时完成织入。

Spring事务

https://www.cnblogs.com/ysocean/p/7617620.html
事务：一般是指要做的或者所做的事情，在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元。事务是一系列的动作，综合在一起才是一个完整的工作单元，这些动作要么全部完成，如果有一个失败的话，事务就会回滚到最开始的位置。用来保证数据的一致性和完整性。
事务的四个特性：
1、原子性：事务是一个原子操作，由一系列动作完成，要么全部成功，要么不起作用。
2、一致性：一旦事务完成（不管成功还是失败），系统必须保证它所建模的业务处于一致的状态，而不是部分完成部分失败，在现实中的数据不应该被破坏。
3、隔离性：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开，防止数据破坏。
4、持久性：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响。这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。
Spring编程式事务和声明式事务的区别
编程式事务：是指通过编程的方式实现事务，允许用户在代码中精确的定义事务的边界。即类似与JDBC编程实现事务管理。
声明式事务：建立在AOP之上，其本质是对方法前后进行拦截，在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的有点就是不需要通过编程的方式实现事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需要在配置文件中做相关的事务规则声明（或者使用@Transactional注解）。
简单的说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理，而声明式事务由于基于AOP，所以既能起到事务管理的作用，又可以不影响业务代码的具体实现。

只是摘抄了一部分，详细内容可以自行查找。
http://ifeve.com/spring-interview-questions-and-answers/
https://blog.youkuaiyun.com/a745233700/article/details/80959716