共计 20661 个字符，预计需要花费 52 分钟才能阅读完成。
1. 为什么应用 Spring ?
1). 不便解耦，简化开发
通过 Spring 提供的 IoC 容器，能够将对象之间的依赖关系交由 Spring 进行管制，防止硬编码所造成的适度程序耦合。
2). AOP 编程的反对
通过 Spring 提供的 AOP 性能，不便进行面向切面的编程，如性能监测、事务管理、日志记录等。
3). 申明式事务的反对
4). 不便集成各种优良框架
5). 升高 Java EE API 的应用难度
如对 JDBC，JavaMail，近程调用等提供了简便封装。2. 什么是 IoC，为什应用 IoC ?
IoC全称 Iversion of Controller，管制反转。
这概念是说你不必创建对象，而只须要形容它如何被创立。你不在代码里间接组装你的组件和服务，然而要在配置文件里形容哪些组件须要哪些服务，之后一个容器（IOC 容器）负责把他们组装起来。
它能领导咱们如何设计出松耦合、更低劣的程序。
3. 什么是 AOP，为什么应用 AOP ?
AOP 全称：Aspect-Oriented Programming，面向切面编程。
AOP，面向切面编程，就是把可重用的性能提取进去，而后将这些通用性能在适合的时候织入到应用程序中，比方事务管理、权限管制、日志记录、性能统计等。
AOP 并没有帮忙咱们解决任何新的问题，它只是提供了一种更好的方法，可能用更少的工作量来解决现有的一些问题，使得零碎更加强壮，可维护性更好。
4. 什么是 Spring 的事务管理？
事务 就是对一系列的数据库操作（比方插入多条数据）进行对立的提交或回滚操作，如果插入胜利，那么一起胜利，如果两头有一条出现异常，那么回滚之前的所有操作。这样能够防止出现脏数据，避免数据库数据呈现问题。
开发中为了防止这种状况个别都会进行事务管理。
Spring 的 申明式事务 通常是指在配置文件中对事务进行配置申明，其中包含了很多申明属性，它是通过 Spring Proxy 帮你做代理，本人不必额定的写代码，只有在 Spring 配置文件中申明即可；通常用在数据库的操作外面；
编程式事务 就是指通过硬编码的形式做事务处理，这种解决形式须要写代码，事务中的逻辑能够本人定制；能够是数据库的东东，也能够是其余的操作。
Spring 中也有本人的事务管理机制，个别是应用 TransactionMananger 进行治理，能够通过 Spring 的注入来实现此性能。
5.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 情景下无效。
6. 什么是 Spring 的 MVC 框架？
Spring 装备构建 Web 利用的全功能 MVC 框架。Spring 能够很便捷地和其余 MVC 框架集成，如 Struts，Spring 的 MVC 框架用管制反转把业务对象和管制逻辑清晰地隔离。它也容许以申明的形式把申请参数和业务对象绑定。
spring mvc 是一个基于 mvc 的 web 框架。spring mvc 是 spring 框架的一个模块，springmvc 和 spring 无需通过两头整合层进行整合。
7. 如何启用注解?
<context:annotation-config/>如果应用
<context:component-scan base-package="com.tgb.web.controller.annotation"> </context:component-scan> 则下面内容能够省略
8.Spring MVC 的申请流程?
第一步：发动申请到前端控制器(DispatcherServlet)
第二步：前端控制器申请 HandlerMapping 查找 Handler 能够依据 xml 配置、注解进行查找
第三步：处理器映射器 HandlerMapping 向前端控制器返回 Handler
第四步：前端控制器调用处理器适配器去执行 Handler
第五步：处理器适配器去执行 Handler
第六步：Handler 执行实现给适配器返回 ModelAndView
第七步：处理器适配器向前端控制器返回 ModelAndView。ModelAndView 是 springmvc 框架的一个底层对象，包含 Model 和 view
第八步：前端控制器申请视图解析器去进行视图解析，依据逻辑视图名解析成真正的视图(jsp)
第九步：视图解析器向前端控制器返回 View
第十步：前端控制器进行视图渲染。视图渲染将模型数据 (在 ModelAndView 对象中) 填充到 request 域
第十一步：前端控制器向用户响应后果
9. 注解的处理器映射器和适配器?
spring3.1 之后应用 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping 注解映射器。
在 spring3.1 之后应用 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter 注解适配器。
应用 mvc:annotation-driven 代替上边注解映射器和注解适配器配置
10.spring 与 mybatis 整合过程?
第一步：整合 dao 层
mybatis 和 spring 整合，通过 spring 治理 mapper 接口。
应用 mapper 的扫描器主动扫描 mapper 接口在 spring 中进行注册。
第二步：整合 service 层
通过 spring 治理 service 接口。
应用配置形式将 service 接口配置在 spring 配置文件中。
实现事务管制。
第三步：整合 springmvc
因为 springmvc 是 spring 的模块，不须要整合
次要配置有：
1). mybatis 配置文件 sqlMapConfig.xml 配置别名主动扫描(实体类)
2). mapper 扫描器(接口，数据库拜访接口)
3). 数据库连接池配置
4). 申明式事务配置
5). 启用注解扫描：<context:component-scan base-package=”cn.itcast.ssm.controller”></context:component-scan>
6). 配置注解映射器和适配器：<mvc:annotation-driven></mvc:annotation-driven>
7). 视图解析器：<bean class=”org.springframework.web.servlet.view.InternalResourceViewResolver”>
8). 配置管制类：DispatcherServlet 前端控制器
9). 配置 spring 配置文件加载类：ClassLoadListener
11. 事务管制(applicationContext-transaction.xml)?
在 applicationContext-transaction.xml 中应用 spring 申明式事务管制办法。
12. 动态资源拜访不被拦挡?
<resources mapping=”/resources/**” location=”/resources/” />
<resources mapping=”/images/**” location=”/images/” />
<resources mapping=”/js/**” location=”/js/” />
13.@RequestMapping 的作用?
1). url 映射
2). 窄化申请映射
3). 限度 http 申请办法
14.controller 办法的返回值?
1 返回 ModelAndView
须要办法完结时，定义 ModelAndView，将 model 和 view 别离进行设置。
2 返回 string
如果 controller 办法返回 string，
1). 示意返回逻辑视图名。真正视图(jsp 门路)= 前缀 + 逻辑视图名 + 后缀
2). redirect 重定向：返回字符串格局为：”redirect:queryItem.action”
3). forward 页面转发：返回字符串格局为：“forward:queryItem.action”
3 返回 void
在 controller 办法形参上能够定义 request 和 response，应用 request 或 response 指定响应后果：
1). 应用 request 转向页面，如下：request.getRequestDispatcher(“ 页面门路 ”).forward(request, response);
2). 也能够通过 response 页面重定向：response.sendRedirect(“url”)
3). 也能够通过 response 指定响应后果，例如响应 json 数据如下：
response.setCharacterEncoding(“utf-8”);
response.setContentType(“application/json;charset=utf-8”);
response.getWriter().write(“json 串 ”);
15. 参数绑定
1 默认反对的类型
间接在 controller 办法形参上定义下边类型的对象，就能够应用这些对象。在参数绑定过程中，如果遇到下边类型间接进行绑定。
1). HttpServletRequest：通过 request 对象获取申请信息
2). HttpServletResponse：通过 response 解决响应信息
3). HttpSession：通过 session 对象失去 session 中寄存的对象
4). Model/ModelMap：model 是一个接口，modelMap 是一个接口实现。作用：将 model 数据填充到 request 域。
2 简略类型
通过 @RequestParam 对简略类型的参数进行绑定。
如果不应用 @RequestParam，要求 request 传入参数名称和 controller 办法的形参名称统一，方可绑定胜利。
如果应用 @RequestParam，不必限度 request 传入参数名称和 controller 办法的形参名称统一。
通过 required 属性指定参数是否必须要传入，如果设置为 true，没有传入参数，会报错。
3 pojo 绑定
页面中 input 的 name 和 controller 的 pojo 形参中的属性名称统一，将页面中数据绑定到 pojo。(usename,age；不须要 user.username,user.age)
4 自定义参数绑定实现日期类型绑定
对于 controller 形参中 pojo 对象，如果属性中有日期类型，须要自定义参数绑定。将申请日期数据串转成 日期类型，要转换的日期类型和 pojo 中日期属性的类型保持一致。
16.Spring MVC 和 Struts2 比照?
1). Struts2 是类级别的拦挡，一个类对应一个 request 上下文，SpringMVC 是办法级别的拦挡，一个办法对应一个 request 上下文，而办法同时又跟一个 url 对应，所以说从架构自身上 SpringMVC 就容易实现 restful url
2). 由上边起因，SpringMVC 的办法之间基本上独立的，独享 request response 数据，申请数据通过参数获取，处理结果通过 ModelMap 交回给框架，办法之间不共享变量，而 Struts2 搞的就比拟乱，尽管办法之间也是独立的，但其所有 Action 变量是共享的，这不会影响程序运行，却给咱们编码 读程序时带来麻烦，每次来了申请就创立一个 Action，一个 Action 对象对应一个 request 上下文。
3). 因为 Struts2 须要针对每个 request 进行封装，把 request，session 等 servlet 生命周期的变量封装成一个一个 Map，供应每个 Action 应用，并保障线程平安，所以在原则上，是比拟消耗内存的。
4). SpringMVC 集成了 Ajax，应用十分不便，只需一个注解 @ResponseBody 就能够实现，而后间接返回响应文本即可，而 Struts2 拦截器集成了 Ajax，在 Action 中解决时个别必须装置插件或者本人写代码集成进去，应用起来也绝对不不便。
5). springmvc 面向办法开发的（更靠近 service 接口的开发方式），struts2 面向类开发。
6). springmvc 能够单例开发，struts2 只能是多例开发。
17. 乱码解决?
1). post 乱码
在 web.xml 增加 post 乱码 filter：CharacterEncodingFilter
2). 对于 get 申请中文参数呈现乱码解决办法有两个：
a. 批改 tomcat 配置文件增加编码与工程编码统一，如下：<Connector URIEncoding=”utf-8″ connectionTimeout=”20000″ port=”8080″ protocol=”HTTP/1.1″ redirectPort=”8443″/>
b. 对参数进行从新编码：String userName = new String(request.getParamter(“userName”).getBytes(“ISO8859-1″),”utf-8”)
ISO8859- 1 是 tomcat 默认编码，须要将 tomcat 编码后的内容按 utf- 8 编码
18. 汇合类型绑定
1). 数组绑定：
controller 办法参数应用：(Integer[] itemId)
页面对立应用:itemId 作为 name
2). list 绑定：
pojo 属性名为：itemsList
页面：itemsList[index]. 属性名
3). map 绑定：
pojo 属性名为：Map<String, Object> itemInfo = new HashMap<String, Object>();
页面：<td> 姓名：<inputtype="text"name="itemInfo['name']"/>
19.spring 校验 ?
1). 我的项目中，通常应用较多是前端的校验，比方页面中 js 校验。对于平安要求较高点倡议在服务端进行校验。
2). springmvc 应用 hibernate 的校验框架 validation(和 hibernate 没有任何关系)。
校验思路：页面提交申请的参数，申请到 controller 办法中，应用 validation 进行校验。如果校验出错，将错误信息展现到页面。
20. 数据回显?
1). @ModelAttribute 还能够将办法的返回值传到页面：在办法上加注解 @ModelAttribute
2). 应用最简略办法应用 model，能够不必 @ModelAttribute：model.addAttribute(“id”, id);
3). springmvc 默认对 pojo 数据进行回显。pojo 数据传入 controller 办法后，springmvc 主动将 pojo 数据放到 request 域，key 等于 pojo 类型（首字母小写）
4). public String testParam(PrintWriter out, @RequestParam(“username”) String username) {//out 间接输入
21. 异样解决?
springmvc 提供全局异样处理器（一个零碎只有一个异样处理器）进行对立异样解决。
零碎遇到异样，在程序中手动抛出，dao 抛给 service、service 给 controller、controller 抛给前端控制器，前端控制器调用全局异样处理器。
22. 上传图片?
1). 在页面 form 中提交 enctype=”multipart/form-data” 的数据时，须要 springmvc 对 multipart 类型的数据进行解析。
2). 在 springmvc.xml 中配置 multipart 类型解析器。
3). 办法中应用：MultipartFile attach (单个文件上传) 或者 MultipartFile[] attachs (多个文件上传)
23.Json 解决
1). 加载 json 转换的 jar 包：springmvc 中应用 jackson 的包进行 json 转换（@requestBody 和 @responseBody 应用下边的包进行 json 转）
2). 配置 json 转换器。在注解适配器 RequestMappingHandlerAdapter 中退出 messageConverters。如果应用 <mvc:annotation-driven /> 则会主动退出。
3). ajax
4). Controller (ResponseBody、RequestBody)
5). 留神 ajax 中 contentType 如果不设置为 json 类型，则传的参数为 key/value 类型。下面设置后，传的是 json 类型。
24. 拦截器?
1). 定义拦截器，实现 HandlerInterceptor 接口。接口中提供三个办法。
a. preHandle：进入 Handler 办法之前执行，用于身份认证、身份受权，比方身份认证，如果认证通过示意以后用户没有登陆，须要此办法拦挡不再向下执行
b. postHandle：进入 Handler 办法之后，返回 modelAndView 之前执行，利用场景从 modelAndView 登程：将专用的模型数据 (比方菜单导航) 在这里传到视图，也能够在这里对立指定视图
c. afterCompletion：执行 Handler 实现执行此办法，利用场景：对立异样解决，对立日志解决
2). 拦截器配置：
a. 针对 HandlerMapping 配置(不举荐)：springmvc 拦截器针对 HandlerMapping 进行拦挡设置，如果在某个 HandlerMapping 中配置拦挡，通过该 HandlerMapping 映射胜利的 handler 最终应用该 拦截器。(个别不举荐应用)
b. 相似全局的拦截器：springmvc 配置相似全局的拦截器，springmvc 框架将配置的相似全局的拦截器注入到每个 HandlerMapping 中
25.spring 中主动拆卸的形式有哪些？
1、No：即不启用主动拆卸。
2、byName：通过属性的名字的形式查找 JavaBean 依赖的对象并为其注入。比如说类 Computer 有个属性 printer，指定其 autowire 属性为 byName 后，Spring IoC 容器会在配置文件中查找 id/name 属性为 printer 的 bean，而后应用 Seter 办法为其注入。
3、byType：通过属性的类型查找 JavaBean 依赖的对象并为其注入。比方类 Computer 有个属性 printer，类型为 Printer，那么，指定其 autowire 属性为 byType 后，Spring IoC 容器会查找 Class 属性为 Printer 的 bean，应用 Seter 办法为其注入。
4、constructor：通 byType 一样，也是通过类型查找依赖对象。与 byType 的区别在于它不是应用 Seter 办法注入，而是应用结构子注入。
5、autodetect：在 byType 和 constructor 之间主动的抉择注入形式。
6、default：由下级标签 <beans> 的 default-autowire 属性确定。
26.Spring 中 AOP 的利用场景、Aop 原理、益处？
AOP–Aspect Oriented Programming 面向切面编程；用来封装横切关注点，具体能够在上面的场景中应用:
Authentication 权限、Caching 缓存、Context passing 内容传递、Error handling 错误处理 Lazy loading 懒加载、Debugging 调试、logging, tracing, profiling and monitoring 记录跟踪优化 校准、Performance optimization 性能优化、Persistence 长久化、Resource pooling 资源池、Synchronization 同步、Transactions 事务。
原理：AOP是面向切面编程，是通过动静代理的形式为程序增加对立性能，集中解决一些公共问题。
长处：1. 各个步骤之间的良好隔离性耦合性大大降低
2. 源代码无关性，再扩大性能的同时不对源码进行批改操作
27.Spring 中 IOC 的作用与原理？对象创立的过程？
IOC–Inversion of Control 管制反转。当某个角色须要另外一个角色帮助的时候，在传统的程序设计过程中，通常由调用者来创立被调用者的实例对象。但在 spring 中创立被调用者的工作不再由调用者来实现，因而称为管制反转。创立被调用者的工作由 spring 来实现，而后注入调用者 间接应用。
28.Spring 常见创建对象的注解？
@Component@Controller@ Service@ Repository
29.Spring 中用到的设计模式？
简略工厂、工厂办法、单例模式、适配器、包装器、代理、观察者、策略、模板办法
30.Spring 的长处？
1. 升高了组件之间的耦合性，实现了软件各层之间的解耦
2. 能够应用容易提供的泛滥服务，如事务管理，音讯服务等
3. 容器提供单例模式反对
4. 容器提供了 AOP 技术，利用它很容易实现如权限拦挡，运行期监控等性能
5. 容器提供了泛滥的辅助类，能放慢利用的开发
6.spring 对于支流的利用框架提供了集成反对，如 hibernate，JPA，Struts 等
7.spring 属于低侵入式设计，代码的净化极低
8. 独立于各种应用服务器
9.spring 的 DI 机制升高了业务对象替换的复杂性
10.Spring 的高度开放性，并不强制利用齐全依赖于 Spring，开发者能够自由选择 spring 的局部或全副
31.Spring Bean 的作用域之间有什么区别？
Spring 容器中的 bean 能够分为 5 个范畴。所有范畴的名称都是自阐明的，然而为了防止混同，还是让咱们来解释一下：
singleton：这种 bean 范畴是默认的，这种范畴确保不论承受到多少个申请，每个容器中只有一个 bean 的实例，单例的模式由 bean factory 本身来保护。
prototype：原形范畴与单例范畴相同，为每一个 bean 申请提供一个实例。
request：在申请 bean 范畴内会每一个来自客户端的网络申请创立一个实例，在申请实现当前，bean 会生效并被垃圾回收器回收。
Session：与申请范畴相似，确保每个 session 中有一个 bean 的实例，在 session 过期后，bean 会随之生效。
global-session：global-session 和 Portlet 利用相干。当你的利用部署在 Portlet 容器中工作时，它蕴含很多 portlet。如果你想要申明让所有的 portlet 共用全局的存储变量的话，那么这全局变量须要存储在 global-session 中。
全局作用域与 Servlet 中的 session 作用域成果雷同。
32.Spring 治理事务有几种形式？
有两种形式：
1、编程式事务，在代码中硬编码。(不举荐应用)
2、申明式事务，在配置文件中配置（举荐应用）
申明式事务 又分为两种：
a、基于 XML 的申明式事务
b、基于注解的申明式事务
33.spring 中的外围类有那些，各有什么作用？
BeanFactory：产生一个新的实例，能够实现单例模式
BeanWrapper：提供对立的 get 及 set 办法
ApplicationContext: 提供框架的实现，包含 BeanFactory 的所有性能
34.Bean 的调用形式有哪些？
有三种形式能够失去 Bean 并进行调用：
1、应用 BeanWrapper
HelloWorld hw=new HelloWorld();
BeanWrapper bw=new BeanWrapperImpl(hw);
bw.setPropertyvalue(”msg”,”HelloWorld”);
system.out.println(bw.getPropertyCalue(”msg”));2、应用 BeanFactory
InputStream is=new FileInputStream(”config.xml”);
XmlBeanFactory factory=new XmlBeanFactory(is);
HelloWorld hw=(HelloWorld) factory.getBean(”HelloWorld”);
system.out.println(hw.getMsg());3、应用 ApplicationConttext
ApplicationContext actx=new FleSystemXmlApplicationContext(”config.xml”);
HelloWorld hw=(HelloWorld) actx.getBean(”HelloWorld”);
System.out.println(hw.getMsg());35. 什么是 IOC，什么又是 DI，他们有什么区别？
依赖注入DI 是一个程序设计模式和架构模型，一些时候也称作管制反转，只管在技术上来讲，依赖注入是一个 IOC 的非凡实现，依赖注入是指一个对象利用另外一个对象来提供一个非凡的能力，例如：把一个 数据库连贯已参数的模式传到一个对象的构造办法外面而不是在那个对象外部自行创立一个连贯。管制反转和依赖注入的根本思维就是把类的依赖从类外部转化到外 部以缩小依赖
利用管制反转，对象在被创立的时候，由一个调控零碎内所有对象的外界实体，将其所依赖的对象的援用，传递给它。也能够说，依赖被注入到对象中。所以，管制反转是，对于一个对象如何获取他所依赖的对象的援用，这个责任的反转。
36.spring 有两种代理形式？
若指标对象实现了若干接口，spring 应用 JDK 的 java.lang.reflect.Proxy 类代理。
长处：因为有接口，所以使零碎更加松耦合
毛病：为每一个指标类创立接口
若指标对象没有实现任何接口，spring 应用 CGLIB 库生成指标对象的子类。
长处：因为代理类与指标类是继承关系，所以不须要有接口的存在。毛病：因为没有应用接口，所以零碎的耦合性没有应用 JDK 的动静代理好。37.springMVC 的流程？
1. 用户发送申请至前端控制器 DispatcherServlet
2.DispatcherServlet 收到申请调用 HandlerMapping 处理器映射器。
3. 处理器映射器依据申请 url 找到具体的处理器，生成处理器对象及处理器拦截器 (如果有则生成) 一并返回给 DispatcherServlet。
4.DispatcherServlet 通过 HandlerAdapter 处理器适配器调用处理器
5. 执行处理器(Controller，也叫后端控制器)。
6.Controller 执行实现返回 ModelAndView
7.HandlerAdapter 将 controller 执行后果 ModelAndView 返回给 DispatcherServlet
8.DispatcherServlet 将 ModelAndView 传给 ViewReslover 视图解析器
9.ViewReslover 解析后返回具体 View
10.DispatcherServlet 对 View 进行渲染视图（行将模型数据填充至视图中）。
11.DispatcherServlet 响应用户
38.Springmvc 的长处？
1. 它是基于组件技术的. 全副的利用对象, 无论控制器和视图, 还是业务对象之类的都是 java 组件. 并且和 Spring 提供的其余根底构造严密集成.
2. 不依赖于 Servlet API(指标虽是如此, 然而在实现的时候的确是依赖于 Servlet 的)
3. 能够任意应用各种视图技术, 而不仅仅局限于 JSP
4. 反对各种申请资源的映射策略
5. 它应是易于扩大的
39. 什么是 spring?
Spring 是个 java 企业级利用的开源开发框架。Spring 次要用来开发 Java 利用，然而有些扩大是针对构建 J2EE 平台的 web 利用。Spring 框架指标是简化 Java 企业级利用开发，并通过 POJO 为根底的编程模型促成良好的编程习惯。
40. 应用 Spring 框架的益处是什么？
轻量：Spring 是轻量的，根本的版本大概 2MB。
管制反转：Spring 通过管制反转实现了涣散耦合，对象们给出它们的依赖，而不是创立或查找依赖的对象们。
面向切面的编程(AOP)：Spring 反对面向切面的编程，并且把利用业务逻辑和零碎服务离开。
容器：Spring 蕴含并治理利用中对象的生命周期和配置。
MVC 框架：Spring 的 WEB 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。
事务管理：Spring 提供一个继续的事务管理接口，能够扩大到上至本地事务下至全局事务（JTA）。
异样解决：Spring 提供方便的 API 把具体技术相干的异样（比方由 JDBC，Hibernate or JDO 抛出的）转化为统一的 unchecked 异样。
41. Spring 由哪些模块组成?
以下是 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
42. 外围容器（利用上下文) 模块。
这是根本的 Spring 模块，提供 spring 框架的根底性能，BeanFactory 是 任何以 spring 为根底的利用的外围。Spring 框架建设在此模块之上，它使 Spring 成为一个容器。
43. BeanFactory – BeanFactory 实现举例。
Bean 工厂是工厂模式的一个实现，提供了管制反转性能，用来把利用的配置和依赖从正真的利用代码中拆散。
最罕用的 BeanFactory 实现是 XmlBeanFactory 类。
44. XMLBeanFactory
最罕用的就是 org.springframework.beans.factory.xml.XmlBeanFactory，它依据 XML 文件中的定义加载 beans。该容器从 XML 文件读取配置元数据并用它去创立一个齐全配置的零碎或利用。
45. 解释 AOP 模块
AOP 模块用于发给咱们的 Spring 利用做面向切面的开发，很多反对由 AOP 联盟提供，这样就确保了 Spring 和其余 AOP 框架的共通性。这个模块将元数据编程引入 Spring。
46. 解释 JDBC 形象和 DAO 模块。
通过应用 JDBC 形象和 DAO 模块，保障数据库代码的简洁，并能防止数据库资源谬误敞开导致的问题，它在各种不同的数据库的错误信息之上，提供了一个对立的异样拜访层。它还利用 Spring 的 AOP 模块给 Spring 利用中的对象提供事务管理服务。
47. 解释对象 / 关系映射集成模块。
Spring 通过提供 ORM 模块，反对咱们在间接 JDBC 之上应用一个对象 / 关系映射映射 (ORM) 工具，Spring 反对集成支流的 ORM 框架，如 Hiberate,JDO 和 iBATIS SQL Maps。Spring 的事务管理同样反对以上所有 ORM 框架及 JDBC。
48. 解释 WEB 模块。
Spring 的 WEB 模块是构建在 application context 模块根底之上，提供一个适宜 web 利用的上下文。这个模块也包含反对多种面向 web 的工作，如通明地解决多个文件上传申请和程序级申请参数的绑定到你的业 务对象。它也有对 Jakarta Struts 的反对。
49. Spring 配置文件
Spring 配置文件是个 XML 文件，这个文件蕴含了类信息，形容了如何配置它们，以及如何互相调用。
50. 什么是 Spring IOC 容器？
Spring IOC 负责创建对象，治理对象（通过依赖注入（DI），拆卸对象，配置对象，并且治理这些对象的整个生命周期。
51. IOC 的长处是什么？
IOC 或 依赖注入把利用的代码量降到最低。它使利用容易测试，单元测试不再须要单例和 JNDI 查找机制。最小的代价和最小的侵入性使涣散耦合得以实现。IOC 容器反对加载服务时的饿汉式初始化和懒加载。
52. ApplicationContext 通常的实现是什么?
FileSystemXmlApplicationContext：此容器从一个 XML 文件中加载 beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你须要正确设置 classpath 因为这个容器将在 classpath 里找 bean 配置。
WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 WEB 利用的所有 bean。
53. Bean Factory 和 Application contexts 有什么区别？
Application contexts 提供一种办法解决文本音讯，一个通常的做法是加载文件资源（比方镜像），它们能够向注册为监听器的 bean 公布事件。
另外，在容器或容器 内的对象上执行的那些不得不由 bean 工厂以程序化形式解决的操作，能够在 Application contexts 中以申明的形式解决。
Application contexts 实现了 MessageSource 接口，该接口的实现以可插拔的形式提供获取本地化音讯的办法。
54. 一个 Spring 的利用看起来象什么？
一个定义了一些性能的接口。
这实现包含属性，它的 Setter，getter 办法和函数等。
Spring AOP。
Spring 的 XML 配置文件。
应用以上性能的客户端程序。
55. 什么是 Spring 的依赖注入？
依赖注入，是 IOC 的一个方面，是个通常的概念，它有多种解释。这概念是说你不必创建对象，而只须要形容它如何被创立。你不在代码里间接组装你的组件和服务，然而要在配置文件里形容哪些组件须要哪些服务，之后一个容器（IOC 容器）负责把他们组装起来。
56. 有哪些不同类型的依赖注入形式？
结构器依赖注入：结构器依赖注入通过容器触发一个类的结构器来实现的，该类有一系列参数，每个参数代表一个对其余类的依赖。
Setter 办法注入：Setter 办法注入是容器通过调用无参结构器或无参 static 工厂 办法实例化 bean 之后，调用该 bean 的 setter 办法，即实现了基于 setter 的依赖注入。
57. 哪种依赖注入形式你倡议应用，结构器注入，还是 Setter 办法注入？
你两种依赖形式都能够应用，结构器注入和 Setter 办法注入。
最好的解决方案是用结构器参数实现强制依赖，setter 办法实现可选依赖。
58. 什么是 Spring beans?
Spring beans 是那些造成 Spring 利用的骨干的 java 对象。它们被 Spring IOC 容器初始化，拆卸，和治理。这些 beans 通过容器中配置的元数据创立。比方，以 XML 文件中 <bean/> 的模式定义。
Spring 框架定义的 beans 都是单件 beans。在 bean tag 中有个属性”singleton”，如果它被赋为 TRUE，bean 就是单件，否则就是一个 prototype bean。默认是 TRUE，所以所有在 Spring 框架中的 beans 缺省都是单件。
59. 一个 Spring Bean 定义 蕴含什么？
一个 Spring Bean 的定义蕴含容器必知的所有配置元数据，包含如何创立一个 bean，它的生命周期详情及它的依赖。
60. 如何给 Spring 容器提供配置元数据?
这里有三种重要的办法给 Spring 容器提供配置元数据。
XML 配置文件。
基于注解的配置。
基于 java 的配置。
61. 你怎么定义类的作用域?
当定义一个 <bean> 在 Spring 里，咱们还能给这个 bean 申明一个作用域。它能够通过 bean 定义中的 scope 属性来定义。
如，当 Spring 要在须要的时候每次生产一个新的 bean 实例，bean 的 scope 属性被指定为 prototype。
另一方面，一个 bean 每次应用的时候必须返回同一个实例，这个 bean 的 scope 属性 必须设为 singleton。
62. 解释 Spring 反对的几种 bean 的作用域。
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.
63. Spring 框架中的单例 bean 是线程平安的吗?
不，Spring 框架中的单例 bean 不是线程平安的。
64. 解释 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()办法。
65. 哪些是重要的 bean 生命周期办法？你能重载它们吗？
有两个重要的 bean 生命周期办法，第一个是 setup，它是在容器加载 bean 的时候被调用。第二个办法是 teardown 它是在容器卸载类的时候被调用。
The bean 标签有两个重要的属性（init-method 和 destroy-method）。用它们你能够本人定制初始化和登记办法。它们也有相应的注解（@PostConstruct 和 @PreDestroy）。
66. 什么是 Spring 的外部 bean？
当一个 bean 仅被用作另一个 bean 的属性时，它能被申明为一个外部 bean，为了定义 inner bean，在 Spring 的 基于 XML 的 配置元数据中，能够在 <property/> 或 <constructor-arg/> 元素内应用 <bean/> 元素，外部 bean 通常是匿名的，它们的 Scope 个别是 prototype。
67. 在 Spring 中如何注入一个 java 汇合？
Spring 提供以下几种汇合的配置元素：
<list> 类型用于注入一列值，容许有雷同的值。
<set> 类型用于注入一组值，不容许有雷同的值。
<map> 类型用于注入一组键值对，键和值都能够为任意类型。
<props> 类型用于注入一组键值对，键和值都只能为 String 类型。
68. 什么是 bean 拆卸?
拆卸，或 bean 拆卸是指在 Spring 容器中把 bean 组装到一起，前提是容器须要晓得 bean 的依赖关系，如何通过依赖注入来把它们拆卸到一起。
69. 什么是 bean 的主动拆卸？
Spring 容器可能主动拆卸相互合作的 bean，这意味着容器不须要 <constructor-arg> 和 <property> 配置，能通过 Bean 工厂主动解决 bean 之间的合作。
70. 解释不同形式的主动拆卸。
有五种主动拆卸的形式，能够用来领导 Spring 容器用主动拆卸形式来进行依赖注入。
no：默认的形式是不进行主动拆卸，通过显式设置 ref 属性来进行拆卸。
byName：通过参数名 主动拆卸，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byname，之后容器试图匹配、拆卸和该 bean 的属性具备雷同名字的 bean。
byType:：通过参数类型主动拆卸，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byType，之后容器试图匹配、拆卸和该 bean 的属性具备雷同类型的 bean。如果有多个 bean 符合条件，则抛出谬误。
constructor：这个形式相似于 byType，然而要提供给结构器参数，如果没有确定的带参数的结构器参数类型，将会抛出异样。
autodetect：首先尝试应用 constructor 来主动拆卸，如果无奈工作，则应用 byType 形式。
71. 主动拆卸有哪些局限性 ?
主动拆卸的局限性是：
重写：你仍需用 <constructor-arg> 和 <property> 配置来定义依赖，意味着总要重写主动拆卸。
根本数据类型：你不能主动拆卸简略的属性，如根本数据类型，String 字符串，和类。
含糊个性：主动拆卸不如显式拆卸准确，如果有可能，倡议应用显式拆卸。
72. 你能够在 Spring 中注入一个 null 和一个空字符串吗？
能够。Spring 注解
73. 什么是基于 Java 的 Spring 注解配置? 给一些注解的例子.
基于 Java 的配置，容许你在大量的 Java 注解 的帮忙下，进行你的大部分 Spring 配置而非通过 XML 文件。
以 @Configuration 注解为例，它用来标记类能够当做一个 bean 的定义，被 Spring IOC 容器应用。
另一个例子是 @Bean 注解，它示意此办法将要返回一个对象，作为一个 bean 注册进 Spring 利用上下文。
74. 什么是基于注解的容器配置?
绝对于 XML 文件，注解型的配置依赖于通过字节码元数据拆卸组件，而非尖括号的申明。
开发者通过在相应的类，办法或属性上应用注解的形式，间接组件类中进行配置，而不是应用 xml 表述 bean 的拆卸关系。
75. 怎么开启注解拆卸？
注解拆卸在默认状况下是不开启的，为了应用注解拆卸，咱们必须在 Spring 配置文件中配置 <context:annotation-config/> 元素。
76. @Required 注解
这个注解表明 bean 的属性必须在配置的时候设置，通过一个 bean 定义的显式的属性值或通过主动拆卸，若 @Required 注解的 bean 属性未被设置，容器将抛出 BeanInitializationException。
77. @Autowired 注解
@Autowired 注解提供了更细粒度的管制，包含在何处以及如何实现主动拆卸。它的用法和 @Required 一样，润饰 setter 办法、结构器、属性或者具备任意名称和 / 或多个参数的 PN 办法。
78. @Qualifier 注解
当有多个雷同类型的 bean 却只有一个须要主动拆卸时，将 @Qualifier 注解和 @Autowire 注解联合应用以打消这种混同，指定须要拆卸的确切的 bean。
Spring 数据拜访
79. 在 Spring 框架中如何更无效地应用 JDBC?
应用 SpringJDBC 框架，资源管理和错误处理的代价都会被加重。所以开发者只需写 statements 和 queries 从数据存取数据，JDBC 也能够在 Spring 框架提供的模板类的帮忙下更无效地被应用，这个模板叫 JdbcTemplate（例子见这里 here）
80. JdbcTemplate
JdbcTemplate 类提供了很多便当的办法解决诸如把数据库数据转变成根本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。
81. Spring 对 DAO 的反对
Spring 对数据拜访对象（DAO）的反对旨在简化它和数据拜访技术如 JDBC，Hibernate or JDO 联合应用。这使咱们能够不便切换长久层。编码时也不必放心会捕捉每种技术特有的异样。
82. 应用 Spring 通过什么形式拜访 Hibernate?
在 Spring 中有两种形式拜访 Hibernate：
管制反转 Hibernate Template 和 Callback。继承 HibernateDAOSupport 提供一个 AOP 拦截器。
83. Spring 反对的 ORM
Spring 反对以下 ORM：
Hibernate、iBatis JPA (Java Persistence API)、TopLink JDO (Java Data Objects)、OJB
84. 如何通过 HibernateDaoSupport 将 Spring 和 Hibernate 联合起来？
用 Spring 的 SessionFactory 调用 LocalSessionFactory。
集成过程分三步：
配置 the Hibernate SessionFactory。
继承 HibernateDaoSupport 实现一个 DAO。
在 AOP 反对的事务中拆卸。
85. Spring 反对的事务管理类型
Spring 反对两种类型的事务管理：
编程式事务管理：这象征你通过编程的形式治理事务，给你带来极大的灵活性，然而难保护。
申明式事务管理：这意味着你能够将业务代码和事务管理拆散，你只需用注解和 XML 配置来治理事务。
86. Spring 框架的事务管理有哪些长处？
它为不同的事务 API 如 JTA，JDBC，Hibernate，JPA 和 JDO，提供一个不变的编程模式。它为编程式事务管理提供了一套简略的 API 而不是一些简单的事务 API 如 它反对申明式事务管理。它和 Spring 各种数据拜访形象层很好得集成。
87. 你更偏向用那种事务管理类型？
大多数 Spring 框架的用户抉择申明式事务管理，因为它对利用代码的影响最小，因而更合乎一个无侵入的轻量级容器的思维。
申明式事务管理要优于编程式事务管理，尽管比编程式事务管理（这种形式容许你通过代码管制事务）少了一点灵活性。
88. 解释 AOP
面向切面的编程，或 AOP，是一种编程技术，容许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。
89. Aspect 切面
AOP 外围就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组 API 提供横切性能。比方，一个日志模块能够被称作日志的 AOP 切面。依据需要的不同，一个应用程序能够有若干切面。在 Spring AOP 中，切面通过带有 @Aspect 注解的类实现。
90. 在 Spring AOP 中，关注点和横切关注的区别是什么？
关注点 是利用中一个模块的行为，一个关注点可能会被定义成一个咱们想实现的一个性能。
横切关注点 是一个关注点，此关注点是整个利用都会应用的性能，并影响整个利用，比方日志，平安和数据传输，简直利用的每个模块都须要的性能。因而这些都属于横切关注点。
91. 连接点
连接点代表一个应用程序的某个地位，在这个地位咱们能够插入一个 AOP 切面，它实际上是个应用程序执行 Spring AOP 的地位。
92. 告诉
告诉是个在办法执行前或执行后要做的动作，实际上是程序执行时要通过 SpringAOP 框架触发的代码段。
Spring 切面能够利用五种类型的告诉：
before：前置告诉，在一个办法执行前被调用。
after: 在办法执行之后调用的告诉，无论办法执行是否胜利。
after-returning: 仅当办法胜利实现后执行的告诉。
after-throwing: 在办法抛出异样退出时执行的告诉。
around: 在办法执行之前和之后调用的告诉。
93. 切点
切入点是一个或一组连接点，告诉将在这些地位执行。能够通过表达式或匹配的形式指明切入点。
94. 什么是引入?
引入容许咱们在已存在的类中减少新的办法和属性。
95. 什么是指标对象?
被一个或者多个切面所告诉的对象。它通常是一个代理对象。也指被告诉（advised）对象。
96. 什么是代理?
代理是告诉指标对象后创立的对象。从客户端的角度看，代理对象和指标对象是一样的。
97. 有几种不同类型的主动代理？
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
Metadata autoproxying
98. 什么是织入。什么是织入利用的不同点？
织入是将切面和到其余利用类型或对象连接或创立一个被告诉对象的过程。
织入能够在编译时，加载时，或运行时实现。
99. 解释基于 XML Schema 形式的切面实现。
在这种状况下，切面由惯例类以及基于 XML 的配置实现。
100. 解释基于注解的切面实现
在这种状况下(基于 @AspectJ 的实现)，波及到的切面申明的格调与带有 java5 标注的一般 java 类统一。
Spring 的 MVC
101. 什么是 Spring 的 MVC 框架？
Spring 装备构建 Web 利用的全功能 MVC 框架。
Spring 能够很便捷地和其余 MVC 框架集成，如 Struts，Spring 的 MVC 框架用管制反转把业务对象和管制逻辑清晰地隔离。
它也容许以申明的形式把申请参数和业务对象绑定。
102. DispatcherServlet
Spring 的 MVC 框架是围绕 DispatcherServlet 来设计的，它用来解决所有的 HTTP 申请和响应。
103. WebApplicationContext
WebApplicationContext 继承了 ApplicationContext 并减少了一些 WEB 利用必备的特有性能，它不同于个别的 ApplicationContext，因为它能解决主题，并找到被关联的 servlet。
104. 什么是 Spring MVC 框架的控制器？
控制器提供一个拜访应用程序的行为，此行为通常通过服务接口实现。控制器解析用户输出并将其转换为一个由视图出现给用户的模型。Spring 用一个十分形象的形式实现了一个管制层，容许用户创立多种用处的控制器。
105. @Controller 注解
该注解表明该类表演控制器的角色，Spring 不须要你继承任何其余控制器基类或援用 Servlet API。
106. @RequestMapping 注解
该注解是用来映射一个 URL 到一个类或一个特定的方解决法上。
原文链接：https://blog.csdn.net/weixin_…