框架基础面试知识
（一）Spring mvc 工作机制(原理):
DispatcherServlet主要用作职责调度工作，本身主要用于控制流程
242a00061aa02f4d9e11.jpg
Spring mvc运行原理
1.springmvc将所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet将请求提交到目标Controller
4.Controller进行业务逻辑处理后，会返回一个ModelAndView
5.DispathcherServlet查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象;
6.视图负责将结果显示到客户端;
视图对象负责渲染返回给客户端。
DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求组织协调Spring MVC的各个组成部分。其主要工作有以下三项：
1. 截获符合特定格式的URL请求。
2. 初始化DispatcherServlet上下文对应的WebApplicationContext，并将其与业务层、持久化层的WebApplicationContext建立关联。
3. 初始化Spring MVC的各个组成组件，并装配到DispatcherServlet中。
====================================================================================================
DispatcherServlet:前端控制器；(相当于一个转发器,中央处理器,调度)
ModelAndView：模型和视图的结合体；(Spring mvc的底层对象)
HandlerMapping: 处理器映射器；
工作原理及为什么要用？
原理：
1.读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Sesssion
4.创建事务
Transation
5. 持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory
为什么要用：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
****（三）Struts工作机制？为什么要使用Struts？
工作机制：
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet，ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象，当ActionServlet接收到一个客户请求时,将执行如下流程.
(1)检索和用户请求匹配的Action Mapping实例,如果不存在,就返 回请求路径无效信息;
(2)如果Action Form实例不存在,就创建一个Action Form对象,把客户提交的表单数据保存到Action Form对象中;
(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用Action Form的validate()方法;
(4)如果Action Form的validate()方法返回null或返回一个不包含Action Message的 ActuibErrors对象,就表示表单验证成功;
(5)Action Servlet 根据Action Mapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
(6)Action的execute()方法返回一个Action Forward对象,Action Servlet再把客户请求转发给 Action Forward对象指向的JSP组件;
(7)Action Forward对象指向JSP组件生成动态网页,返回给客户;
为什么要用：
JSP、Servlet,JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件
****（四）如何优化Hibernate？
1. 使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6.继承类使用显式多态
7.表字段要少，表关联不要怕多，有二级缓存撑腰
Spring工作原理
Spring 已经用过一段时间了，感觉Spring是个很不错的框架。
内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射,反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 。
Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的。
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置 内部通过反射去动态的组装对象）
Struts2 框架本身大致可以分为3个部分：
核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。
核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。
业务控制器Action和业务逻辑组件是需要用户来自己实现的。
用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。
Struts 2 的工作流程相对于 Struts1 要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。
基本简要流程如下：
1.客户端初始化一个指向Servlet容器的请求；
2.这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器， 这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh?Plugin）
3.接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action;
4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy;
5、ActionProxy通过Configuration Manager（配置管理器）询问框架的配置文件，找到需要调用的Action类;
6、ActionProxy创建一个ActionInvocation的实例。
7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。
返回结果通常是（但不总是，也可?能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。
在表示的过程中可以使用Struts2?框架中继承的标签。在这个过程中需要涉及到ActionMapper;
9.响应的返回是通过我们在web.xml中配置的过滤器;
10、如果ActionContextCleanUp是当前使用的，则FilterDispatecher将不会清理sreadlocal?ActionContext;
如果ActionContextCleanUp不使用，则将会去清理
2、说下Struts的设计模式
MVC模式:web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。
3、拦截器和过滤器的区别
1、拦截器是基于java反射机制的，而过滤器是基于函数回调的。
2、拦截器不依赖于servlet容器，过滤器依赖于servlet容器。
3、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有请求起作用。
4、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。
5、在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。
4、struts1于struts2的比较
1、Action类:Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
Struts2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。
Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
2、线程模式:Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。
单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，
servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
3、Servlet依赖:
Struts1 Action 依赖于Servlet API,因为当一个Action被调用时HttpServletRequest和HttpServletResponse被传递给execute方法。
Struts2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。
但是，其他的元素减少或者消除了直接访问HttpServetRequest和HttpServletResponse的必要性。
4、可测性:
测试Struts1?Action的一个主要问题是execute方法暴露了servlet?API（这使得测试要依赖于容器）。
一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）
Struts2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。
5、捕获输入:
Struts1使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态Bean（DynaBeans）可以作为创建传统ActionForm的选择，但是，
开发者可能是在重新描述(创建)已经存在的JavaBean（仍然会导致有冗余的javabean）。
Struts2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。
Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。
这种ModelDriven特性简化了taglib对POJO输入对象的引用。
6、表达式语言：
Struts1整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－ "Object Graph Notation Language "(OGNL).
7、绑定值到页面（view）:
Struts1使用标准JSP机制把对象绑定到页面中来访问。
Struts2使用"ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。
ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
8、类型转换：
Struts1 ActionForm属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
Struts2使用OGNL进行类型转换。提供基本和常用对象的转换器。
9、校验：
Struts1支持在ActionForm的validate方法中手动校验，或者通过Commons Validator的扩展来校验。
同一个类可以有不同的校验内容，但不能校验子对象。
Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，
来支持chain校验子属性.
10、Action执行的控制：
Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。
Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。
为什么要使用Struts2
Struts2 是一个相当强大的Java Web开源框架，是一个基于POJO的Action的MVC Web框架。它基于当年的Webwork和XWork框架，继承其优点，同时做了相当的改进。
1.Struts2基于MVC架构，框架结构清晰，开发流程一目了然，开发人员可以很好的掌控开发的过程。
2.使用OGNL进行参数传递。OGNL提供了在Struts2里访问各种作用域中的数据的简单方式，你可以方便的获取Request，Attribute，Application，Session，Parameters中的数据。大大简化了开发人员在获取这些数据时的代码量。
(OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言，通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。)
3.强大的拦截器: Struts2的拦截器是一个Action级别的AOP，Struts2中的许多特性都是通过拦截器来实现的，例如异常处理，文件上传，验证等。拦截器是可配置与重用的，可以将一些通用的功能如：登录验证，权限验证等置于拦截器中
以完成一些Java?Web项目中比较通用的功能。在我实现的的一Web项目中，就是使用Struts2的拦截器来完成了系统中的权限验证功能。
4.易于测试: Struts2的Action都是简单的POJO，这样可以方便的对Struts2的Action编写测试用例，大大方便了5Java Web项目的测试。
5.易于扩展的插件机制在Struts2添加扩展是一件愉快而轻松的事情，只需要将所需要的Jar包放到WEB-INF/lib文件夹中，在struts.xml中作一些简单的设置就可以实现扩展;
6.模块化管理: Struts2已经把模块化作为了体系架构中的基本思想，可以通过三种方法来将应用程序模块化：将配置信息拆分成多个文件把自包含的应用模块创建为插件创建新的框架特性，即将与特定应用无关的新功能组织成插件，以添加到多个应用中去。
7.全局结果与声明式异常:
为应用程序添加全局的Result，和在配置文件中对异常进行处理，这样当处理过程中出现指定异常时，可以跳转到特定页面。
他的如此之多的优点，是很多人比较的青睐，与spring ,Hibernate进行结合，组成了现在比较流行的ssh框架，
struts2有哪些优点
1.在软件设计上Struts2的应用可以不依赖于Servlet API和struts API。 Struts2的这种设计属于无侵入式设计；
2.拦截器，实现如参数拦截注入等功能；
3.类型转换器，可以把特殊的请求参数转换成需要的类型；
4.多种表现层技术，如：JSP、freeMarker、Velocity等；
5.Struts2的输入校验可以对指定某个方法进行校验；
6.提供了全局范围、包范围和Action范围的国际化资源文件管理实现
struts2是如何启动的？
struts2框架是通过Filter启动的，即StrutsPrepareAndExecuteFilter，此过滤器为struts2的核心过滤器；
StrutsPrepareAndExecuteFilter的init()方法中将会读取类路径下默认的配置文件struts.xml完成初始化操作。
struts2读取到struts.xml的内容后，是将内容封装进javabean对象然后存放在内存中，以后用户的每次请求处理将使用内存中的数据，而不是每次请求都读取struts.xml文件。
struts2框架的核心控制器是什么？它有什么作用？
1）Struts2框架的核心控制器是StrutsPrepareAndExecuteFilter。
2）作用：负责拦截由<url-pattern>/*</url-pattern>指定的所有用户请求，当用户请求到达时，该Filter会过滤用户的请求。
默认情况下，如果用户请求的路径不带后缀或者后缀以.action结尾，这时请求将被转入struts2框架处理，
否则struts2框架将略过该请求的处理。 可以通过常量"struts.action.extension"修改action的后缀，
如：<constant name="struts.action.extension" value="do"/>
如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。
<constant name="struts.action.extension" value="do,Go"/>
struts2配置文件的加载顺序:
struts.xml ——> struts.properties，常量可以在struts.xml或struts.properties中配置，如果在多个文件中配置了同一个常量，则后一个文件中配置的常量值会覆盖前面文件中配置的常量值.
struts.xml文件的作用：通知Struts2框架加载对应的Action资源
struts2是如何管理action的？这种管理方式有什么好处？
struts2框架中使用包来管理Action，包的作用和java中的类包是非常类似的。
主要用于管理一组业务功能相关的action。在实际应用中，我们应该把一组业务功能相关的Action放在同一个包下。
struts2默认能解决get和post提交方式的乱码问题吗？
不能。struts.i18n.encoding=UTF-8属性值只能解析POST提交下的乱码问题
ActionContext、ServletContext、pageContext的区别？
1）ActionContext是当前的Action的上下文环境，通过ActionContext可以获取到request、session、ServletContext等与Action有关的对象的引用；
2）ServletContext是域对象，一个web应用中只有一个ServletContext，生命周期伴随整个web应用；
3）pageContext是JSP中的最重要的一个内置对象，可以通过pageContext获取其他域对象的应用，同时它是一个域对象，作用范围只针对当前页面，当前页面结束时，pageContext销毁，生命周期是JSP四个域对象中最小的。
==========================================================
Spring 面试题
1. Spring框架有哪些模块？
Spring框架由七个模块组成组成，这7个模块(或组件)均可以单独存在，也可以与其它一个或多个模块联合使用，如下所示：
(1)Spring 核心容器——IoC容器
(2)Spring AOP
(3)Spring ORM
(4)Spring DAO
(5)Spring WEB
(6)Spring上下文（Context）
(7)Spring MVC
2. 为什么要使用Spring框架，它有什么优点？
(1)轻量级的框架
(2)非侵入性的
(3)可以整合其它的框架，比如Struts，Hibernate等
(4)可以提供事务管理
4．怎么使用Spring配置事务?
Spring同时支持编程式事务策略和声明式事务策略，大部分时候都采用声明式事务策略。
声明式事务管理的配置方式，通常有以下4种：
(1)使用TransactionProxyFactoryBean为目标Bean生成事务代理的配置。此方式是最传统、配置文件最臃肿、最难以阅读的方式。
(2)采用Bean继承的事务代理配置方式，比较简洁，但依然是增量式配置。
(3)采用BeanNameAutoProxyCreator，根据Bean Name自动生成事务代理的方式。这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所理解。但这种方式避免了增量式配置，效果非常不错。
(4)采用DefaultAdvisorAutoProxyCreator，直接利用Spring的AOP框架配置事务代理的方式，效果非常不错，只是这种配置方式的可读性不如第3种方式。
5．请你谈谈SSH整合
SSH整合：
(1) Struts（表示层）+ Spring（业务层）+ Hibernate（持久层）
(2) Struts：Struts是一个表示层框架，主要作用是界面展示、接收请求和分发请求。
在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。
(View：沿用JSP，HTTP，Form，Tag，Resourse；Controller：ActionServlet，struts-config.xml，Action)
(3) Hibernate：
Hibernate是一个持久层框架，它只负责与关系数据库的操作。
(4) Spring：Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。
9．Spring里如何定义Hibernate?Mapping？
添加hibernate mapping 文件到WEB-INF目录下的applicationContext.xml文件中。
10．解释一下Dependency Injection(DI,依赖注入)和IoC(Inversion of Control,控制反转)
1.依赖注入DI是一种设计模式，通常也称作控制反转，尽管在技术上来讲，依赖注入是一个IoC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一种特殊的能力。例如，把一个数据库连接以参数的形式传到一个对象的构造函数里面而不是在那个对象内部自行创建一个连接。
2.控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖。
3.应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。
也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取它依赖的对象的引用，这个责任的反转。
13.Spring中的核心类有那些，各有什么作用?
BeanFactory：产生一个新的实例，可以实现单例模式。
BeanWrapper：提供统一的get及set方法。
ApplicationContext：提供Spring框架的实现，包括BeanFactory的所有功能。
14.什么是AOP，AOP的作用是什么?
面向切面编程(AOP)提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编程(OOP)的不足。
除了类(classes)以外，AOP提供了切面。切面对关注点进行模块化，例如横切多个类型和对象的事务管理。
Spring的一个关键的组件就是AOP框架，可以自由选择是否使用AOP，提供声明式企业服务，特别是为了替代EJB声明式服务。
最重要的服务是声明性事务管理，这个服务建立在Spring的抽象事物管理之上。
允许用户实现自定义切面，用AOP来完善OOP的使用，可以把Spring AOP看作是对Spring的一种增强.
15.使用Spring有什么好处?
(1)Spring能有效地组织你的中间层对象，无论你是否选择使用了EJB。如果你仅仅使用了Struts或其它的包含了J2EE特有APIs的?framework，你会发现Spring关注了遗留问题。
(2)Spring能消除在许多工程上对Singleton的过多使用。
(3)Spring能消除使用各种格式的属性定制文件的需要，在整个工程中，可通过一种一致的方法来进行配置。
(4)Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。
(5)Spring被设计为让使用它创建的应用尽可能少的依赖于它的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。
(6)使用Spring构建的应用程序易于单元测试。
(7)Spring能使EJB的使用成为一个实现选择，而不是应用架构的必然选择。你能选择用POJOs或local?EJBs来实现业务接口，却不会影响调用代码。
(8)Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。
例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。
(9)Spring为数据存取提供了一致的框架，不论是使用JDBC或O/R?mapping产品（如Hibernate）。
16.什么是Spring，它有什么特点?
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
(1)轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布，并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
(2)控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
(3)面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。
它们并不负责其它的系统级关注点，例如日志或事务支持。
(4)容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
(5)框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
比较Hibernate的三种检索策略优缺点?
1.立即检索:
优点：对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象；
缺点：1.select语句太多；2.可能会加载应用程序不需要访问的对象白白浪费许多内存空间；
2.延迟检索：
优点：由应用程序决定需要加载哪些对象，可以避免可执行多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并且能节省内存空间；
缺点：应用程序如果希望访问游离状态代理类实例，必须保证他在持久化状态时已经被初始化；
3.迫切左外连接检索
优点：
1.对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便地冲一个对象导航到与它关联的对象。
2.使用了外连接，select语句数目少；
缺点：
1.可能会加载应用程序不需要访问的对象，白白浪费许多内存空间；
2.复杂的数据库表连接也会影响检索性能；
hibernate里面的sorted collection 和ordered collection有什么区别
sorted collection是在内存中通过java比较器进行排序的
ordered collection是在数据库中通过order by进行排序的
==========================================
spring hibernate struts的笔试面试题
2．Hibernate是如何延迟加载?
1.Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
2.Hibernate3 提供了属性的延迟加载功能,当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、
4．说下Hibernate的缓存机制
1.内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存;
2.二级缓存：
a)应用级缓存;
b)分布式缓存;
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据;
c)第三方缓存的实现;
6．如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多;
2.灵活使用单向一对多关联;
3.不用一对一，用多对一取代;
4.配置对象缓存，不使用集合缓存;
5.一对多集合使用Bag,多对多集合使用Set;
6.继承类使用显式多态;
7.表字段要少，表关联不要怕多，有二级缓存撑腰 ;
7．Struts工作机制？为什么要使用Struts？
工作机制：Struts的工作流程: 在web应用启动时就会加载初始化ActionServlet,ActionServlet从?struts-config.xml文件中读取配置信息,把它们存放到各种配置对象 当ActionServlet接收到一个客户请求时,将执行如下流程;
-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给?ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
=================================================
hibernate 面试题小集
3.说说Hibernate中的update()和saveOrUpdate()的区别，session的load()和get()的区别。
saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：
1. 如果对象在该session中已经被持久化，不进行操作；
2. 对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；
3. 如果session中的另一个对象有相同的标识符抛出一个异常；以上皆不符合则调用update()更新之。
Session.load/get方法均可以根据指定的实体类和id从数据库读取记录，并返回与之对应的实体对象。
session的get()和load()其区别在于：
1. 如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException；
2. load方法可返回实体的代理类实例，而get方法永远直接返回实体类；
3. load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。
hibernate中对象的三种状态?
瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。
处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（Value Object）。
瞬时态:
由new命令开辟内存空间的java对象， eg. Person person =new Person(”amigo”, “女”);
如果没有变量对该对象进行引用，它将被java虚拟机回收。
瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或 saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，
此时该瞬时对象转变成持久化对象。
持久态:
处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。
当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。
持久对象具有如下特点：
1.和session实例关联；
2.在数据库中有与之关联的记录。
脱管态:
当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。
脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。
脱管对象具有如下特点：
1.本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；
2.比瞬时对象多了一个数据库记录标识值。
1.在数据库中条件查询速度很慢的时候,如何优化?
1.建索引;
2.减少表之间的关联;
3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面;
4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据;
===============================
spring面试题
1、简述你对IoC（Inversion of Control）的理解，描述一下Spring中实现DI（Dependency?Injection）的几种方式。
spring的IOC有三种注入方式:
第一是根据属性注入也叫set方法注入；
第二种是根据构造方法进行注入；
第三种是根据注解进行注入，这种方式我认为比较好，方便，要是bean多的话，使用前两种方式会使得配置文件过于臃肿。
3、简单描述Spring?Framework与Struts的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？
答、Spring是完整的一站式框架，而Struts仅是MVC框架，且着重于MVC中的C。
Spring有三种方式整合
Struts：使用Spring的ActionSupport类整合Struts；
使用Spring的DelegatingRequestProcessor覆盖Struts的RequestProcessor；
将Struts Action 管理委托给Spring框架，动作委托最好。
4、Hibernate中的update()和saveOrUpdate()的区别?
答、saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：
1. 如果对象在该session中已经被持久化，不进行操作；
2. 对象的标识符属性(identifier?property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；
3.如果session中的另一个对象有相同的标识符抛出一个异常；?以上皆不符合则调用update()更新之。
struts2的原理
一 工作原理:
在Struts2框架中的处理大概分为以下几个步骤 :
1. 客户端初始化一个指向Servlet容器（例如Tomcat）的请求
2.这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，iteMesh Plugin）
3.接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action
4.如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy(泼若科c)
5 .ActionProxy通过Configuration Manager(康飞科润熊Manager)询问框架的配置文件，找到需要调用的Action类.ActionProxy创建一个ActionInvocation(Action印则k熊)的实例。
6 .ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
7 .一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可 能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper
二 struts2工作流程:
242b0005556ad50f1338.jpg
1、客户端浏览器发出HTTP请求.
2、根据web.xml配置，该请求被FilterDispatcher接收
3、根据struts.xml配置，找到需要调用的Action类和方法， 并通过IoC方式，将值注入给Aciton
4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面
6、返回HTTP响应到客户端浏览器
JSP的运行原理
jsp运行原理.jpg
WEB容器（Servlet引擎）接收到以.jsp为扩展名的URL的访问请求时，它将把该访问请求交给JSP引擎去处理。Tomcat中的JSP引擎就是一个Servlet程序，它负责解释和执行JSP页面。
每个JSP 页面在第一次被访问时，JSP引擎将它翻译成一个Servlet源程序，接着再把这个Servlet源程序编译成Servlet的class类文件，然后再由WEB容器（Servlet引擎）像调用普通Servlet程序一样的方式来装载和解释执行这个由JSP页面翻译成的Servlet程序。
