Spring知识--面试

最新推荐文章于 2024-02-16 20:36:23 发布

Vincilovefang

最新推荐文章于 2024-02-16 20:36:23 发布

阅读量285

点赞数

分类专栏：学习笔记

本文链接：https://blog.csdn.net/Vincilovefang/article/details/108295647

版权

学习笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1、 Spring的IOC和AOP机制

我们是在使用Spring框架的过程中，其实就是为了使用IOC和AOP，这两个是Spring的灵魂。
主要用到的设计模式有工厂模式和代理模式。

IOC就是典型的工厂模式，通过BeanFactory去注入实例。
AOP就是典型的代理模式。代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
spring的IoC容器是spring的核心，spring AOP是spring框架的重要组成部分。
在传统的程序设计中，当调用者需要被调用者协助时，通常由调用者来创建被调用者的实例。但在spring里创建被调用者的工作不再由调用者来完成，创建被调用者实例的工作通常由spring容器完成，然后注入调用者，被称为依赖注入
面向方面编程(AOP)是以另一个角度来考虑程序结构，通过分析程序结构的关注点来完善面向对象编程 (OOP)。OOP将应用程序分解成各个层次的对象，而AOP将程序分解成多个切面。spring AOP 只实现了方法级别的连接点，在J2EE应用中，AOP拦截到方法级别的操作就已经足够。在spring中，未来使 IoC方便地使用健壮、灵活的企业服务，需要利用spring AOP实现为IoC和企业服务之间建立联系。
IOC:控制反转也叫依赖注入。利用了工厂模式将对象交给容器管理，你只需要在spring配置文件总配置相应的bean，以及设置相关的属性，让 spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类(假设这个类名是A)，分配的方法就是调用A的setter方法来注入，而不需要你在 A里面new这些bean了。
注意:面试的时候，如果有条件，画图，这样更加显得你懂了.
spring ioc初始化流程

AOP:面向切面编程。(Aspect-Oriented Programming) AOP可以说是对OOP的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。将程序中的交叉业务逻辑(比如安全，日志，事务等)，封装成一个切面，然后注入到目标对象(具体业务逻辑)中去。
实现AOP的技术，主要分为两大类:一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行;二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码.
简单点解释，比方说你想在你的biz层所有类中都加上一个打印‘你好’的功能,这时就可以用aop思想来做. 你先写个类写个类方法，方法经实现打印‘你好’,然后Ioc这个类 ref=“biz.*”让每个类都注入即可实现。

2、 Spring中Autowired和Resource关键字的区别

@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。
1、共同点
两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。
2、不同点
(1)@Autowired
@Autowired为Spring提供的注解，需要导入包 org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

	public class TestServiceImpl {
		// 下面两种@Autowired只要使用一种即可 
		@Autowired
		private UserDao userDao; // 用于字段上
		
		@Autowired
		public void setUserDao(UserDao userDao) { 
		// 用于属性的方法上 
		this.userDao = userDao;
		} 
	}

@Autowired注解是按照类型(byType)装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称(byName)来装配，可以结合@Qualifier注解一起使用。如下:

	public class TestServiceImpl {
	    @Autowired
	    @Qualifier("userDao")
	    private UserDao userDao;
	}

(2)@Resource
@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。 @Resource有两个重要的属性:name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。

	public class TestServiceImpl {
		// 下面两种@Resource只要使用一种即可 
		@Resource(name="userDao")
		private UserDao userDao; // 用于字段上

		@Resource(name="userDao")
		public void setUserDao(UserDao userDao) { 
		// 用于属性的setter方法上
        this.userDao = userDao;
    }

注:最好是将@Resource放在setter方法上，因为这样更符合面向对象的思想，通过set、get去操作属性，而不是直接去操作属性。
@Resource装配顺序:

如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异
常。
如果指定了name，则从上下文中查找名称(id)匹配的bean进行装配，找不到则抛出异常。
如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配;如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。
@Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入。

3、依赖注入的方式有几种，各是什么?

一、构造器注入
将被依赖对象通过构造函数的参数注入给依赖对象，并且在初始化对象的时候注入。
- 优点:
  对象初始化完成后便可获得可使用的对象。
- 缺点:
  当需要注入的对象很多时，构造器参数列表将会很长;
  不够灵活。若有多种注入方式，每种方式只需注入指定几个依赖，那么就需要提供多个重载的构造函数，麻烦。
二、setter方法注入
IoC Service Provider通过调用成员变量提供的setter函数将被依赖对象注入给依赖类。
- 优点:
  灵活。可以选择性地注入需要的对象。
- 缺点:
  依赖对象初始化完成后由于尚未注入被依赖对象，因此还不能使用。
三、接口注入
依赖类必须要实现指定的接口，然后实现该接口中的一个函数，该函数就是用于依赖注入。该函数的参数就是要注入的对象。
- 优点
  接口注入中，接口的名字、函数的名字都不重要，只要保证函数的参数是要注入的对象类型即可。
- 缺点:
  侵入行太强，不建议使用。
  PS:什么是侵入行? 如果类A要使用别人提供的一个功能，若为了使用这功能，需要在自己的类中增加额外的代码，这就是侵入性

4、讲一下什么是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实现。

5、Spring MVC流程

1、用户发送请求至前端控制器DispatcherServlet。
2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4、 DispatcherServlet调用HandlerAdapter处理器适配器。
5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6、 Controller执行完成返回ModelAndView。
7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。 8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9、 ViewReslover解析后返回具体View。
10、DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)。
11、 DispatcherServlet响应用户。
组件说明:
以下组件通常使用框架提供实现:
DispatcherServlet:作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。
HandlerMapping:通过扩展处理器映射器实现不同的映射方式，例如:配置文件方式，实现接口方式，注解方式等。
HandlAdapter:通过扩展处理器适配器，支持更多类型的处理器。 ViewResolver:通过扩展视图解析器，支持更多类型的视图解析，例如:jsp、freemarker、pdf、
excel等。
组件:
1、前端控制器DispatcherServlet(不需要工程师开发),由框架提供作用:接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。
2、处理器映射器HandlerMapping(不需要工程师开发),由框架提供作用:根据请求的url查找Handler HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如:配置文件方式，实现接口方式，注解方式等。
3、处理器适配器HandlerAdapter 作用:按照特定规则(HandlerAdapter要求的规则)去执行Handler 通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
4、处理器Handler(需要工程师开发) 注意:编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。
5、视图解析器View resolver(不需要工程师开发),由框架提供作用:进行视图解析，根据逻辑视图名解析成真正的视图(view)
View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括:jstlView、freemarkerView、pdfView等。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。
6、视图View(需要工程师开发jsp…) View是一个接口，实现类支持不同的View类型(jsp、freemarker、pdf…)
核心架构的具体流程步骤如下:
1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制;
2、DispatcherServlet——>HandlerMapping， HandlerMapping 将会把请求映射为 HandlerExecutionChain 对象(包含一个Handler 处理器(页面控制器)对象、多个 HandlerInterceptor 拦截器)对象，通过这种策略模式，很容易添加新的映射策略;
3、DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器; 4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理;并返回一个ModelAndView 对象(包含模型数据、逻辑视图名);
5、ModelAndView的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的 View，通过这种策略模式，很容易更换其他视图技术;
6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术; 7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
下边两个组件通常情况下需要开发: Handler:处理器，即后端控制器用controller表示。 View:视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。
在讲SpringMVC之前我们先来看一下什么是MVC模式 MVC:MVC是一种设计模式
MVC的原理图:
springMVC是什么:
springMVC是一个MVC的开源框架，springMVC=struts2+spring，springMVC就相当于是Struts2 加上sring的整合，但是这里有一个疑惑就是，springMVC和spring是什么样的关系呢?这个在百度百科上有一个很好的解释:意思是说，springMVC是spring的一个后续产品，其实就是spring在原有基础上，又提供了web应用的MVC模块，可以简单的把springMVC理解为是spring的一个模块(类似AOP， IOC这样的模块)，网络上经常会说springMVC和spring无缝集成，其实springMVC就是spring的一个子模块，所以根本不需要同spring进行整合。
看到这个图大家可能会有很多的疑惑，现在我们来看一下这个图的步骤:(可以对比MVC的原理图进行理解)
第一步:用户发起请求到前端控制器(DispatcherServlet) 第二步:前端控制器请求处理器映射器(HandlerMappering)去查找处理器(Handle):通过xml配
置或者注解进行查找第三步:找到以后处理器映射器(HandlerMappering)像前端控制器返回执行链
(HandlerExecutionChain) 第四步:前端控制器(DispatcherServlet)调用处理器适配器(HandlerAdapter)去执行处理器
(Handler)
第五步:处理器适配器去执行Handler
第六步:Handler执行完给处理器适配器返回ModelAndView
第七步:处理器适配器向前端控制器返回ModelAndView
第八步:前端控制器请求视图解析器(ViewResolver)去进行视图解析
第九步:视图解析器像前端控制器返回View
第十步:前端控制器对视图进行渲染
第十一步:前端控制器向用户响应结果
看到这些步骤我相信大家很感觉非常的乱，这是正常的，但是这里主要是要大家理解springMVC中的几个组件:
前端控制器(DispatcherServlet):接收请求，响应结果，相当于电脑的CPU。处理器映射器(HandlerMapping):根据URL去查找处理器处理器(Handler):(需要程序员去写代码处理逻辑的)
处理器适配器(HandlerAdapter):会把处理器包装成适配器，这样就可以支持多种类型的处理器，类比笔记本的适配器(适配器模式的应用)
视图解析器(ViewResovler):进行视图解析，多返回的字符串，进行处理，可以解析成对应的页面

6、SpringMVC怎么样设定重定向和转发的?

(1)转发:在返回值前面加"forward:"，譬如"forward:user.do?name=method4" (2)重定向:在返回值前面加"redirect:"，譬如"redirect:http://www.baidu.com"

7、 SpringMVC常用的注解有哪些?

@RequestMapping:用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所
有响应请求的方法都是以该地址作为父路径。 @RequestBody:注解实现接收http请求的json数据，将json转换为java对象。 @ResponseBody:注解实现将conreoller方法返回对象转化为json对象响应给客户。

8、 Spring的AOP理解: OOP面向对象，允许开发者定义纵向的关系，但并适用于定义横向的关系，导致了大量代码的重复，而

不利于各个模块的重用。
AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。
AOP实现的关键在于代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ; 动态代理则以Spring AOP为代表。

(1)AspectJ是静态代理的增强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的 AOP对象。
(2)Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理:
- 1.JDK动态代理只提供接口的代理，不支持类的代理。核心InvocationHandler接口和Proxy类， InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起;接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
- 2.如果代理类没有实现 InvocationHandler 接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB(Code Generation Library)，是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。
(3)静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。
9、Spring的IOC理解
(1)IOC就是控制反转，是指创建对象的控制权的转移，以前创建对象的主动权和时机是由自己把控的，而现在这种权力转移到Spring容器中，并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用。DI依赖注入，和控制反转是同一个概念的不同角度的描述，即应用程序在运行时依赖IoC容器来动态注入对象需要的外部资源。
(2)最直观的表达就是，IOC让对象的创建不用去new了，可以由spring自动生产，使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的。
(3)Spring的IOC有三种注入方式 :构造器注入、setter方法注入、根据注解注入。 IoC让相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成
可重用的功能组件。

10、解释一下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:
1如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值;
2如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。
3如果这个Bean已经实现了ApplicationContextAware接口，会调用 setApplicationContext(ApplicationContext)方法，传入Spring上下文;
(4)BeanPostProcessor: 如果想对Bean进行一些自定义的处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用
postProcessBeforeInitialization(Object obj, String s)方法。
(5)InitializingBean 与 init-method:
如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。
(6)如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法;由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术;

以上几个步骤完成后，Bean就已经被正确创建了，之后就可以使用这个Bean了。

(7)DisposableBean:
当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的 destroy()方法;
(8)destroy-method: 最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

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

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

12、 Spring基于xml注入bean的几种方式:

(1)Set方法注入; (2)构造器注入:1通过index设置参数的位置;2通过type设置参数类型; (3)静态工厂注入;
(4)实例工厂; 详细内容可以阅读:https://blog.csdn.net/a745233700/article/details/89307518

13、Spring框架中都用到了哪些设计模式?

(1)工厂模式:BeanFactory就是简单工厂模式的体现，用来创建对象的实例;
(2)单例模式:Bean默认为单例模式。
(3)代理模式:Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术;
(4)模板方法:用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
(5)观察者模式:定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。

Vincilovefang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring知识--面试

1、 Spring的IOC和AOP机制我们是在使用Spring框架的过程中，其实就是为了使用IOC和AOP，这两个是Spring的灵魂。主要用到的设计模式有工厂模式和代理模式。 IOC就是典型的工厂模式，通过BeanFactory去注入实例。AOP就是典型的代理模式。代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关
复制链接

扫一扫