关于spring:Spring面试题

Spring 是个 java 企业级利用的开源开发框架。Spring 次要用来开发 Java 利用，然而有些扩大是针对构建 J2EE 平台的 web 利用。Spring 框架指标是简化 Java 企业级利用开发，并通过 POJO 为根底的编程模型促成良好的编程习惯。

轻量：Spring 是轻量的，根本的版本大概 2MB。

管制反转：Spring 通过管制反转实现了涣散耦合，对象们给出它们的依赖，而不是创立或查找依赖的对象们。

面向切面的编程(AOP)：Spring 反对面向切面的编程，并且把利用业务逻辑和零碎服务离开。

容器：Spring 蕴含并治理利用中对象的生命周期和配置。

MVC 框架：Spring 的 WEB 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。

事务管理：Spring 提供一个继续的事务管理接口，能够扩大到上至本地事务下至全局事务（JTA）。

异样解决：Spring 提供方便的 API 把具体技术相干的异样（比方由 JDBC，Hibernate or JDO 抛出的）转化为统一的 unchecked 异样。

以下是 Spring 框架的根本模块：
Core module
Bean module
Context module
Expression Language module
JDBC module
ORM module
OXM module
Java Messaging Service(JMS) module
Transaction module
Web module
Web-Servlet module
Web-Struts module
Web-Portlet module

这是根本的 Spring 模块，提供 spring 框架的根底性能，BeanFactory 是任何以 spring 为根底的利用的外围。Spring 框架建设在此模块之上，它使 Spring 成为一个容器。

BeanFactory 是工厂模式的一个实现，提供了管制反转性能，用来把利用的配置和依赖从真正的利用代码中拆散。最罕用的 BeanFactory 实现是 XmlBeanFactory 类。

最罕用的就是 org.springframework.beans.factory.xml.XmlBeanFactory，它依据 XML 文件中的定义加载 beans。该容器从 XML 文件读取配置元数据并用它去创立一个齐全配置的零碎或利用。

AOP 模块用于给咱们的 Spring 利用做面向切面的开发，很多反对由 AOP 联盟提供，这样就确保了 Spring 和其余 AOP 框架的共通性。这个模块将元数据编程引入 Spring。

通过应用 JDBC 形象和 DAO 模块，保障数据库代码的简洁，并能防止数据库资源谬误敞开导致的问题，它在各种不同的数据库的错误信息之上，提供了一个对立的异样拜访层。它还利用 Spring 的 AOP 模块给 Spring 利用中的对象提供事务管理服务。

Spring 通过提供 ORM 模块，反对咱们在间接 JDBC 之上应用一个对象 / 关系映射映射 (ORM) 工具，Spring 反对集成支流的 ORM 框架，如 Hiberate,JDO 和 iBATIS SQL Maps。Spring 的事务管理同样反对以上所有 ORM 框架及 JDBC。

Spring 的 WEB 模块是构建在 application context 模块根底之上，提供一个适宜 web 利用的上下文。这个模块也包含反对多种面向 web 的工作，如通明地解决多个文件上传申请和程序级申请参数的绑定到你的业务对象。它也有对 Jakarta Struts 的反对。

Spring 配置文件是个 XML 文件，这个文件蕴含了类信息，形容了如何配置它们，以及如何互相调用。

Spring IOC 负责创建对象，治理对象（通过依赖注入（DI），拆卸对象，配置对象，并且治理这些对象的整个生命周期。

IOC 或依赖注入把利用的代码量降到最低。它使利用容易测试，单元测试不再须要单例和 JNDI 查找机制。最小的代价和最小的侵入性使涣散耦合得以实现。IOC 容器反对加载服务时的饿汉式初始化和懒加载。

FileSystemXmlApplicationContext：此容器从一个 XML 文件中加载 beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。

ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你须要正确设置 classpath 因为这个容器将在 classpath 里找 bean 配置。

WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 WEB 利用的所有 bean。

BeanFactory 是 Spring 外面最底层的接口, 是 Ioc 的外围, 定义了 Ioc 的基本功能, 蕴含了各种 Bean 的定义、加载、实例化, 依赖注入和生命周期治理。

ApplicationContext 接口作为 BeanFactory 的子类, 除了提供 BeanFactory 所具备的性能外, 还提供了更残缺的框架性能:

①继承 MessageSource, 因而反对国际化

②资源文件拜访，如 URL 和文件（ResourceLoader）

③载入多个（有继承关系）上下文（及同时加载多个配置文件），使得每一个上下文都专一于一个特定的档次

④提供在监听器中注册 bean 的事件；

二者区别

1.BeanFactroy 采纳的是提早加载模式来注入 Bean 的，即只有在应用到某个 Bean 时(调用 getBean())，才对该 Bean 进行加载实例化，这样，咱们就不能发现一些存在的 Spring 的配置问题。而 ApplicationContext 则相同，它是在容器启动时，一次性创立了所有的 Bean。这样，在容器启动时，咱们就能够发现 Spring 中存在的配置谬误。绝对于根本的 BeanFactory，ApplicationContext 惟一的有余是占用内存空间。当应用程序配置 Bean 较多时，程序启动较慢。

BeanFacotry 提早加载, 如果 Bean 的某一个属性没有注入，BeanFacotry 加载后，直至第一次应用调用 getBean 办法才会抛出异样；而 ApplicationContext 则在初始化本身是测验，这样有利于查看所依赖属性是否注入；所以通常状况下咱们抉择应用 ApplicationContext。利用上下文则会在上下文启动后预载入所有的单实例 Bean。通过预载入单实例 bean , 确保当你须要的时候，你就不必期待，因为它们曾经创立好了。

2.BeanFactory 和 ApplicationContext 都反对 BeanPostProcessor、BeanFactoryPostProcessor 的应用，但两者之间的区别是：BeanFactory 须要手动注册，而 ApplicationContext 则是主动注册。（Applicationcontext 比 beanFactory 退出了一些更好应用的性能。而且 beanFactory 的许多性能须要通过编程实现而 Applicationcontext 能够通过配置实现。比方后处理 bean，Applicationcontext 间接配置在配置文件即可而 beanFactory 这要在代码中显示的写进去才能够被容器辨认。）

3.beanFactory 次要是面对与 spring 框架的基础设施，面对 spring 本人。而 Applicationcontex 次要面对与 spring 应用的开发者。根本都会应用 Applicationcontex 并非 beanFactory

· 一个定义了一些性能的接口。

· 这实现包含属性，它的 Setter，getter 办法和函数等。

· Spring AOP。

· Spring 的 XML 配置文件。

· 应用以上性能的客户端程序。

依赖注入，是 IOC 的一个方面，是个通常的概念，它有多种解释。这概念是说你不必创建对象，而只须要形容它如何被创立。你不在代码里间接组装你的组件和服务，然而要在配置文件里形容哪些组件须要哪些服务，之后一个容器（IOC 容器）负责把他们组装起来。

结构器依赖注入：结构器依赖注入通过容器触发一个类的结构器来实现的，该类有一系列参数，每个参数代表一个对其余类的依赖。

Setter 办法注入：Setter 办法注入是容器通过调用无参结构器或无参 static 工厂办法实例化 bean 之后，调用该 bean 的 setter 办法，即实现了基于 setter 的依赖注入。

注解注入

你两种依赖形式都能够应用，结构器注入和 Setter 办法注入。最好的解决方案是用结构器参数实现强制依赖，setter 办法实现可选依赖。

Spring beans 是那些造成 Spring 利用的骨干的 java 对象。它们被 Spring IOC 容器初始化，拆卸，和治理。这些 beans 通过容器中配置的元数据创立。比方，以 XML 文件中 <bean/> 的模式定义。

Spring 框架定义的 beans 都是单件 beans。在 bean tag 中有个属性”singleton”，如果它被赋为 TRUE，bean 就是单件，否则就是一个 prototype bean。默认是 TRUE，所以所有在 Spring 框架中的 beans 缺省都是单件。

一个 Spring Bean 的定义蕴含容器必知的所有配置元数据，包含如何创立一个 bean，它的生命周期详情及它的依赖。

这里有三种重要的办法给 Spring 容器提供配置元数据。

· XML 配置文件。

· 基于注解的配置。

· 基于 java 的配置。

当定义一个 <bean> 在 Spring 里，咱们还能给这个 bean 申明一个作用域。它能够通过 bean 定义中的 scope 属性来定义。如，当 Spring 要在须要的时候每次生产一个新的 bean 实例，bean 的 scope 属性被指定为 prototype。另一方面，一个 bean 每次应用的时候必须返回同一个实例，这个 bean 的 scope 属性必须设为 singleton。

Spring 框架反对以下五种 bean 的作用域：

· singleton : bean 在每个 Spring ioc 容器中只有一个实例。

· prototype：一个 bean 的定义能够有多个实例。

· request：每次 http 申请都会创立一个 bean，该作用域仅在基于 web 的 Spring ApplicationContext 情景下无效。

· session：在一个 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web 的 Spring ApplicationContext 情景下无效。

· global-session：在一个全局的 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web 的 Spring ApplicationContext 情景下无效。
缺省的 Spring bean 的作用域是 Singleton.

不，Spring 框架中的单例 bean 不是线程平安的。

· Spring 容器从 XML 文件中读取 bean 的定义，并实例化 bean。

· Spring 依据 bean 的定义填充所有的属性。

· 如果 bean 实现了 BeanNameAware 接口，Spring 传递 bean 的 ID 到 setBeanName 办法。

· 如果 Bean 实现了 BeanFactoryAware 接口，Spring 传递 beanfactory 给 setBeanFactory 办法。

· 如果有任何与 bean 相关联的 BeanPostProcessors，Spring 会在 postProcesserBeforeInitialization()办法内调用它们。

· 如果 bean 实现 IntializingBean 了，调用它的 afterPropertySet 办法.

· 如果 bean 申明了初始化办法，调用此初始化办法。

· 如果有 BeanPostProcessors 和 bean 关联，这些 bean 的 postProcessAfterInitialization() 办法将被调用。

· 如果 bean 实现了 DisposableBean，它将调用 destroy()办法。

有两个重要的 bean 生命周期办法，第一个是 setup，它是在容器加载 bean 的时候被调用。第二个办法是 teardown 它是在容器卸载类的时候被调用。

The bean 标签有两个重要的属性（init-method 和 destroy-method）。用它们你能够本人定制初始化和登记办法。它们也有相应的注解（@PostConstruct 和 @PreDestroy）。

当一个 bean 仅被用作另一个 bean 的属性时，它能被申明为一个外部 bean，为了定义 inner bean，在 Spring 的基于 XML 的配置元数据中，能够在 <property/> 或 <constructor-arg/> 元素内应用 <bean /> 元素，外部 bean 通常是匿名的，它们的 Scope 个别是 prototype。

Spring 提供以下几种汇合的配置元素：

· <list> 类型用于注入一列值，容许有雷同的值。
· <set> 类型用于注入一组值，不容许有雷同的值。
· <map> 类型用于注入一组键值对，键和值都能够为任意类型。
· <props> 类型用于注入一组键值对，键和值都只能为 String 类型。

拆卸，或 bean 拆卸是指在 Spring 容器中把 bean 组装到一起，前提是容器须要晓得 bean 的依赖关系，如何通过依赖注入来把它们拆卸到一起。

Spring 容器可能主动拆卸相互合作的 bean，这意味着容器不须要 <constructor-arg> 和 <property> 配置，能通过 Bean 工厂主动解决 bean 之间的合作。

有 五种主动拆卸 的形式，能够用来领导 Spring 容器用主动拆卸形式来进行依赖注入。

· no：默认的形式是不进行主动拆卸，通过显式设置 ref 属性来进行拆卸。

· byName：通过参数名主动拆卸，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byname，之后容器试图匹配、拆卸和该 bean 的属性具备雷同名字的 bean。

· byType:：通过参数类型主动拆卸，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byType，之后容器试图匹配、拆卸和该 bean 的属性具备雷同类型的 bean。如果有多个 bean 符合条件，则抛出谬误。

· constructor：这个形式相似于 byType，然而要提供给结构器参数，如果没有确定的带参数的结构器参数类型，将会抛出异样。

· autodetect：首先尝试应用 constructor 来主动拆卸，如果无奈工作，则应用 byType 形式。

主动拆卸的局限性是：

· 重写：你仍需用 <constructor-arg> 和 <property> 配置来定义依赖，意味着总要重写主动拆卸。

· 根本数据类型：你不能主动拆卸简略的属性，如根本数据类型，String 字符串，和类。

· 含糊个性：主动拆卸不如显式拆卸准确，如果有可能，倡议应用显式拆卸。

能够。

基于 Java 的配置，容许你在大量的 Java 注解的帮忙下，进行你的大部分 Spring 配置而非通过 XML 文件。

以 @Configuration 注解为例，它用来标记类能够当做一个 bean 的定义，被 Spring IOC 容器应用。另一个例子是 @Bean 注解，它示意此办法将要返回一个对象，作为一个 bean 注册进 Spring 利用上下文。

绝对于 XML 文件，注解型的配置依赖于通过字节码元数据拆卸组件，而非尖括号的申明。

开发者通过在相应的类，办法或属性上应用注解的形式，间接组件类中进行配置，而不是应用 xml 表述 bean 的拆卸关系。

注解拆卸在默认状况下是不开启的，为了应用注解拆卸，咱们必须在 Spring 配置文件中配置 <context:annotation-config/> 元素。

这个注解表明 bean 的属性必须在配置的时候设置，通过一个 bean 定义的显式的属性值或通过主动拆卸，若 @Required 注解的 bean 属性未被设置，容器将抛出 BeanInitializationException。

@Autowired 注解提供了更细粒度的管制，包含在何处以及如何实现主动拆卸。它的用法和 @Required 一样，润饰 setter 办法、结构器、属性或者具备任意名称和 / 或多个参数的 PN 办法。

当有多个雷同类型的 bean 却只有一个须要主动拆卸时，将 @Qualifier 注解和 @Autowire 注解联合应用以打消这种混同，指定须要拆卸的确切的 bean。

应用 SpringJDBC 框架，资源管理和错误处理的代价都会被加重。所以开发者只需写 statements 和 queries 从数据存取数据，JDBC 也能够在 Spring 框架提供的模板类的帮忙下更无效地被应用，这个模板叫 JdbcTemplate（例子见这里 here）

JdbcTemplate 类提供了很多便当的办法解决诸如把数据库数据转变成根本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。

Spring 对数据拜访对象（DAO）的反对旨在简化它和数据拜访技术如 JDBC，Hibernate or JDO 联合应用。这使咱们能够不便切换长久层。编码时也不必放心会捕捉每种技术特有的异样。

在 Spring 中有两种形式拜访 Hibernate：

管制反转 Hibernate Template 和 Callback。

继承 HibernateDAOSupport 提供一个 AOP 拦截器。

Spring 反对以下 ORM：

Hibernate
iBatis
JPA (Java Persistence API)
TopLink
JDO (Java Data Objects)
OJB

用 Spring 的 SessionFactory 调用 LocalSessionFactory。集成过程分三步：

配置 the Hibernate SessionFactory。

继承 HibernateDaoSupport 实现一个 DAO。

在 AOP 反对的事务中拆卸。

Spring 反对两种类型的事务管理：

· 编程式事务管理：这象征你通过编程的形式治理事务，给你带来极大的灵活性，然而难保护。

· 申明式事务管理：这意味着你能够将业务代码和事务管理拆散，你只需用注解和 XML 配置来治理事务。

· 它为不同的事务 API 如 JTA，JDBC，Hibernate，JPA 和 JDO，提供一个不变的编程模式。

· 它为编程式事务管理提供了一套简略的 API 而不是一些简单的事务 API 如

· 它反对申明式事务管理。

· 它和 Spring 各种数据拜访形象层很好得集成。

大多数 Spring 框架的用户抉择申明式事务管理，因为它对利用代码的影响最小，因而更合乎一个无侵入的轻量级容器的思维。申明式事务管理要优于编程式事务管理，尽管比编程式事务管理（这种形式容许你通过代码管制事务）少了一点灵活性。

面向切面的编程，或 AOP，是一种编程技术，容许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。

AOP 外围就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组 API 提供横切性能。比方，一个日志模块能够被称作日志的 AOP 切面。依据需要的不同，一个应用程序能够有若干切面。在 Spring AOP 中，切面通过带有 @Aspect 注解的类实现。

关注点是利用中一个模块的行为，一个关注点可能会被定义成一个咱们想实现的一个性能。

横切关注点是一个关注点，此关注点是整个利用都会应用的性能，并影响整个利用，比方日志，平安和数据传输，简直利用的每个模块都须要的性能。因而这些都属于横切关注点。

连接点代表一个应用程序的某个地位，在这个地位咱们能够插入一个 AOP 切面，它实际上是个应用程序执行 Spring AOP 的地位。

告诉是个在办法执行前或执行后要做的动作，实际上是程序执行时要通过 SpringAOP 框架触发的代码段。

Spring 切面能够利用五种类型的告诉：

· before：前置告诉，在一个办法执行前被调用。

· after: 在办法执行之后调用的告诉，无论办法执行是否胜利。

· after-returning: 仅当办法胜利实现后执行的告诉。

· after-throwing: 在办法抛出异样退出时执行的告诉。

· around: 在办法执行之前和之后调用的告诉。

切入点是一个或一组连接点，告诉将在这些地位执行。能够通过表达式或匹配的形式指明切入点。

引入容许咱们在已存在的类中减少新的办法和属性。

被一个或者多个切面所告诉的对象。它通常是一个代理对象。也指被告诉（advised）对象。

代理是告诉指标对象后创立的对象。从客户端的角度看，代理对象和指标对象是一样的。

· BeanNameAutoProxyCreator

· DefaultAdvisorAutoProxyCreator

· Metadata autoproxying

织入是将切面和到其余利用类型或对象连接或创立一个被告诉对象的过程。

织入能够在编译时，加载时，或运行时实现。

在这种状况下，切面由惯例类以及基于 XML 的配置实现。

在这种状况下(基于 @AspectJ 的实现)，波及到的切面申明的格调与带有 java5 标注的一般 java 类统一。

Spring 装备构建 Web 利用的全功能 MVC 框架。Spring 能够很便捷地和其余 MVC 框架集成，如 Struts，Spring 的 MVC 框架用管制反转把业务对象和管制逻辑清晰地隔离。它也容许以申明的形式把申请参数和业务对象绑定。

Spring 的 MVC 框架是围绕 DispatcherServlet 来设计的，它用来解决所有的 HTTP 申请和响应。

WebApplicationContext 继承了 ApplicationContext 并减少了一些 WEB 利用必备的特有性能，它不同于个别的 ApplicationContext，因为它能解决主题，并找到被关联的 servlet。

控制器提供一个拜访应用程序的行为，此行为通常通过服务接口实现。控制器解析用户输出并将其转换为一个由视图出现给用户的模型。Spring 用一个十分形象的形式实现了一个管制层，容许用户创立多种用处的控制器。

该注解表明该类表演控制器的角色，Spring 不须要你继承任何其余控制器基类或援用 Servlet API。

该注解是用来映射一个 URL 到一个类或一个特定的方解决法上。

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创立的。Spring 既是一个 AOP 框架，也是一 IOC 容器。

SpringFramework 的组成：Spring AOP，Spring DAO，Spring ORM，Spring Web，Spring Context，Spring Web MVC。

Spring 的外围就是 IOC 和 AOP，所以 Spring 的工作机制简略的了解也就是 IOC 和 AOP 的工作机制。

借助于 Spring AOP，Spring IoC 可能很不便的应用到十分强壮、灵便的企业级服务，通过应用 IoC 可能升高组件之间的耦合度，最终，可能进步类的重用性，利于测试，而且更利于整个产品或系统集成和配置。

· AOP，Aspect Oriented Program，面向 (方面) 切面的编程；

· IOC，Invert Of Control，管制反转。

IOC 就是其实就是依赖注入，即用接口编程，在程序中不呈现 new 关键字，而是用接口来命名援用，而后通过某种形式把接口的某个实现类的实例注入到援用里，从而实现接口与具体实现类的松耦合。

由容器控制程序之间的关系(通过 XML 配置)，而非传统实现中的由程序代码间接操控，(在一个 Class 对象中援用另一个 Class 对象时，咱们通常都是间接通过 new contructor)。控制权由利用代码直达到了内部容器，控制权的转移，是所谓的反转。

AOP 形式很相似 filter，就是在程序失常的业务流两头像切面一样插入很多其余须要执行的代码，比方登录时候，在进入登录页背后写入日志，很罕用的，尤其是跟数据库无关的，或者跟领取无关的程序必定会在每一步后面插入日志。

面向方面的编程，即 AOP，是一种编程技术，它容许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的外围结构是切面，它将那些影响多个类的行为封装到可重用的模块中。

AOP Advice（AOP 告诉）分为：

· 前置告诉

· 后置告诉

· 异样告诉

· 盘绕告诉

申明式事务:

应用 spring 申明式事务，spring 应用 AOP 来反对申明式事务，会依据事务属性，主动在办法调用之前决定是否开启一个事务，并在办法执行之后决定事务提交或回滚事务。

编程式事务管理:

Spring 的编程式事务与申明式事务区别

程式事务须要你在代码中间接退出解决事务的逻辑, 可能须要在代码中显式调用 beginTransaction()、commit()、rollback()等事务管理相干的办法, 如在执行 a 方法时候须要事务处理, 你须要在 a 办法开始时候开启事务, 解决完后。在办法完结时候, 敞开事务.

申明式的事务的做法是在 a 办法外围增加注解或者间接在配置文件中定义,a 办法须要事务处理, 在 spring 中会通过配置文件在 a 办法前后拦挡, 并增加事务.

二者区别：

编程式事务侵入性比拟强，但解决粒度更细.

事务的隔离级别：

数据库系统提供了 4 种事务隔离级别，在这 4 种隔离级别中，Serializable 的隔离级别最高，Read Uncommitted 的隔离级别最低；

· Read Uncommitted 读未提交数据；（会呈现脏读）

· Read Committed 读已提交数据；

· Repeatable Read 可反复读；

· Serializable 串行化

事务的流传属性:

· Required 业务办法须要在一个事务中运行，如果一个办法运行时曾经处在一个事务中，那么退出到该事务，否则为本人创立一个新事务，80% 的办法用到该流传属性；

· Not-Supported· Requiresnew· Mandatoky· Supports· Never· Nested

事务的流传机制:

流传机制	阐明
PROPAGATION_REQUIRED	如果以后没有事务，就创立一个事务，如果曾经存在事务，就退出到这个事务。以后流传机制也是 spring 默认流传机制
PROPAGATION_REQUIRES_NEW	新建事务，如果以后存在事务，就抛出异样
PROPAGATION_SUPPORTS	反对以后事务，如果以后没有事务，就以非事务形式执行
PROPAGATION_NOT_SUPPORTED	以非事务形式执行操作，如果以后存在事务，就把以后事务挂起
PROPAGATION_MANDATORY	应用以后的事务，如果以后没有事务，就抛出异样
PROPAGATION_NEVER	以非事务形式执行，如果以后存在事务，则抛出异样
PROPAGATION_NESTED	如果以后存在事务，则在嵌套的事务内执行。如果以后没有事务，则执行与 PROPAGATION_REQUIRED 相似的操作

⑴Spring 的长处：

① Spring 能无效地组织你的中间层对象，不论你是否抉择应用了 EJB；

② Spring 能打消在许多工程中常见的对 Singleton 的过多应用。(因为它升高了零碎的可测试性和面向对象的水平)；

③ 通过一种在不同应用程序和我的项目间统一的办法来解决配置文件，Spring 能打消各种各样自定义格局的属性文件的须要。Inversion of Control 的应用帮忙实现了这种简化；

④通过把对接口编程而不是对类编程的代价简直缩小到没有，Spring 可能促成养成好的编程习惯；

⑤Spring 被设计为让应用它创立的利用尽可能少的依赖于他的 APIs。在 Spring 利用中的大多数业务对象没有依赖于 Spring；

⑥应用 Spring 构建的应用程序易于单元测试；

⑦Spring 能使 EJB 的应用成为一个实现抉择，而不是利用架构的必然选择。你能抉择用 POJOs 或 local EJBs 来实现业务接口，却不会影响调用代码；

⑧Spring 帮忙你解决许多问题而无需应用 EJB。Spring 能提供一种 EJB 的替换物，他们实用于许多 web 利用。例如：Spring 能应用 AOP 提供申明性事务管理而不通过 EJB 容器；

⑨Spring 为数据存取提供了一个统一的框架不管应用的是 JDBC 还是 O /R mapping 产品；

⑵Spring 的毛病：

①应用人数不多，jsp 中要写很多代码；（已过期）

②控制器过于灵便，短少一个专用控制器。

转自：http://blog.163.com/menxu_wor…
https://blog.csdn.net/zl1zl2z…

1. 什么是 spring?

2. 应用 Spring 框架的益处是什么？

3. Spring 由哪些模块组成?

4. 外围容器（利用上下文) 模块。

5. BeanFactory – BeanFactory 实现举例。

6. XMLBeanFactory

7. 解释 AOP 模块

8. 解释 JDBC 形象和 DAO 模块。

9. 解释对象 / 关系映射集成模块。

10. 解释 WEB 模块。

12. Spring 配置文件

13. 什么是 Spring IOC 容器？

14. IOC 的长处是什么？

15. ApplicationContext 通常的实现是什么?

16. Bean 工厂和 Application contexts 有什么区别？

17. 一个 Spring 的利用看起来象什么？

18. 什么是 Spring 的依赖注入？

19. 有哪些不同类型的 IOC（依赖注入）形式？

20. 哪种依赖注入形式你倡议应用，结构器注入，还是 Setter 办法注入？

21. 什么是 Spring beans?

22. 一个 Spring Bean 定义 蕴含什么？

23. 如何给 Spring 容器提供配置元数据?

24. 你怎么定义类的作用域?

25. 解释 Spring 反对的几种 bean 的作用域。

26. Spring 框架中的单例 bean 是线程平安的吗?

27. 解释 Spring 框架中 bean 的生命周期。

28. 哪些是重要的 bean 生命周期办法？你能重载它们吗？

29. 什么是 Spring 的外部 bean？

30. 在 Spring 中如何注入一个 java 汇合？

31. 什么是 bean 拆卸?

32. 什么是 bean 的主动拆卸？

33. 解释不同形式的主动拆卸。

34. 主动拆卸有哪些局限性 ?

35. 你能够在 Spring 中注入一个 null 和一个空字符串吗？

36. 什么是基于 Java 的 Spring 注解配置? 给一些注解的例子.

37. 什么是基于注解的容器配置?

38. 怎么开启注解拆卸？

39. @Required 注解

40. @Autowired 注解

41. @Qualifier 注解

42. 在 Spring 框架中如何更无效地应用 JDBC?

43. JdbcTemplate

44. Spring 对 DAO 的反对

45. 应用 Spring 通过什么形式拜访 Hibernate?

46. Spring 反对的 ORM

47. 如何通过 HibernateDaoSupport 将 Spring 和 Hibernate 联合起来？

48. Spring 反对的事务管理类型

49. Spring 框架的事务管理有哪些长处？

50. 你更偏向用那种事务管理类型？

51. 解释 AOP

52. Aspect 切面

53. 在 Spring AOP 中，关注点和横切关注的区别是什么？

54. 连接点

55. 告诉

56. 切点

57. 什么是引入?

58. 什么是指标对象?

59. 什么是代理?

60. 有几种不同类型的主动代理？

61. 什么是织入。什么是织入利用的不同点？

62. 解释基于 XML Schema 形式的切面实现。

63. 解释基于注解的切面实现

64. 什么是 Spring 的 MVC 框架？

65. DispatcherServlet

66. WebApplicationContext

67. 什么是 Spring MVC 框架的控制器？

68. @Controller 注解

69. @RequestMapping 注解

70.Spring 工作机制及为什么要用？

71. 说说 AOP 和 IOC 的概念以及在 spring 中是如何利用的?

72. Spring 的事务有几种形式？

73. 谈谈 spring 事务的隔离级别和流传行为？

74. Spring 的长处和毛病？

22. 一个 Spring Bean 定义蕴含什么？