Struts,Spring,Hibernate三大框架面试参考

曾经终败给现在 2022-08-08 09:07 202阅读 0赞

# 关于Struts #

## 1.Struts1流程： ##

1、客户端浏览器发出HTTP请求。2、根据web.xml配置，该请求被ActionServlet接收。3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。4、是否验证，需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。6、Action返回ActionForward对象，跳转到相应JSP页面或Action。7、返回HTTP响应到客户端浏览器。

## 2.MVC设计模式： ##

modal：“模型” 也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射

## 3.struts2是什么？ ##

struts1是基于JSP和servlet的一个开源的Web应用框架，使用的是MVC的设计模式struts2是基于webwork技术的框架，是sun和webwork公司联手开发的一个功能非常齐全的框架，struts2和struts1没有任何关系，是一个全新的框架

## 4.用自己的话简要阐述struts2的执行流程: ##

Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。  
   
Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。基本简要流程如下：1、客户端浏览器发出HTTP请求。2、根据web.xml配置，该请求被FilterDispatcher接收。3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。6、返回HTTP响应到客户端浏览器。  
1 Action是不是线程安全的？如果不是有什么方式可以保证Action的线程安全？如果是，说明原因  
不是  
声明局部变量，或者扩展RequestProcessor，让每次都创建一个Action，或者在spring中用scope="prototype"来管理

## 5.MVC，分析一下struts是如何实现MVC的 ##

m：JavaBean 或结合 EJB 组件或者pojo构成  
c：Action 来实现  
v：一组 JSP 文件及其标签构成。

## 6.struts中的几个关键对象的作用(说说几个关键对象的作用) ##

Action：控制器类，ActionForm：表单对象，DynaValidatorForm：动态form，ActonMapping：配置文件中action节点的信息......

## 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组件生成动态网页,返回给客户;

### 为什么要用： ###

JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。  
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件

## 8.Struts的validate框架是如何验证的？ ##

在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

## 9.说下Struts的设计模式: ##

MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数 据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对 象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动 态的网页，返回给客户。

## 10.Struts的优点有: ##

1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.  
2. 有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。  
3. 页面导航.页面导航将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。  
4. 提供Exception处理机制 .  
5. 数据库链接池管理  
6. 支持I18N

## 11.Struts的缺点有: ##

一、转到展示层时，需要配置forward，每一次转到展示层，相信大多数都是直接转到jsp，而涉及到转向， 需要配置forward，如果有十个展示层的jsp，需要配置十次struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而tomcate这样的服务器，还必须重新启动服务器，如果业务变更复杂频繁的系统，这样的操作简单不可想象。现在就是这样，几十上百个人同时在线使用我们的系统，大家可以想象一下，我的烦恼有多大。  
二、 Struts 的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。  
三、 测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。  
四、 类型的转换. Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。  
五、 对Servlet的依赖性过强. Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它摆脱不了Servlet容器。  
六、前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。  
七、 对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。  
八、 对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。  
九、 对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能 对应一个事件，struts这种事件方式称为applicationevent，application event和component event相比是一种粗粒度的事件。

Struts重要的表单对象ActionForm是一种对象，它代表了一种应用，这个对象中至少包含几个字段， 这些字段是Jsp页面表单中的input字段，因为一个表单对应一个事件，所以，当我们需要将事件粒度细化到表单中这些字段时，也就是说，一个字段对应一个事件时，单纯使用Struts就不太可能，当然通过结合JavaScript也是可以转弯实现的。

# 关于Spring: #

## 1.spring是什么？ ##

spring是一个集成了许多第三方框架的大杂烩，其核心技术是IOC（控制反转，也称依赖注入）和AOP（面向切面编程）

这个问题，往往也可以通过我们为什么要使用spring这个问题来切入：AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

## 2.说说AOP和IOC的概念以及在spring中是如何应用的 ##

AOP:面向方面编程，ioc：依赖注入；声明式事务和编程式事务积极一些通用部分

## 3.spring的事务有几种方式？谈谈spring事务的隔离级别和传播行为。 ##

声明事务和编程事务  
隔离级别：  
\- DEFAULT使用数据库默认的隔离级别  
\- READ\_UNCOMMITTED会出现脏读，不可重复读和幻影读问题  
\- READ\_COMMITTED会出现重复读和幻影读  
\- REPEATABLE\_READ会出现幻影读  
\- SERIALIZABLE最安全，但是代价最大，性能影响极其严重  
和传播行：  
\- REQUIRED存在事务就融入该事务，不存在就创建事务  
\- SUPPORTS存在事务就融入事务，不存在则不创建事务  
\- MANDATORY存在事务则融入该事务，不存在，抛异常  
\- REQUIRES\_NEW总是创建新事务  
\- NOT\_SUPPORTED存在事务则挂起，一直执行非事务操作  
\- NEVER总是执行非事务，如果当前存在事务则抛异常  
\- NESTED嵌入式事务

## 4.Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理。 ##

getHiberanteTemplate里面提供了save，update，delete，find等方法。  
简单说一个：如果配置了声明式事务，当执行getHibernateTemplate的各种方法的时候，事务会  
自动被加载  
如果没有配置事务，那么以上操作不会真正的被同步到数据库，除非配置了hibernate的  
autocommit=true

## spring的事务有几种方式？谈谈spring事务的隔离级别和传播行为。 ##

spring事务分两种形式，声明式事务和编程式事务，spring提供了一个事务的接口  
PaltformTractionManager接口，针对不同的事务，spring进行了不同的实现,对hibernate事务  
的实现HIbernateTractionManager,对JDBC的JdbcTractionManager，  
DataSourceTractionManager以及JdoTractionManager。接口platformTractionManager提供了三  
个方法，获取事务，提交和回滚的方法。

## spring工作机制及为什么要用? ##

### 工作机制: ###

1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。  
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.  
3.DispatcherServlet请请求提交到目标Controller  
4.Controller进行业务逻辑处理后，会返回一个ModelAndView  
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象  
6.视图对象负责渲染返回给客户端。

### 为什么用： ###

\{AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。  
IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。  
Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。\}

Spring它是一个开源的项目，而且目前非常活跃；它基于IoC（Inversion of Control，反向控制）和AOP的构架多层j2ee系统的框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块；它实现了很优雅的MVC，对不同的数据访问技术提供了统一的接口，采用IoC使得可以很容易的实现bean的装配，提供了简洁的AOP并据此实现Transcation Managment，等等  
优点：  
a. Spring能有效地组织你的中间层对象，不管你是否选择使用了EJB。如果你仅仅使用了Struts或其他为J2EE的 API特制的framework，Spring致力于解决剩下的问题。  
b. Spring能消除在许多工程中常见的对Singleton的过多使用。根据我的经验，这是一个很大的问题，它降低了系统的可测试性和面向对象的程度。  
c. 通过一种在不同应用程序和项目间一致的方法来处理配置文件，Spring能消除各种各样自定义格式的属性文件的需要。曾经对某个类要寻找的是哪个魔法般的 属性项或系统属性感到不解，为此不得不去读Javadoc甚至源编码？有了Spring，你仅仅需要看看类的JavaBean属性。Inversion ofControl的使用（在下面讨论）帮助完成了这种简化。  
d.通过把对接口编程而不是对类编程的代价几乎减少到没有，Spring能够促进养成好的编程习惯。  
e. Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。  
f. 使用Spring构建的应用程序易于单元测试。  
g.Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。  
h. Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适用于许多web应用。例如，Spring能使用AOP提供声明性事务管理而不通过EJB容器，如果你仅仅需要与单个数据库打交道，甚至不需要一个JTA实现。  
i. Spring为数据存取提供了一个一致的框架,不论是使用的是JDBC还是O/R mapping产品（如Hibernate）。  
Spring确实使你能通过最简单可行的解决办法来解决你的问题。而这是有有很大价值的。  
缺点：  
使用人数不多、jsp中要写很多代码、控制器过于灵活，缺少一个公用控制器。

# 关于Hibernate: #

## hibernate是什么？ ##

hibernate是基于ORM对象关系映射（完成对象数据到关系数据映射的机制）实现的,做数据持久化的工具

## Hibernate工作原理及为什么要用？ ##

原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory  
为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

## Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) ##

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many

## Hibernate是如何延迟加载? ##

1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）  
2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

## load()和get()的区别 ##

hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，load默认支持延迟加载，在用到对象中的其他属性数 据时才查询数据库，但是万一数据库中不存在该记录，只能抛异常ObjectNotFoundEcception；所说的load方法抛异常是指在使用该对 象的数据时，数据库中不存在该数据时抛异常，而不是在创建这个对象时。由于session中的缓存对于hibernate来说是个相当廉价的资源，所以在 load时会先查一下session缓存看看该id对应的对象是否存在，不存在则创建代理（load时候之查询一级缓存，不存在则创建代理）。get() 现在一级缓存找，没有就去二级缓存找，没有就去数据库找，没有就返回null ；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

## 谈谈hibernate的延迟加载和openSessionInView ##

延迟加载要在session范围内，用到的时候再加载；opensessioninview是在web层写了一个filter来打开和关闭session，这样就表示在一次request过程中session一直开着，保证了延迟加载在session中的这个前提。

## Hibernate中的update()和saveOrUpdate()的区别. ##

摘自hibernate说明文档：  
saveOrUpdate()做下面的事:  
如果对象已经在本session中持久化了，不做任何事  
如果另一个与本session关联的对象拥有相同的持久化标识(identifier)，抛出一个异常  
如果对象没有持久化标识(identifier)属性，对其调用save()  
如果对象的持久标识(identifier)表明其是一个新实例化的对象，对其调用save()  
如果对象是附带版本信息的（通过<version>或 <timestamp>）并且版本属性的值表明其是一个新实例化的对象，save()它。否则update() 这个对象

## Hibernate工作原理及为什么要用？ ##

### 原理： ###

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的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。