SSH框架面试题

Hibernate工做原理及为何要用？

原理：

1. 读取并解析配置文件
2. 读取并解析映射信息，建立SessionFactory
3. 打开Sesssion
4. 建立事务Transation
5. 持久化操做
6. 提交事务
7. 关闭Session
8. 关闭SesstionFactory

为何要用：

* 对JDBC访问数据库的代码作了封装，大大简化了数据访问层繁琐的重复性代码。
* Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工做
* hibernate使用Java反射机制，而不是字节码加强程序来实现透明性。
* hibernate的性能很是好，由于它是个轻量级框架。映射的灵活性很出色。它支持各类关系数据库，从一对一到多对多的各类复杂关系。

Hibernate是如何延迟加载?

* Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
* Hibernate3 提供了属性的延迟加载功能

当Hibernate在查询数据的时候，数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提升了服务器的性能。
Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体如今表与表之间的关系进行操做，它们都市对对象进行操做，咱们程序中把全部的表与类都映射在一块儿，它们经过配置文件中的many-to-one、one-to-many、many-to-many、

说下Hibernate的缓存机制

* 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
* 二级缓存：

a)应用及缓存

b)分布式缓存

条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据

c) 第三方缓存的实现
Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：

* 属性查询
* 参数查询、命名参数查询
* 关联查询
* 分页查询
* 统计函数

如何优化Hibernate？

* 使用双向一对多关联，不使用单向一对多
* 灵活使用单向一对多关联
* 不用一对一，用多对一取代
* 配置对象缓存，不使用集合缓存
* 一对多集合使用Bag,多对多集合使用Set
* 继承类使用显式多态
* 表字段要少，表关联不要怕多，有二级缓存撑腰

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类组件构成：控制器组件、模型组件、视图组件
Struts的validate框架是如何验证的？
在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

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

单例模式

Factory(工厂模式)：

定义一个基类===》实现基类方法（子类经过不一样的方法）===》定义一个工厂类（生成子类实例）

===》开发人员调用基类方法

Proxy(代理模式)

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 属性和配置文件加入依赖性（协做对象）。而后能够很容易地在须要时替换具备相似接口的协做对象。

网友自出的几道面试题

1、 简述你对IoC（Inversion of Control）的理解，描述一下Spring中实现DI（Dependency Injection）的几种方式。

2、 Spring的Bean有多种做用域，包括：
singleton、prototype、request、session、global session、application、自定义

3、 简单描述Spring Framework与Struts的不一样之处，整合Spring与Struts有哪些方法，哪一种最好，为何？

4、 Hibernate中的update()和saveOrUpdate()的区别

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

Hibernate

1.在数据库中条件查询速度很慢的时候,如何优化?
1.建索引
2.减小表之间的关联
3.优化sql，尽可能让sql很快定位数据，不要让sql作全表查询，应该走索引,把数据量大的表排在前面
4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽可能返回少许数据

[2.在hibernate中进行多表查询,每一个表中各取几个字段,也就是说查询出来的结果集并无一个实体类与之对应,如何解决这个问题?
解决方案一，按照Object[]数据取出数据，而后本身组bean
解决方案二，对每一个表的bean写构造函数，好比表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，而后在hql里面就能够直接生成这个bean了。具体怎么用请看相关文档，我说的不是很清楚。
session.load()和session.get()的区别
Session.load/get方法都可以根据指定的实体类和id从数据库读取记录，并返回与之对应的实体对象。其区别在于：

若是未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。
Load方法可返回实体的代理类实例，而get方法永远直接返回实体类。
load方法能够充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。
Session在加载实体对象时，将通过的过程：

首先，Hibernate中维持了两级缓存。第一级缓存由Session实例维护，其中保持了Session当前全部关联实体的数据，也称为内部缓存。而第二级缓存则存在于SessionFactory层次，由当前全部由本 SessionFactory构造的Session实例共享。出于性能考虑，避免无谓的数据库访问，Session在调用数据库查询功能以前，会先在缓存中进行查询。首先在第一级缓存中，经过实体类型和id进行查找，若是第一级缓存查找命中，且数据状态合法，则直接返回。
以后，Session会在当前“NonExists”记录中进行查找，若是“NonExists”记录中存在一样的查询条件，则返回null。 “NonExists”记录了当前Session实例在以前全部查询操做中，未能查询到有效数据的查询条件（至关于一个查询黑名单列表）。如此一来，若是 Session中一个无效的查询条件重复出现，便可迅速做出判断，从而得到最佳的性能表现。
对于load方法而言，若是内部缓存中未发现有效数据，则查询第二级缓存，若是第二级缓存命中，则返回。
如在缓存中未发现有效数据，则发起数据库查询操做（Select SQL），如通过查询未发现对应记录，则将这次查询的信息在“NonExists”中加以记录，并返回null。
根据映射配置和Select SQL获得的ResultSet，建立对应的数据对象。
将其数据对象归入当前Session实体管理容器（一级缓存）。
执行Interceptor.onLoad方法（若是有对应的Interceptor）。
将数据对象归入二级缓存。
若是数据对象实现了LifeCycle接口，则调用数据对象的onLoad方法。
返回数据对象。
Hibernate的主键生成机制
1) assigned
主键由外部程序负责生成，无需Hibernate参与。
2) hilo
经过hi/lo 算法实现的主键生成机制，须要额外的数据库表保存主键生成历史状态。
3) seqhilo
与hilo 相似，经过hi/lo 算法实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。
4) increment
主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，以后每次须要生成主键的时候将此值加1做为主键。这种方式可能产生的问题是：若是当前有多个实例访问同一个数据库，那么因为各个实例各自维护主键状态，不一样实例可能生成一样的主键，从而形成主键重复异常。所以，若是同一数据库有多个实例访问，此方式必须避免使用。
5) identity
采用数据库提供的主键生成机制。如DB二、SQL Server、MySQL中的主键生成机制。
6) sequence
采用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。
7) native
由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种做为主键生成方式。
8) uuid.hex
由Hibernate基于128 位惟一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）做为主键。
9) uuid.string
与uuid.hex 相似，只是生成的主键未进行编码（长度16）。在某些数据库中可能出现问题（如PostgreSQL）。
10) foreign
使用外部表的字段做为主键。通常而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。
这10中生成OID标识符的方法,increment 比较经常使用,把标识符生成的权力交给Hibernate处理.可是当同时多个Hibernate应用操做同一个数据库,甚至同一张表的时候.就推荐使用identity 依赖底层数据库实现,可是数据库必须支持自动增加,固然针对不一样的数据库选择不一样的方法.若是你不能肯定你使用的数据库具体支持什么的状况下.能够选择用native 让Hibernate来帮选择identity,sequence,或hilo.
另外因为经常使用的数据库，如Oracle、DB二、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。咱们能够在数据库提供的主键生成机制上，采用generator-class=native的主键生成方式。
不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，大量并发insert数据时可能会引发表之间的互锁。数据库提供的主键生成机制，每每是经过在一个内部表中保存当前主键状态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），以后每次插入数据会读取这个最大值，而后加上递增量做为新记录的主键，以后再把这个新的最大值更新回内部表中，这样，一次Insert操做可能致使数据库内部屡次表读写操做，同时伴随的还有数据的加锁解锁操做，这对性能产生了较大影响。所以，对于并发Insert要求较高的系统，推荐采用uuid.hex 做为主键生成机制

myeclipse 加入Hibernate的全过程

1.Db-browers加入配置链接
2.新建工程
3.加入hibernate环境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置

hibernate的核心类是什么，它们的相互关系是什么?重要的方法是什么?

Configuration
SessionFactory
Session以下方法
Save
load
Update
Delete
Query q=CreateQuery(“from Customer where customerName=:customerName”)
beginTransaction
close
Transaction
Commit()

Hibernate中数据表映射关系主要有什么类型

one-to-many
inverse:主控方，外键的关系有谁控制
inverse=false 是主控方，外键是由它控制的
inverse=true 是被控方，外键与它不要紧
要想实现主控方的控制必须将被控方做为主控方的属性
cascade:级联
主表增从表增
主表修从表修
主表删从表删
lazy:延迟
lazy=false：一下将全部的内容取出，不延时(经常使用)
lazy=true：取出部份内容，其他内容动态去取
经过get能够取出对方的全部内容

Hibernate中Criteria和DetachedCriteria的做用是什么

Criteria c=session.createCriteria(Customer.class);
//设置条件
c.add(Expression.ge(“字段名”,”值对象”))
ge:>=
gt:>
le:<=
lt:<
eq:=
//排序
c.addOrder(Order.asc(“字段名”))
//分页
c.setFirstResult(1)//从第2行开始提取
c.setMaxResults(5)//返回5行

DetachedCriteria产生时不须要session
DetachedCriteria dc= DetachedCriteria.forClass(Customer.class)
Criteria c=Dc.getExecutableCriteria(session)

Hibernate中Query对象的使用

1 个或多个属性查询:
Query query=session.createQuery(”select customername,customerid from Customer”)
List l=query.list();
For(int i=0;i {
Obejct[] object=(Object[])l.get(i);
Object[0] object[1]
}
}
分组: “select count(*),productname from Product group by productname order by productname”
取值与属性同样
配置的查询,在*.hbm.xml中

from Product where productid=:productid
]]>

Query query=session.getNamedQuery(sql);
联接1
”from Customer as customer join fetch customer.buySet”：将多的放到buySet属性中，得出的结是Customer有一个，Buy有多个
联接2
“from Customer as customer join customer.buySet”:得出的对象,customer与buy是1对1
子查询:
”from Customer as customer where (select count(*) from customer.buySet)>1″

Hibernate如何实现数据表映射的继承关系