【面试篇】Spring的那些面试题(上)

Spring面试专题

1.介绍下你对Spring的理解

  Java程序员其实就是Spring程序员。足见Spring框架对Java程序员的影响力了。

1.1 Spring的发展历程

先介绍Spring是怎么来的，发展中有哪些核心的节点，当前的最新版本是什么等

通过上图可以比较清晰的看到Spring的各个时间版本对应的时间节点了。也就是Spring从之前单纯的xml的配置方式，到现在的完全基于注解的编程方式发展。

1.2 Spring的组成

  Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于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实现。

1.3 Spring的好处

2.介绍下你对IOC的理解

  IOC（Inversion of Control 即控制反转）将对象交给Spring容器管理.

和传统使用方式的对比

  spring中提供了一种IOC容器，来控制对象的创建，无论是你创建对象，处理对象之间的依赖关系，对象的创建时间还是对象的创建数量，都是spring提供IOC容器上配置对象的信息就可以了。

IoC容器管理对象的好处：

1. 由IOC容器帮对象找相应的依赖思想并注入，并不是由对象主动去找
2. 资源集中管理，实现资源的可配置和易管理
3. 降低了使用资源双方的依赖程度，松耦合
4. 解决了Dao和Service的强耦合。

3.介绍下你对AOP的理解

  AOP是Spring中另一个非常重要的核心。AOP【Aspect Oriented Programming】面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

  AOP的常用应用场景有哪些：

  AOP可以拦截指定的方法，并且对方法增强，比如：事务、日志、权限、性能监测等增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离。

  AOP涉及到的术语：

  通知的类型：

  实现方式：

1.基于Schema来实现的

2.基于aspectJ实现(配置/注解)

  切入点表达式

AOP的代理方式：

  在Spring里可以把一个类型注册成Spring里的一个Bean，这时候Spring就会帮我们把这个Bean初始化，变成一个可用的对象。加入我们需要在上面做一些增强，就是我们所谓的AOP。这时候我们就需要在中间加一层代理类或者增强类。

• JdkProxy：假如说这个对象所在的类上面有接口（基于接口来做的），Spring会默认使用JdkProxy（JDK的动态代理），来生成一个代理，在代理里进一步的把所有对这个类做的增强操作，放到代理执行的代码里面。然后先做了增强的操作，再去调用原本的类的他的方法。
• proxyTargetClass：如果要代理的类有接口但想强制不用默认JDK的动态代理，也是用字节码增强的技术，就可以开启proxyTargetClass选项。同CGlib。
• CGlib：假如说要增强或代理的这个类没有接口，只有一个类的定义，Spring会默认使用CGlib，对他做字节码增强。相当于硬生生的给他生成一个子类。在这个子类里，当我们调用原先这个类的某个方法时，先做增强操作，再去调原本类的方法，最后再把结果返回回来。

4.介绍下Spring中的事务处理

  数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。 事务处理可以确保除非事务性单元内的所有操作都成功完成，否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元，可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务，必须满足所谓的ACID（原子性、一致性、隔离性和持久性）属性。事务是数据库运行中的逻辑工作单位，由DBMS中的事务管理子系统负责事务的处理。

• 原子性（Atomicity）：一个事务是一个不可分割的工作单位，事务中包括的动作要么都做要么都不做。
• 一致性（Consistency）：事务必须保证数据库从一个一致性状态变到另一个一致性状态，一致性和原子性是密切相关的。
• 隔离性（Isolation）：一个事务的执行不能被其它事务干扰，即一个事务内部的操作及使用的数据对并发的其它事务是隔离的，并发执行的各个事务之间不能互相打扰。
• 持久性（Durability）：持久性也称为永久性，指一个事务一旦提交，它对数据库中数据的改变就是永久性的，后面的其它操作和故障都不应该对其有任何影响。

在Spring中事务的实现的两种方式：

1. 基于XML声明式事务
2. 基于注解的使用

事务的传播行为：

ServiceA {   
     void methodA() {
         ServiceB.methodB();
     }
}

1
2
3
4
5
6

ServiceB { 
     void methodB() {
     }  
}

1
2
3
4
5

有个问题：如果methodA()方法中调用了 this.b()这时b方法中的事务会生效吗?

AopContext.currentProxy();

具体的声明案例

@Transactional(propagation=Propagation.REQUIRED)
如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)
@Transactional(propagation=Propagation.NOT_SUPPORTED)
容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY)
必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER)
必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS)
如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.

1
2
3
4
5
6
7
8
9
10
11
12
13

事务的隔离级别

  事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度，当多个事务同时访问相同数据时，如果没有采取必要的隔离机制，就可能发生以下问题：

Spring中支持的隔离级别

5.介绍下Bean的生命周期

  Spring的核心IoC就是管理Bean对象的生命周期，那么Bean的生命周期具体是怎么样的呢？

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1. Bean自身的方法：这个包括了Bean本身调用的方法和通过配置文件中的init-method和destroy-method指定的方法
2. Bean级生命周期接口方法：这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
3. 容器级生命周期接口方法：这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。
4. 工厂后处理器接口方法：这个包括了AspectJWeavingEnabler,ConfigurationClassPostProcessor,CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

生命周期简单说明：

1. Spring容器 从XML 文件中读取bean的定义，并实例化bean。
2. Spring根据bean的定义填充所有的属性。Spring根据bean的定义填充所有的属性。如果bean实现了BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
3. 如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
   如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
4. 如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
5. 如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
6. 如果bean实现了 DisposableBean，它将调用destroy()方法。

https://blog.csdn.net/qq_38526573/article/details/88143169

6.介绍下Spring用到的设计模式

6.1 单例模式

  单例模式应该是大家印象最深的一种设计模式了。在Spring中最明显的使用场景是在配置文件中配置注册bean对象的时候设置scope的值为singleton 。

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean class="com.dpb.pojo.User" id="user" scope="singleton">
		<property name="name" value="波波烤鸭">property>
	bean>
beans>

1
2
3
4
5
6
7
8
9
10

6.2 原型模式

  原型模式也叫克隆模式，Spring中该模式使用的很明显，和单例一样在bean标签中设置scope的属性prototype即表示该bean以克隆的方式生成

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean class="com.dpb.pojo.User" id="user" scope="prototype">
		<property name="name" value="波波烤鸭">property>
	bean>
beans>

1
2
3
4
5
6
7
8
9
10

6.3 模板模式

  模板模式的核心是父类定义好流程，然后将流程中需要子类实现的方法就抽象话留给子类实现，Spring中的JdbcTemplate就是这样的实现。我们知道jdbc的步骤是固定

• 加载驱动,
• 获取连接通道,
• 构建sql语句.
• 执行sql语句,
• 关闭资源

在这些步骤中第3步和第四步是不确定的,所以就留给客户实现，而我们实际使用JdbcTemplate的时候也确实是只需要构建SQL就可以了.这就是典型的模板模式。我们以query方法为例来看下JdbcTemplate中的代码.

6.4 观察者模式

  观察者模式定义的是对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。使用比较场景是在监听器中而spring中Observer模式常用的地方也是listener的实现。如ApplicationListener.

6.5 工厂模式

简单工厂模式：

  简单工厂模式就是通过工厂根据传递进来的参数决定产生哪个对象。Spring中我们通过getBean方法获取对象的时候根据id或者name获取就是简单工厂模式了。

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<context:annotation-config/>
	<bean class="com.dpb.pojo.User" id="user"  >
		<property name="name" value="波波烤鸭">property>
	bean>
beans>

1
2
3
4
5
6
7
8
9
10
11
12
13

工厂方法模式：

  在Spring中我们一般是将Bean的实例化直接交给容器去管理的，实现了使用和创建的分离，这时容器直接管理对象，还有种情况是，bean的创建过程我们交给一个工厂去实现，而Spring容器管理这个工厂。这个就是我们讲的工厂模式，在Spring中有两种实现一种是静态工厂方法模式，一种是动态工厂方法模式。以静态工厂来演示

/**
 * User 工厂类
 * @author dpb[波波烤鸭]
 *
 */
public class UserFactory {

	/**
	 * 必须是static方法
	 * @return
	 */
	public static UserBean getInstance(){
		return new UserBean();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

application.xml文件中注册

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<bean class="com.dpb.factory.UserFactory" factory-method="getInstance" id="user2"/>
beans>

1
2
3
4
5
6
7
8

6.6 适配器模式

  将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。这就是适配器模式。在Spring中在AOP实现中的Advice和interceptor之间的转换就是通过适配器模式实现的。

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		// 通知类型匹配对应的拦截器
		return new MethodBeforeAdviceInterceptor(advice);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6.7 装饰者模式

  装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。
  spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。
  具体的使用在Spring session框架中的SessionRepositoryRequestWrapper使用包装模式对原生的request的功能进行增强，可以将session中的数据和分布式数据库进行同步，这样即使当前tomcat崩溃，session中的数据也不会丢失。

<dependency>
	<groupId>org.springframework.sessiongroupId>
	<artifactId>spring-sessionartifactId>
	<version>1.3.1.RELEASEversion>
dependency>

1
2
3
4
5
6

6.8 代理模式

  代理模式应该是大家非常熟悉的设计模式了，在Spring中AOP的实现中代理模式使用的很彻底.

6.9 策略模式

  策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法，spring中在实例化对象的时候用到Strategy模式。XmlBeanDefinitionReader,PropertiesBeanDefinitionReader

6.10 责任链默认

AOP中的拦截器链

6.11 委托者模式

DelegatingFilterProxy，整合Shiro，SpringSecurity的时候都有用到。

…

7.Spring中常用的注解有哪些

举例说明：@RestController @Import @EnableXXX @Indexd。。。。