Java Spring面试题解析发布时间：2024-02-27

1.Spring MVC工作流程？【重点】

用户发送请求至前端控制器DispatcherServlet；
DispatcherServlet收到请求调用HandlerMapping处理器映射器；
处理器映射器根据请求URL找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet；
DispatcherServlet通过HandlerAdapter处理器适配器调用处理器；
执行处理器（Controller，也叫后端控制器）；
Controller执行完成返回ModelAndView；
HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet；
DispatcherServlet将ModelAndView传给ViewReslover视图解析器；
ViewReslover解析后返回具体View；
DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）；
DispatcherServlet响应用户。

2.Spring中Bean Factory与AplicationContext有什么区别？【重点】

Bean Factory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的生命周期；
ApplicationContext除了提供上述Bean Factory所能提供的功能之外，还提供了更完整的框架功能。

3.Spring IOC注入的几种方式？【重点】

根据注入依赖对象的类型分类：
基本类型对象的注入；
注入其他Bean。
注入依赖对象的方式：
构造器注入；
属性Setter方法注入；
工厂注入（不常用）。
注入依赖对象的编程方式：
手动装配
XML方式；
注解方式。
自动装配

4.请说明filter和inteceptor的区别？【重点】

Filter基于Filter接口中的doFilter回调函数，Interceptor则基于Java本身的反射机制；
Filter是依赖于Servlet的，没有Servlet就无法回调doFilter方法，而Interceptor与Servlet无关；
Filter的过滤范围比Interceptor大，Filter除了过滤请求外通过通配符可以保护页面、图片、文件等，而Interceptor只能过滤Handler；
Filter是在请求进入Tomcat等容器后，Servlet处理之前进行调用的；Interceptor是在请求进入Servlet后，执行Handler之前进行调用的；
Filter是随着Tomcat等Web容器启动时而进行初始化；Interceptor时随着Spring启动而进行初始化。

5.AOP有哪些实现方式？【重点】

实现AOP的技术，主要分为两大类：
静态代理：指使用AOP框架提供的命令进行编译，从而在编译阶段就可生成AOP代理类，因此也称为编译时增强；
编译时编织（特殊编译器实现）；
类加载时编织（特殊的类加载器实现）。
动态代理- 在运行时在内存中“临时”生成AOP动态代理类，因此也被称为运行时增强。
JDK动态代理、CGLIB。

6.使用Spring 框架的好处是什么?【重点】

简化开发、解耦、集成其它框架；
低侵入式设计，代码污染级别低；
Spring的IOC机制降低了业务对象替换的复杂性，提高了软件之间的解耦性；
Spring AOP支持将一些通用的任务进行集中式的管理，例如：安全、事务、日志等，从而使代码能更好的复用。

7.解释Spring支持的几种Bean的作用域？【了解】

当通过Spring 容器创建一个Bean实例的时候，不仅可以完成Bean实例的实例化，还可以为Bean指定作用域。Spring Bean元素的支持以下5 种作用域：
Singleton：单例模式，在整个Spring IOC容器中，使用Singleton定义的Bean将只有一个实例。
Prototype：多例模式，每次通过容器中的getBean方法获取prototype定义的Beans时，都会产生一个新的Bean的实例。
Request：对于每次Http请求，使用Request定义的Bean都会产生一个新的实例，只有在Web应用时候，该作用域才会有效。
Session：对于每次Http Session，使用Session定义的Bean都将产生一个新的实例。
Globalsession：每个全局的Http Sesisonn，使用Session定义的Bean都将产生一个新的实例。

8.在Spring中如何注入一个Java集合？【了解】

Set集合的注入：
<bean id="testBean" class="com.spring.domain.TestBean">
   <property name="sets">
       <set>
           <value>set1</value>
           <value>set2</value>
       </set>
   </property>
</bean>
List集合的注入：
<bean id="testBean" class="com.spring.domain.TestBean">
   <property name="lists">
       <list>
           <value>list1</value>
           <value>list2</value>
       </list>
   </property>
</bean>
Map集合的注入：
<bean id="testBean" class="com.spring.domain.TestBean">
   <property name="maps">
       <map>
           <entry key="map1" value="map1"/>
           <entry key="map2" value="map2"/>
       </map>
   </property>
</bean>
Properties集合的注入：
<bean id="testBean" class="com.spring.domain.TestBean">
   <property name="props">
       <props>
           <prop key="prop1">prop1</prop>
           <prop key="prop2">prop2</prop>
       </props>
   </property>
</bean>

9.什么是Spring bean？【了解】

它们是构成用户应用程序主干的对象；
Bean由Spring IoC容器管理；
它们由Spring IoC容器实例化，配置，装配和管理；
Bean是基于用户提供给容器的元数据创建。

10.什么是Spring自动装配?【了解】

就是将一个Bean 注入到其它的Bean的Property中，默认情况下，容器不会自动装配，需要我们手动设定。
Spring可以通过向Bean Factory中注入的方式来搞定Bean之间的依赖关系，达到自动装配的目的。
自动装配建议少用，如果要使用建议使用ByName。

11.如何使用自动装配注入依赖对象?【重点】

示例代码：<bean id="…" class="…" autowire="…">，autowire属性的取值如下：
byType：按类型装配，可以根据属性的类型，在容器中寻找跟该类型匹配的bean，如果发现多个，那么将会抛出异常。如果没有找到，即属性值为null；
byName：按名称装配，可以根据属性的名称，在容器中寻找跟该属性名称相同的bean，如果没有找到，即属性值为null；
constructor：与buType类似，不同之处在于它应用与构造器注入，如果在容器中没有找到与构造器参数类型一致的bean，那么会抛出异常；
no：不自动装配。
default：默认值，同no配置。

12.自动装配有什么局限？【了解】

覆盖的可能性：您始终可以使用<constructor-arg>和<property>设置指定依赖项，这将覆盖自动装配；
基本元数据类型：简单属性（如原数据类型，字符串和类）无法自动装配；
令人困惑的性质：总是喜欢使用明确的装配，因为自动装配不太精确。

13.Spring的重要注解？【重点】

@Controller：用于Spring MVC 项目中的控制器类。
@Service：用于服务类。
@RequestMapping：用于在控制器处理程序方法中配置URI 映射。
@ResponseBody：用于发送Object 作为响应，通常用于发送XML 或JSON 数据作为响应。
@RequestBody：用于接收JSON 格式数据参数。
@PathVariable：用于将动态值从URI 映射到处理程序方法参数。
@Autowired：用于在Spring Bean中自动装配依赖项。
@Qualifier：使用@Autowired 注解，以避免在存在多个bean 类型实例时出现混淆。
@Scope：用于配置spring bean 的范围。
@Configuration、@ComponentScan和@Bean：用于基于Java的配置。
@Aspect、@Before、@After、@AfterTrowing、@AfterReturning、@Around、@Pointcut：用于切面编程。

14. Spring MVC常用注解？【重点】

@Controller：写在控制器上作用和@component一样。

@RequestMapping：用于处理请求URL映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。

@RequestBody：注解实现接收http请求的Json数据，将Json转换为Java对象。

@ResponseBody：注解实现将conreoller方法返回对象转化为Json对象响应给客户。

@RestController：相当于@Controller+@ResponseBody

@PathVariable：用于将动态值从URL映射到处理程序方法参数。

@RequestParam：用于设置Hanlder的参数映射。

15. Spring @Resource和@Autowired有什么区别？【重点】

@Autowired与@Resource都可以用来装配Bean，都可以写在字段上，或写在setter方法上；

@Autowired默认按类型注入，按名称注入需要与@Qualifier("对象名")连用；

@Resource同时支持按类型和按名称注入，默认按名称注入，如果找不到就按类型注入；

@Autowired是Spring提供的注解，@Resource是Java EE提供的。

16. @Component, @Controller, @Repository, @Service 有何区别？【掌握】

@Component：这将Java类标记为bean，它是任何Spring管理组件的通用构造型，Spring的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。

@Controller：这将一个类标记为Spring Web MVC 控制器。标有它的Bean会自动导入到IOC容器中。

@Service：此注解是组件注解的特化，它不会对@Component注解提供任何其他行为，您可以在服务层类中使用@Service而不是@Component，因为它以更好的方式指定了意图。

@Repository：这个注解是具有类似用途和功能的@Component注解的特化，它为DAO提供了额外的好处，它将DAO导入IOC容器，并使未经检查的异常有资格转换为SpringDataAccessException。

17. 列举Spring支持的事务管理类型？【了解】

Spring 支持两种类型的事务管理：

程序化事务管理：在此过程中，在编程的帮助下管理事务。它为您提供极大的灵活性，但维护起来非常困难。

声明式事务管理：在此，事务管理与业务代码分离。仅使用注解或基于XML的配置来管理事务。

18. Spring框架的事务管理有哪些优点？【了解】

它为不同的事务API（如JTA、JDBC、Hibernate、JPA和JDO）提供了统一的编程模型。

它为编程式事务管理提供了一个简单的API而非一系列复杂的事务API（如JTA）。

它支持声明式事务管理。

它可以和Spring的多种数据访问技术很好的融合。

19. Spring AOP（面向切面）编程的原理？【重点】

AOP面向切面编程，它是一种思想。它就是针对业务处理过程中的切面进行提取，以达到优化代码的目的，减少重复代码的目的。就比如，在编写业务逻辑代码的时候，我们习惯性的都要写：日志记录，事务控制，以及权限控制等，每一个子模块都要写这些代码，代码明显存在重复。这时候，我们运用面向切面的编程思想，采用横切技术，将代码中重复的部分，不影响主业务逻辑的部分抽取出来，放在某个地方进行集中式的管理，调用。形成日志切面，事务控制切面，权限控制切面。这样，我们就只需要关心业务的逻辑处理，即提高了工作的效率，又使得代码变的简洁优雅。这就是面向切面的编程思想，它是面向对象编程思想的一种扩展。

AOP的使用场景：缓存、权限管理、内容传递、错误处理、懒加载、记录跟踪、优化、校准、调试、持久化、资源池、同步管理、事务控制等。

AOP的相关概念：切面（Aspect）、连接点(JoinPoint) 、通知（Advice）、切入点（Pointcut）代理（Proxy）：织入（Weaving）。

Spring AOP的编程原理？代理机制JDK的动态代理：只能用于实现了接口的类产生代理。Cglib代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强技术，生成当前类的子类对象。

20. Spring MVC框架有什么用？【重点】

Spring Web MVC框架提供模型-视图-控制器架构和随时可用的组件，用于开发灵活且松散耦合的Web 应用程序。MVC模式有助于分离应用程序的不同方面，如输入逻辑，业务逻辑和UI逻辑，同时在所有这些元素之间提供松散耦合。

21. 什么是控制反转（IOC），什么是依赖注入（DI）？【重点】

IOC：就是对象之间的依赖关系由容器来创建，对象之间的关系本来是由我们开发者自己创建和维护的，在我们使用Spring框架后，对象之间的关系由容器来创建和维护，将开发者做的事让容器做，这就是控制反转。BeanFactory接口是Spring IOC容器的核心接口。

DI：我们在使用Spring容器的时候，容器通过调用set方法或者是构造器来建立对象之间的依赖关系。控制反转是目标，依赖注入是我们实现控制反转的一种手段。

22. Spring运行原理？【重点】

内部最核心的就是IOC，之前是使用new关键字创建对象，现在可以直接从容器中获取，动态注入，这其实就是利用Java里的反射。反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，根据Spring核心配置文件（XML）来动态的创建对象，和调用对象里的方法。

Spring另一个核心就是AOP面向切面编程，可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的。

Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置内部通过反射去动态的组装对象）；要记住，Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能。

Spring里用的最经典设计模式：模板方法模式；核心容器组件是BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

23. Spring中事务的传播特性？【了解】

REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。

NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务，如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。

REQUEIRESNEW：不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有的事务会被挂起，新的事务会被创建，直到方法执行结束，新的事务才算结束，原先的事务才会被恢复执行。

NANDATORY：业务方法只能在一个已经存在的事务中执行，业务方法不能自己发起事务，如果业务方法没有在事务环境下被调用，容器会抛出例外。

SUPPORTS：如果业务方法在某个事务范围中被调用，则方法称为该事务的一部分，如果业务方法在事务范围外被调用，则方法在没有事务环境下执行。

Never：业务方法绝对不会在事务范围内执行，如果业务方法在某一个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。

NESTED：如果一个活动的事务存在，则运行在一个嵌套事务中，如果没有活动事务，则按REQUIRED属性执行，它使用了一个单独的事务，这个事务拥有多个可回滚的保存点。内部事务的回滚不会影响到外部事务。它只对DataSourceTransactionManager事务管理器生效。

24. Spring MVC怎么样设定重定向和转发的？【掌握】

转发：在返回值前面加“forward:”前缀，比如：forward:/user?name=1。

重定向：在返回值前面加“redirect:”前缀，比如：redirect:/user。

25. Spring MVC的优点？【重点】

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面，是一个强大灵活的Web框架。

Spring MVC提供了一个DispatcherServlet作为前端控制器来分配请求。通过策略接口，Spring框架是高度可配置的。

Spring MVC通过一套注解，让JavaBean成为处理请求的控制器，而无需实现任何接口。

Spring MVC还包含多种视图技术，如 Java Server Pages（JSP）、Velocity、Tiles、iText和POI等。

Spring MVC支持Rest风格的URL请求。

Spring MVC分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

Spring MVC框架主要由DispatcherServlet、处理器映射器、处理器适配器、处理器、视图解析器、视图组成。

26. Spring MVC的主要组件？【重点】

前端控制器（DispatcherServlet）作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet就减少了其它组件之间的耦合度。

处理器映射器（HandlerMapping）作用：根据请求的URL来查找Handler（控制器）。

处理器适配器（HandlerAdapter）作用：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器才可以正确的去执行Handler。

处理器（Handler）作用：处理请求、调用业务代码、返回ModelAndView对象。

视图解析器（ViewResolver）作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）。

视图（View）作用：View是一个接口，它的实现类支持不同的视图类型（JSP、Freemarke等）。

27. Spring MVC如何得到从前台传入的参数？【掌握】

直接在形参里面声明参数，必须名字和传过来的参数一样。

使用@RequestParam注解的方式获取，注意设置的别名需要与表单元素的名称一致。

使用POJO对象绑定请求参数值，注意对象中属性与表单元素的名称一致。

使用@PathVariable注解与URL路径中“{占位符}”进行绑定。

使用Servlet原生API进行获取QueryString中指定名称的参数。

28. 在Controller中如何获取原生Servlet API的内置对象？【掌握】

使用Controller中方法声明形式参数：

@Controller
public class TestController {
@RequestMapping("/test")
public void test(HttpServletRequest request) {
//代码略
}
}

使用Controller中的成员属性依赖注入：
@Controller
public class TestController{
@Autowired
private HttpServletRequest request; //自动注入request
@RequestMapping("/test")
public void test(){
//代码略
}
}
使用基类中的成员属性依赖注入：
public class BaseController {
@Autowired
protected HttpServletRequest request;
}
@Controller
public class TestController extends BaseController {
@RequestMapping("/test")
public void test(){
//代码略
}
}
在Controller中的方法中手动注入：
@Controller
public class TestController {
@RequestMapping("/test")
public void test() {
       HttpServletRequest request = ((ServletRequestAttributes)
       (RequestContextHolder.currentRequestAttributes())).getRequest();

       //代码略
}
}

29. 如何在Web项目中配置Spring MVC？【掌握】

修改web.xml，配置Spring主控Servlet：

<servlet>
   <servlet-name>spring-mvc</servlet-name>
   <servlet-class>
       org.springframework.web.servlet.DispatcherServlet
   </servlet-class>
   <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
   <servlet-name>spring-mvc</servlet-name>
   <url-pattern>/</url-pattern>
</servlet-mapping>
编写Spring_mvc配置文件：

<!—
   扫描包，将标注Spring注解的类自动转化为Bean,同时完成Bean的注入
-->
<context:component-scan base-package="org.spring.controller"/>
<!—
   配置视图解析器：如何把handler方法返回值解析成实际物理视图
-->
<bean    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   <property name="prefix" value="/WEB-INF/views/"></property>
   <property name="suffix" value=".jsp"></property>
</bean>

<mvc:annotation-driven/>