SSH三大框架笔面试总结

时间 2019-11-15

原文原文链接

Java工程师（程序员）面题html

Struts,Spring,Hibernate三大框架前端

1.Hibernate工做原理及为何要用？ java

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

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

2．Hibernate是如何延迟加载? web

1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）面试

2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提升了服务器的性能。 spring

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

类与类之间的关系主要体如今表与表之间的关系进行操做，它们都是对对象进行操做，咱们程序中把全部的表与类都映射在一块儿，它们经过配置文件中的many-to-one、one-to-many、many-to-many 数据库

4.Struts1流程：

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

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

5.struts是什么？

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

6.spring是什么？

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

7.hibernate是什么？

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

8.JSF是什么？

JavaServer Face是基于组件的web开发框架，跟sturts差很少的框架

9.数据库里面的索引和约束是什么?

索引是为了提升数据的检索速度，索引是创建在数据表上，根据一个或多个字段创建的约束是为了保持数据的完整性，约束有非空约束，主键约束，外键约束等等。

10.spring是什么

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

11.用本身的话简要阐述struts2的执行流程。

Struts 2框架自己大体能够分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是须要用户来本身实现的。用户在开发Action和业务逻辑组件的同时，还须要编写相关的配置文件，供核心控制器FilterDispatcher来使用。

Struts 2的工做流程相对于Struts 1要简单，与WebWork框架基本相同，因此说Struts 2是WebWork的升级版本。基本简要流程以下：一、客户端浏览器发出HTTP请求。二、根据web.xml配置，该请求被FilterDispatcher接收。三、根据struts.xml配置，找到须要调用的Action类和方法，并经过IoC方式，将值注入给Aciton。四、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。五、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。六、返回HTTP响应到客户端浏览器。

1 Action是否是线程安全的？若是不是有什么方式能够保证Action的线程安全？若是是，说明缘由

不是

声明局部变量，或者扩展RequestProcessor，让每次都建立一个Action，或者在spring中用scope="prototype"来管理

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

m：JavaBean 或结合 EJB 组件或者pojo构成

c：Action 来实现

v：一组 JSP 文件及其标签构成。

3.struts中的几个关键对象的做用(说说几个关键对象的做用)

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

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

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

5.Hibernate有哪几种查询数据的方式

hql查询，sql查询，条件查询

6.load()和get()的区别

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

7.谈谈hibernate的延迟加载和openSessionInView

延迟加载要在session范围内，用到的时候再加载；opensessioninview是在web层写了一个

filter来打开和关闭session，这样就表示在一次request过程当中session一直开着，保证了延迟

加载在session中的这个前提。

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

声明事务和编程事务

隔离级别：

- DEFAULT使用数据库默认的隔离级别

- READ_UNCOMMITTED会出现脏读，不可重复读和幻影读问题

- READ_COMMITTED会出现重复读和幻影读

- REPEATABLE_READ会出现幻影读

- SERIALIZABLE最安全，可是代价最大，性能影响极其严重

和传播行：

- REQUIRED存在事务就融入该事务，不存在就建立事务

- SUPPORTS存在事务就融入事务，不存在则不建立事务

- MANDATORY存在事务则融入该事务，不存在，抛异常

- REQUIRES_NEW老是建立新事务

- NOT_SUPPORTED存在事务则挂起，一直执行非事务操做

- NEVER老是执行非事务，若是当前存在事务则抛异常

- NESTED嵌入式事务

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

摘自hibernate说明文档：

saveOrUpdate()作下面的事:

若是对象已经在本session中持久化了，不作任何事

若是另外一个与本session关联的对象拥有相同的持久化标识(identifier)，抛出一个异常

若是对象没有持久化标识(identifier)属性，对其调用save()

若是对象的持久标识(identifier)代表其是一个新实例化的对象，对其调用save()

若是对象是附带版本信息的（经过 <version>或 <timestamp>）而且版本属性的值代表其是一个新实例化的对象，save()它。不然update() 这个对象

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

getHiberanteTemplate里面提供了save，update，delete，find等方法。

简单说一个：若是配置了声明式事务，当执行getHibernateTemplate的各类方法的时候，事务会

自动被加载

若是没有配置事务，那么以上操做不会真正的被同步到数据库，除非配置了hibernate的

autocommit=true

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

spring事务分两种形式，声明式事务和编程式事务，spring提供了一个事务的接口

PaltformTractionManager接口，针对不一样的事务，spring进行了不一样的实现,对hibernate事务

的实现HIbernateTractionManager,对JDBC的JdbcTractionManager，

DataSourceTractionManager以及JdoTractionManager。接口platformTractionManager提供了三

个方法，获取事务，提交和回滚的方法。

******************************************************************************

分享面试题二】Spring,hibernate,struts的面试笔试题（含答案）

（声明：这里不是为其余商业利益，是为学习讨论使用）

【郑重声明】：单纯接分将被删帖，但愿你们有本身的感触

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

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) 第三方缓存的实现

5． Hibernate的查询方式

Sql、Criteria,object comptosition

Hql：

一、属性查询

二、参数查询、命名参数查询

三、关联查询

四、分页查询

五、统计函数

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

为何要用：

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

Struts,Spring,Hibernate优缺点

Struts跟Tomcat、Turbine等诸多Apache项目同样，是开源软件，这是它的一大优势。使开发者能更深刻的了解其内部实现机制。 Struts开放源码框架的建立是为了使开发者在构建基于Java Servlet和JavaServer Pages（JSP）技术的Web应用时更加容易。Struts框架为开放者提供了一个统一的标准框架，经过使用Struts做为基础，开发者可以更专一于应用程序的商业逻辑。Struts框架自己是使用Java Servlet和JavaServer Pages技术的一种Model-View-Controller（MVC）实现.

具体来说,

Struts的优势有:

1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.

2. 有丰富的tag能够用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提升开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的经常使用标记外，不多开发本身的标记，或许Struts是一个很好的起点。

3. 页面导航.页面导航将是从此的一个发展方向，事实上，这样作，使系统的脉络更加清晰。经过一个配置文件，便可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤为是当另外一批开发者接手这个项目时，这种优点体现得更加明显。

4. 提供Exception处理机制 .

5. 数据库连接池管理

6. 支持I18N

缺点:

1、转到展现层时，须要配置forward，每一次转到展现层，相信大多数都是直接转到jsp，而涉及到转向，须要配置forward，若是有十个展现层的jsp，须要配置十次struts，并且还不包括有时候目录、文件变动，须要从新修改forward，注意，每次修改配置以后，要求从新部署整个项目，而tomcate这样的服务器，还必须从新启动服务器，若是业务变动复杂频繁的系统，这样的操做简单不可想象。如今就是这样，几十上百我的同时在线使用咱们的系统，你们能够想象一下，个人烦恼有多大。

2、 Struts 的Action必需是thread－safe方式，它仅仅容许一个实例去处理全部的请求。因此action用到的全部的资源都必需统一同步，这个就引发了线程安全的问题。

3、测试不方便. Struts的每一个Action都同Web层耦合在一块儿，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase能够实现它的单元测试。

4、类型的转换. Struts的FormBean把全部的数据都做为String类型，它能够使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，并且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是很是困难的。

5、对Servlet的依赖性过强. Struts处理Action时必须要依赖ServletRequest 和ServletResponse，全部它摆脱不了Servlet容器。

6、前端表达式语言方面.Struts集成了JSTL，因此它主要使用JSTL的表达式语言来获取数据。但是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。

7、对Action执行的控制困难. Struts建立一个Action，若是想控制它的执行顺序将会很是困难。甚至你要从新去写Servlet来实现你的这个功能需求。

8、对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操做。

9、对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，struts这种事件方式称为application event，application event和component event相比是一种粗粒度的事件。

Struts重要的表单对象ActionForm是一种对象，它表明了一种应用，这个对象中至少包含几个字段，这些字段是Jsp页面表单中的input字段，由于一个表单对应一个事件，因此，当咱们须要将事件粒度细化到表单中这些字段时，也就是说，一个字段对应一个事件时，单纯使用Struts就不太可能，固然经过结合JavaScript也是能够转弯实现的。

2．Hibernate

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了很是轻量级的对象封装，使得Java程序员能够为所欲为的使用对象编程思惟来操纵数据库。

Hibernate能够应用在任何使用JDBC的场合，既能够在Java的客户端程序实用，也能够在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate能够在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

大多数开发机构常常采起建立各自独立的数据持久层。一旦底层的数据结构发生改变，那么修改应用的其他部分使之适应这种改变的代价将是十分巨大的。 Hibernate适时的填补了这一空白，它为Java应用提供了一个易用的、高效率的对象关系映射框架。hibernate是个轻量级的持久性框架，功能却很是丰富。

优势：

a.Hibernate 使用 Java 反射机制而不是字节码加强程序来实现透明性。

b.Hibernate 的性能很是好，由于它是个轻量级框架。映射的灵活性很出色。

c.它支持各类关系数据库，从一对一到多对多的各类复杂关系。

缺点：

它限制您所使用的对象模型。(例如，一个持久性类不能映射到多个表)其独有的界面和可怜的市场份额也让人不安，尽管如此，Hibernate 仍是以其强大的发展动力减轻了这些风险。其余的开源持久性框架也有一些，不过都没有 Hibernate 这样有市场冲击力。

上面回贴情绪有点激动，但愿谅解，我不是由于有人批评Hibernate而感到不快，而是由于帖子里面的观点实在让我以为荒谬。无论以为 Hibernate好也吧，很差也吧，我惟一以为遗憾的是，在中文论坛里面找不到一个对Hibernate的真正高水平的评价。在TSS上有一个关于 Hibernate的hot thread，跟了几百贴，其中包括Hibernate做者Gavin和LiDO JDO的CTO，对于JDO和Hibernate有过一些激烈的争论，我曾经耐心的看了一遍，仍然没有发现针对Hibernate真正有力的攻击，那些所谓的攻击无非针对Hibernate没有一个GUI的配置工具，没有商业公司支持，没有标准化等等这些站不住脚的理由。

补充几点个人意见：

1、Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate能够用在任何JDBC能够使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至能够是BMP里面的访问数据库的代码。从这个意义上来讲，Hibernate和EB不是一个范畴的东西，也不存在非此即彼的关系。

2、Hibernate是一个和JDBC密切关联的框架，因此Hibernate的兼容性和JDBC驱动，和数据库都有必定的关系，可是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。

3、Hibernate不能用来直接和Entity Bean作对比，只有放在整个J2EE项目的框架中才能比较。而且即便是放在软件总体框架中来看，Hibernate也是作为JDBC的替代者出现的，而不是Entity Bean的替代者出现的，让我再列一次我已经列n次的框架结构：

传统的架构：

1) Session Bean <-> Entity Bean <-> DB

为了解决性能障碍的替代架构：

2) Session Bean <-> DAO <-> JDBC <-> DB

使用Hibernate来提升上面架构的开发效率的架构：

3) Session Bean <-> DAO <-> Hibernate <-> DB

就上面3个架构来分析：

一、内存消耗：采用JDBC的架构2无疑是最省内存的，Hibernate的架构3次之，EB的架构1最差。

二、运行效率：若是JDBC的代码写的很是优化，那么JDBC架构运行效率最高，可是实际项目中，这一点几乎作不到，这须要程序员很是精通JDBC，运用 Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的状况下采用结果集cache等等。而通常状况下程序员是作不到这一点的。所以Hibernate架构表现出最快的运行效率。 EB的架构效率会差的很远。

三、开发效率：在有JBuilder的支持下以及简单的项目，EB架构开发效率最高，JDBC次之，Hibernate最差。可是在大的项目，特别是持久层关系映射很复杂的状况下，Hibernate效率高的惊人，JDBC次之，而EB架构极可能会失败。

四、分布式，安全检查，集群，负载均衡的支持

因为有SB作为Facade，3个架构没有区别。

4、EB和Hibernate学习难度在哪里？

EB的难度在哪里？不在复杂的XML配置文件上，而在于EB运用稍微不慎，就有严重的性能障碍。因此难在你须要学习不少EJB设计模式来避开性能问题，需要学习App Server和EB的配置来优化EB的运行效率。作EB的开发工做，程序员的大部分精力都被放到了EB的性能问题上了，反而没有更多的精力关注自己就主要投入精力去考虑的对象持久层的设计上来。

Hibernate难在哪里？不在Hibernate自己的复杂，实际上Hibernate很是的简单，难在Hibernate太灵活了。

当你用EB来实现持久层的时候，你会发现EB实在是太笨拙了，笨拙到你根本没有什么能够选择的余地，因此你根本就不用花费精力去设计方案，去平衡方案的好坏，去费脑筋考虑选择哪一个方案，由于只有惟一的方案摆在你面前，你只能这么作，没得选择。

Hibernate相反，它太灵活了，相同的问题，你至少能够设计出十几种方案来解决，因此特别的犯难，究竟用这个，仍是用那个呢？这些方案之间到底有什么区别呢？他们的运行原理有什么不一样？运行效率哪一个比较好？光是主键生成，就有七八种方案供你选择，你为难不为难？集合属性能够用Set，能够用 List，还能够用Bag，到底哪一个效率高，你为难不为难？查询能够用iterator，能够用list，哪一个好，有什么区别？你为难不为难？复合主键你能够直接在hbm里面配置，也能够自定义CustomerType，哪一种比较好些？你为难不为难？对于一个表，你能够选择单一映射一个对象，也能够映射成父子对象，还能够映射成两个1:1的对象，在什么状况下用哪一种方案比较好，你为难不为难？

这个列表能够一直开列下去，直到你不想再看下去为止。当你面前摆着无数的眼花缭乱的方案的时候，你会以为幸福呢？仍是悲哀呢？若是你是一个负责的程序员，那么你必定会仔细研究每种方案的区别，每种方案的效率，每种方案的适用场合，你会以为你已经陷入进去拔不出来了。若是是用EB，你第一秒种就已经作出了决定，根本没得选择，好比说集合属性，你只能用Collection，若是是Hibernate，你会在Bag，List和Set之间来回犹豫不决，甚至搞不清楚的话，程序都没有办法写。

3． 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 of Control的使用（在下面讨论）帮助完成了这种简化。

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中要写不少代码、控制器过于灵活，缺乏一个公用控制器。

6. Java web部分

一、Tomcat的优化经验

答:去掉对web.xml的监视，把jsp提早编辑成Servlet。

有富余物理内存的状况，加大tomcat使用的jvm的内存

一、HTTP请求的GET与POST方式的区别

（1）get是从服务器上获取数据，post是向服务器传送数据。

在客户端，Get方式在经过URL提交数据，数据在URL中能够看到；POST方式，数据放置在HTML HEADER内提交。

（2）对于get方式，服务器端用Request.QueryString获取变量的值，对于post方式，服务器端用Request.Form获取提交的数据。

（3） GET方式提交的数据最多只能有1024字节，而POST则没有此限制。

（4）安全性问题。正如在（1）中提到，使用 Get 的时候，参数会显示在地址栏上，而 Post 不会。因此，若是这些数据是中文数据并且是非敏感数据，那么使用 get；若是用户输入的数据不是中文字符并且包含敏感数据，那么仍是使用 post为好。

6二、解释一下什么是servlet;

答:servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。

一、说一说Servlet的生命周期?

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。

web容器加载servlet，生命周期开始。经过调用servlet的init()方法进行servlet的初始化。经过调用service()方法实现，根据请求的不一样调用不一样的do***()方法。结束服务，web容器调用servlet的destroy()方法。

四、Servlet的基本架构

public class ServletName extends HttpServlet {

public void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

}

public void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

}

三、SERVLET API中forward() 与redirect()的区别？

答:前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是彻底的跳转，浏览器将会获得跳转的地址，并从新发送请求连接。这样，从浏览器的地址栏中能够看到跳转后的连接地址。因此，前者更加高效，在前者能够知足须要时，尽可能使用forward()方法，而且，这样也有助于隐藏实际的连接。在有些状况下，好比，须要跳转到一个其它服务器上的资源，则必须使用

sendRedirect()方法。

60、什么状况下调用doGet()和doPost()？

Jsp页面中的FORM标签里的method属性为get时调用doGet()，为post时调用doPost()。

6六、Request对象的主要方法：

setAttribute(String name,Object)：设置名字为name的request的参数值

getAttribute(String name)：返回由name指定的属性值

getAttributeNames()：返回request对象全部属性的名字集合，结果是一个枚举的实例

getCookies()：返回客户端的全部Cookie对象，结果是一个Cookie数组

getCharacterEncoding()：返回请求中的字符编码方式

getContentLength()：返回请求的Body的长度

getHeader(String name)：得到HTTP协议定义的文件头信息

getHeaders(String name)：返回指定名字的request Header的全部值，结果是一个枚举的实例

getHeaderNames()：返回因此request Header的名字，结果是一个枚举的实例

getInputStream()：返回请求的输入流，用于得到请求中的数据

getMethod()：得到客户端向服务器端传送数据的方法

getParameter(String name)：得到客户端传送给服务器端的有name指定的参数值

getParameterNames()：得到客户端传送给服务器端的全部参数的名字，结果是一个枚举的实例

getParametervalues(String name)：得到有name指定的参数的全部值

getProtocol()：获取客户端向服务器端传送数据所依据的协议名称

getQueryString()：得到查询字符串

getRequestURI()：获取发出请求字符串的客户端地址

getRemoteAddr()：获取客户端的IP地址

getRemoteHost()：获取客户端的名字

getSession([Boolean create])：返回和请求相关Session

getServerName()：获取服务器的名字

getServletPath()：获取客户端所请求的脚本文件的路径

getServerPort()：获取服务器的端口号

removeAttribute(String name)：删除请求中的一个属性

1九、forward 和redirect的区别

forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，而后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，因此它的地址栏中仍是原来的地址。

redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器从新去请求那个地址，通常来讲浏览器会用刚才请求的全部参数从新请求，因此session,request参数均可以获取。

四、request.getAttribute() 和 request.getParameter() 有何区别?

1.getAttribute是取得jsp中用setAttribute設定的attribute

2.parameter获得的是string；attribute获得的是object

3.request.getParameter ()方法传递的数据，会从Web客户端传到Web服务器端，表明HTTP请求数据；request.setAttribute()和 getAttribute()方法传递的数据只会存在于Web容器内部，在具备转发关系的Web组件之间共享。即 request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取 http提交过来的数据。

1. jsp有哪些内置对象?做用分别是什么? 分别有什么方法？

答:JSP共有如下9个内置的对象：

request 用户端请求，此请求会包含来自GET/POST请求的参数

response 网页传回用户端的回应

pageContext 网页的属性是在这里管理

session 与请求有关的会话期

application servlet 正在执行的内容

out 用来传送回应的输出

config servlet的构架部件

page JSP网页自己

exception 针对错误网页，未捕捉的例外

request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，而且提供了几个用于获取cookie, header, 和session数据的有用的方法。

response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等）

out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。

pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各类范围的名字空间、servlet相关的对象的API，而且包装了通用的servlet相关功能的方法。

session表示一个请求的javax.servlet.http.HttpSession对象。Session能够存贮用户的状态信息

applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息

config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。

page表示从该页面产生的一个servlet实例

2. jsp有哪些动做?做用分别是什么?

（这个问题彷佛不重要，不明白为什么有此题）

答:JSP共有如下6种基本动做

jsp:include：在页面被请求的时候引入一个文件。

jsp:useBean：寻找或者实例化一个JavaBean。

jsp:setProperty：设置JavaBean的属性。

jsp:getProperty：输出某个JavaBean的属性。

jsp:forward：把请求转到一个新的页面。

jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

5九、JSP的经常使用指令

isErrorPage(是否能使用Exception对象)，isELIgnored(是否忽略表达式)

3. JSP中动态INCLUDE与静态INCLUDE的区别？

答：动态INCLUDE用jsp:include动做实现

<jsp:include page=included.jsp flush=true />它老是会检查所含文件中的变化，适合用于包含动态页面，而且能够带参数静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面 <%@ include file=included.htm %>

四、两种跳转方式分别是什么?有什么区别?

（下面的回答严重错误，应该是想问forward和sendRedirect 的区别，毕竟出题的人不是专业搞文字艺术的人，可能表达能力并不见得很强，用词不必定精准，加之其自身的技术面也可能存在一些问题，不必定真正将他的意思表达清楚了，严格意思上来说，一些题目可能根本就无人能答，因此，答题时要掌握主动，只要把本身知道的表达清楚就够了，而不要去推敲原始题目的具体含义是什么，不要一味想着是在答题）

答：有两种，分别为：

<jsp:include page=included.jsp flush=true>

<jsp:forward page= nextpage.jsp/>

前者页面不会转向include所指的页面，只是显示该页的结果，主页面仍是原来的页面。执行完后还会回来，至关于函数调用。而且能够带参数.后者彻底转向新页面，不会再回来。至关于go to 语句。

6三、页面间对象传递的方法

request，session，application，cookie等

6四、JSP和Servlet有哪些相同点和不一样点，他们之间的联系是什么？

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不一样点在于，Servlet的应用逻辑是在Java文件中，而且彻底从表示层中的HTML里分离开来。而JSP的状况是Java和HTML能够组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

一、MVC的各个部分都有那些技术来实现?如何实现?

答:MVC是Model－View－Controller的简写。Model 表明的是应用的业务逻辑（经过JavaBean，EJB组件实现）， View 是应用的表示面（由JSP页面产生），Controller 是提供应用的处理过程控制（通常是一个Servlet），经过这种设计模型把应用逻辑，处理过程和显示逻辑分红不一样的组件实现。这些组件能够进行交互和重用。

6八、咱们在web应用开发过程当中常常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串？

Public String translate (String str) {

String tempStr = "";

try {

tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");

tempStr = tempStr.trim();

}

catch (Exception e) {

System.err.println(e.getMessage());

}

return tempStr;

}

1．如今输入n个数字，以逗号，分开；而后可选择升或者降序排序；按提交键就在另外一页面显示按什么排序，结果为，提供reset

7. 实际项目开发

一、在eclipse中调试时，怎样查看一个变量的值？

在要查看的变量前先设置断点，而后选中变量，右键选debug as-->Java Application，打开debug透视图，这时在Variables窗口中能够看到变量当前的值。

若是是局部变量，也能够在局部变量窗口中查看。

要知道一个方法被调用的方法调用链，能够在方法栈中查看。

二、大家公司使用的代码配置管理工具是什么？

除了说之前使用cvs，如今新项目使用svn了，还简要说一下使用的过程，若是有可能，还说说仓库的概念和如何使用锁之类的细节。

三、大家的项目总金额多少，多少人开发，总共花了多少个月？

像巴巴运动网这种规模的项目，能够说是四、5我的、开发了四、5个月，费用则是四、50万。按每人每个月两万收入去计算，就差很少了。

7. 数据库部分

一、用两种方式根据部门号从高到低，工资从低到高列出每一个员工的信息。

employee:

eid,ename,salary,deptid;

select * from employee order by deptid desc,salary

二、列出各个部门中工资高于本部门的平均工资的员工数和部门号，并按部门号排序

建立表：

mysql> create table employee921(id int primary key auto_increment,name varchar(5

0),salary bigint,deptid int);

插入实验数据：

mysql> insert into employee921 values(null,'zs',1000,1),(null,'ls',1100,1),(null

,'ww',1100,1),(null,'zl',900,1) ,(null,'zl',1000,2), (null,'zl',900,2) ,(null,'z

l',1000,2) , (null,'zl',1100,2);

编写sql语句：

（）select avg(salary) from employee921 group by deptid;

（）mysql> select employee921.id,employee921.name,employee921.salary,employee921.dep

tid tid from employee921 where salary > (select avg(salary) from employee921 where deptid = tid);

效率低的一个语句，仅供学习参考使用（在group by以后不能使用where，只能使用having，在group by以前能够使用where，即表示对过滤后的结果分组）：

mysql> select employee921.id,employee921.name,employee921.salary,employee921.dep

tid tid from employee921 where salary > (select avg(salary) from employee921 group by deptid having deptid = tid);

（）select count(*) ,tid

from (

select employee921.id,employee921.name,employee921.salary,employee921.deptid tid

from employee921

where salary >

(select avg(salary) from employee921 where deptid = tid)

) as t

group by tid ;

另一种方式：关联查询

select a.ename,a.salary,a.deptid

from emp a,

(select deptd,avg(salary) avgsal from emp group by deptid ) b

where a.deptid=b.deptid and a.salary>b.avgsal;

一、存储过程与触发器必须讲，常常被面试到?

create procedure insert_Student (_name varchar(50),_age int ,out _id int)

begin

insert into student value(null,_name,_age);

select max(stuId) into _id from student;

end;

call insert_Student('wfz',23,@id);

select @id;

mysql> create trigger update_Student BEFORE update on student FOR EACH ROW

-> select * from student;

触发器不容许返回结果

create trigger update_Student BEFORE update on student FOR EACH ROW

insert into student value(null,'zxx',28);

mysql的触发器目前不能对当前表进行操做

create trigger update_Student BEFORE update on student FOR EACH ROW

delete from articles where id=8;

这个例子不是很好，最好是用删除一个用户时，顺带删除该用户的全部帖子

这里要注意使用OLD.id

触发器用处仍是不少的，好比校内网、开心网、Facebook，你发一个日志，自动通知好友，其实就是在增长日志时作一个后触发，再向通知表中写入条目。由于触发器效率高。而UCH没有用触发器，效率和数据处理能力都很低。

存储过程的实验步骤：

mysql> delimiter |

mysql> create procedure insertArticle_Procedure (pTitle varchar(50),pBid int,out

pId int)

-> begin

-> insert into article1 value(null,pTitle,pBid);

-> select max(id) into pId from article1;

-> end;

-> |

Query OK, 0 rows affected (0.05 sec)

mysql> call insertArticle_Procedure('传智播客',1,@pid);

-> |

Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;

mysql> select @pid;

+------+

| @pid |

+------+

| 3 |

+------+

1 row in set (0.00 sec)

mysql> select * from article1;

+----+--------------+------+

| id | title | bid |

+----+--------------+------+

| 1 | test | 1 |

| 2 | chuanzhiboke | 1 |

| 3 | 传智播客 | 1 |

+----+--------------+------+

3 rows in set (0.00 sec)

触发器的实验步骤：

create table board1(id int primary key auto_increment,name varchar(50),ar

ticleCount int);

create table article1(id int primary key auto_increment,title varchar(50)

,bid int references board1(id));

delimiter |

create trigger insertArticle_Trigger after insert on article1 for each ro

w begin

-> update board1 set articleCount=articleCount+1 where id= NEW.bid;

-> end;

-> |

delimiter ;

insert into board1 value (null,'test',0);

insert into article1 value(null,'test',1);

还有，每插入一个帖子，都但愿将版面表中的最后发帖时间，帖子总数字段进行同步更新，用触发器作效率就很高。下次课设计这样一个案例，写触发器时，对于最后发帖时间可能须要用declare方式声明一个变量，或者是用NEW.posttime来生成。

一、数据库三范式是什么?

第一范式（1NF）：字段具备原子性,不可再分。全部关系型数据库系统都知足第一范式）

数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须做为一个总体，没法区分哪部分是姓，哪部分是名，若是要区分出姓和名，必须设计成两个独立的字段。

第二范式（2NF）：

第二范式（2NF）是在第一范式（1NF）的基础上创建起来的，即知足第二范式（2NF）必须先知足第一范式（1NF）。

要求数据库表中的每一个实例或行必须能够被唯一地区分。一般须要为表加上一个列，以存储各个实例的唯一标识。这个唯一属性列被称为主关键字或主键。

第二范式（2NF）要求实体的属性彻底依赖于主关键字。所谓彻底依赖是指不能存在仅依赖主关键字一部分的属性，若是存在，那么这个属性和主关键字的这一部分应该分离出来造成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分一般须要为表加上一个列，以存储各个实例的唯一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。

第三范式的要求以下：

知足第三范式（3NF）必须先知足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。

因此第三范式具备以下特征：

1，每一列只有一个值

2，每一行都能区分。

3，每个表都不包含其余表已经包含的非主关键字信息。

例如，帖子表中只能出现发帖人的id，而不能出现发帖人的id，还同时出现发帖人姓名，不然，只要出现同一发帖人id的全部记录，它们中的姓名部分都必须严格保持一致，这就是数据冗余。

一、说出一些数据库优化方面的经验?

用PreparedStatement 通常来讲比Statement性能高：一个sql 发给服务器去执行，涉及步骤：语法检查、语义分析，编译，缓存

“inert into user values(1,1,1)”-?二进制

“inert into user values(2,2,2)”-?二进制

“inert into user values(?,?,?)”-?二进制

有外键约束会影响插入和删除性能，若是程序可以保证数据的完整性，那在设计数据库时就去掉外键。（比喻：就比如免检产品，就是为了提升效率，充分相信产品的制造商）

（对于hibernate来讲，就应该有一个变化：empleyee->Deptment对象，如今设计时就成了employee?deptid）

看mysql帮助文档子查询章节的最后部分，例如，根据扫描的原理，下面的子查询语句要比第二条关联查询的效率高：

1. select e.name,e.salary where e.managerid=(select id from employee where name='zxx');

2. select e.name,e.salary,m.name,m.salary from employees e,employees m where

e.managerid = m.id and m.name='zxx';

表中容许适当冗余，譬如，主题帖的回复数量和最后回复时间等

将姓名和密码单独从用户表中独立出来。这能够是很是好的一对一的案例哟！

sql语句所有大写，特别是列名和表名都大写。特别是sql命令的缓存功能，更加须要统一大小写，sql语句?发给oracle服务器?语法检查和编译成为内部指令?缓存和执行指令。根据缓存的特色，不要拼凑条件，而是用?和PreparedStatment

还有索引对查询性能的改进也是值得关注的。

备注：下面是关于性能的讨论举例

4航班 3个城市

m*n

select * from flight,city where flight.startcityid=city.cityid and city.name='beijing';

m + n

select * from flight where startcityid = (select cityid from city where cityname='beijing');

select flight.id,'beijing',flight.flightTime from flight where startcityid = (select cityid from city where cityname='beijing')

二、union和union all有什么不一样?

假设咱们有一个表Student，包括如下字段与数据：

drop table student;

create table student

(

id int primary key,

name nvarchar2(50) not null,

score number not null

);

insert into student values(1,'Aaron',78);

insert into student values(2,'Bill',76);

insert into student values(3,'Cindy',89);

insert into student values(4,'Damon',90);

insert into student values(5,'Ella',73);

insert into student values(6,'Frado',61);

insert into student values(7,'Gill',99);

insert into student values(8,'Hellen',56);

insert into student values(9,'Ivan',93);

insert into student values(10,'Jay',90);

commit;

Union和Union All的区别。

select *

from student

where id < 4

union

select *

from student

where id > 2 and id < 6

结果将是

1 Aaron 78

2 Bill 76

3 Cindy 89

4 Damon 90

5 Ella 73

若是换成Union All链接两个结果集，则返回结果是：

1 Aaron 78

2 Bill 76

3 Cindy 89

4 Damon 90

5 Ella 73

能够看到，Union和Union All的区别之一在于对重复结果的处理。

　　UNION在进行表连接后会筛选掉重复的记录，因此在表连接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最多见的是过程表与历史表UNION。如：

select * from gc_dfys

union

select * from ls_jg_dfys

　　这个SQL在运行时先取出两个表的结果，再用排序空间进行排序删除重复的记录，最后返回结果集，若是表数据量大的话可能会致使用磁盘进行排序。

　而UNION ALL只是简单的将两个结果合并后就返回。这样，若是返回的两个结果集中有重复的数据，那么返回的结果集就会包含重复的数据了。

　从效率上说，UNION ALL 要比UNION快不少，因此，若是能够确认合并的两个结果集中不包含重复的数据的话，那么就使用UNION ALL，

3.分页语句

取出sql表中第31到40的记录（以自动增加ID为主键）

sql server方案1：

select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id

sql server方案2：

select top 10 * from t where id in (select top 40 id from t order by id) order by id desc

mysql方案：select * from t order by id limit 30,10

oracle方案：select * from (select rownum r,* from t where r<=40) where r>30

--------------------待整理进去的内容-------------------------------------

pageSize=20;

pageNo = 5;

1.分页技术1（直接利用sql语句进行分页，效率最高和最推荐的）

mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;

oracle: sql = "select * from " +

"(select rownum r,* from " +

"(select * from articles order by postime desc)" +

"where rownum<= " + pageNo*pageSize +") tmp " +

"where r>" + (pageNo-1)*pageSize;

注释：第7行保证rownum的顺序是肯定的，由于oracle的索引会形成rownum返回不一样的值

简洋提示：没有order by时，rownum按顺序输出，一旦有了order by，rownum不按顺序输出了，这说明rownum是排序前的编号。若是对order by从句中的字段创建了索引，那么，rownum也是按顺序输出的，由于这时候生成原始的查询结果集时会参照索引表的顺序来构建。

sqlserver:sql = "select top 10 * from id not id(select top " + (pageNo-1)*pageSize + "id from articles)"

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql);

ResultSet rs = pstmt.executeQuery()

while(rs.next())

{

out.println(rs.getString(1));

}

2.不可滚动的游标

pageSize=20;

pageNo = 5;

cn = null

stmt = null;

rs = null;

try

{

sqlserver:sql = "select * from articles";

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql);

ResultSet rs = pstmt.executeQuery()

for(int j=0;j<(pageNo-1)*pageSize;j++)

{

rs.next();

}

int i=0;

while(rs.next() && i<10)

{

i++;

out.println(rs.getString(1));

}

cacth(){}

finnaly

{

if(rs!=null)try{rs.close();}catch(Exception e){}

if(stm.........

if(cn............

}

3.可滚动的游标

pageSize=20;

pageNo = 5;

cn = null

stmt = null;

rs = null;

try

{

sqlserver:sql = "select * from articles";

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,...);

//根据上面这行代码的异常SQLFeatureNotSupportedException，就可判断驱动是否支持可滚动游标

ResultSet rs = pstmt.executeQuery()

rs.absolute((pageNo-1)*pageSize)

int i=0;

while(rs.next() && i<10)

{

i++;

out.println(rs.getString(1));

}

cacth(){}

finnaly

{

if(rs!=null)try{rs.close();}catch(Exception e){}

if(stm.........

if(cn............

}

3.用一条SQL语句查询出每门课都大于80分的学生姓名

name kecheng fenshu

张三语文 81

张三数学 75

李四语文 76

李四数学 90

王五语文 81

王五数学 100

王五英语 90

准备数据的sql代码：

create table score(id int primary key auto_increment,name varchar(20),subject varchar(20),score int);

insert into score values

(null,'张三','语文',81),

(null,'张三','数学',75),

(null,'李四','语文',76),

(null,'李四','数学',90),

(null,'王五','语文',81),

(null,'王五','数学',100),

(null,'王五 ','英语',90);

提示：当百思不得其解时，请理想思惟，把小变成大作，把大变成小作，

答案：

A: select distinct name from score where name not in (select distinct name from score where score<=80)

B:select distince name t1 from score where 80< all (select score from score where name=t1);

4.全部部门之间的比赛组合

一个叫department的表，里面只有一个字段name,一共有4条纪录，分别是a,b,c,d,对应四个球对，如今四个球对进行比赛，用一条sql语句显示全部可能的比赛组合.

答：select a.name, b.name

from team a, team b

where a.name < b.name

4.每月份的发生额都比101科目多的科目

请用SQL语句实现：从TestDB数据表中查询出全部月份的发生额都比101科目相应月份的发生额高的科目。请注意：TestDB中有不少科目，都有1－12月份的发生额。

AccID：科目代码，Occmonth：发生额月份，DebitOccur：发生额。

数据库名：JcyAudit，数据集：Select * from TestDB

准备数据的sql代码：

drop table if exists TestDB;

create table TestDB(id int primary key auto_increment,AccID varchar(20), Occmonth date, DebitOccur bigint);

insert into TestDB values

(null,'101','1988-1-1',100),

(null,'101','1988-2-1',110),

(null,'101','1988-3-1',120),

(null,'101','1988-4-1',100),

(null,'101','1988-5-1',100),

(null,'101','1988-6-1',100),

(null,'101','1988-7-1',100),

(null,'101','1988-8-1',100);

--复制上面的数据，故意把第一个月份的发生额数字改小一点

insert into TestDB values

(null,'102','1988-1-1',90),

(null,'102','1988-2-1',110),

(null,'102','1988-3-1',120),

(null,'102','1988-4-1',100),

(null,'102','1988-5-1',100),

(null,'102','1988-6-1',100),

(null,'102','1988-7-1',100),

(null,'102','1988-8-1',100);

--复制最上面的数据，故意把全部发生额数字改大一点

insert into TestDB values

(null,'103','1988-1-1',150),

(null,'103','1988-2-1',160),

(null,'103','1988-3-1',180),

(null,'103','1988-4-1',120),

(null,'103','1988-5-1',120),

(null,'103','1988-6-1',120),

(null,'103','1988-7-1',120),

(null,'103','1988-8-1',120);

--复制最上面的数据，故意把全部发生额数字改大一点

insert into TestDB values

(null,'104','1988-1-1',130),

(null,'104','1988-2-1',130),

(null,'104','1988-3-1',140),

(null,'104','1988-4-1',150),

(null,'104','1988-5-1',160),

(null,'104','1988-6-1',170),

(null,'104','1988-7-1',180),

(null,'104','1988-8-1',140);

--复制最上面的数据，故意把第二个月份的发生额数字改小一点

insert into TestDB values

(null,'105','1988-1-1',100),

(null,'105','1988-2-1',80),

(null,'105','1988-3-1',120),

(null,'105','1988-4-1',100),

(null,'105','1988-5-1',100),

(null,'105','1988-6-1',100),

(null,'105','1988-7-1',100),

(null,'105','1988-8-1',100);

答案：

select distinct AccID from TestDB

where AccID not in

(select TestDB.AccIDfrom TestDB,

(select * from TestDB where AccID='101') as db101

where TestDB.Occmonth=db101.Occmonth and TestDB.DebitOccur<=db101.DebitOccur

);

4.统计每一年每个月的信息

year month amount

1991 1 1.1

1991 2 1.2

1991 3 1.3

1991 4 1.4

1992 1 2.1

1992 2 2.2

1992 3 2.3

1992 4 2.4

查成这样一个结果

year m1 m2 m3 m4

1991 1.1 1.2 1.3 1.4

1992 2.1 2.2 2.3 2.4

提示：这个与工资条很是相似，与学生的科目成绩也很类似。

准备sql语句：

drop table if exists sales;

create table sales(id int auto_increment primary key,year varchar(10), month varchar(10), amount float(2,1));

insert into sales values

(null,'1991','1',1.1),

(null,'1991','2',1.2),

(null,'1991','3',1.3),

(null,'1991','4',1.4),

(null,'1992','1',2.1),

(null,'1992','2',2.2),

(null,'1992','3',2.3),

(null,'1992','4',2.4);

答案1、

select sales.year ,

(select t.amount from sales t where t.month='1' and t.year= sales.year) '1',

(select t.amount from sales t where t.month='1' and t.year= sales.year) '2',

(select t.amount from sales t where t.month='1' and t.year= sales.year) '3',

(select t.amount from sales t where t.month='1' and t.year= sales.year) as '4'

from sales group by year;

5.显示文章标题，发帖人、最后回复时间

表：id,title,postuser,postdate,parentid

准备sql语句：

drop table if exists articles;

create table articles(id int auto_increment primary key,title varchar(50), postuser varchar(10), postdate datetime,parentid int references articles(id));

insert into articles values

(null,'第一条','张三','1998-10-10 12:32:32',null),

(null,'第二条','张三','1998-10-10 12:34:32',null),

(null,'第一条回复1','李四','1998-10-10 12:35:32',1),

(null,'第二条回复1','李四','1998-10-10 12:36:32',2),

(null,'第一条回复2','王五','1998-10-10 12:37:32',1),

(null,'第一条回复3','李四','1998-10-10 12:38:32',1),

(null,'第二条回复2','李四','1998-10-10 12:39:32',2),

(null,'第一条回复4','王五','1998-10-10 12:39:40',1);

答案：

select a.title,a.postuser,

(select max(postdate) from articles where parentid=a.id) reply

from articles a where a.parentid is null;

注释：子查询能够用在选择列中，也可用于where的比较条件中，还能够用于from从句中。

3.删除除了id号不一样,其余都相同的学生冗余信息

2.学生表以下:

id号学号姓名课程编号课程名称分数

1 2005001 张三 0001 数学 69

2 2005002 李四 0001 数学 89

3 2005001 张三 0001 数学 69

A: delete from tablename where id号 not in(select min(id号) from tablename group by 学号,姓名,课程编号,课程名称,分数)

实验：

create table student2(id int auto_increment primary key,code varchar(20),name varchar(20));

insert into student2 values(null,'2005001','张三'),(null,'2005002','李四'),(null,'2005001','张三');

//以下语句，mysql报告错误，可能删除依赖后面统计语句，而删除又致使统计语句结果不一致。

delete from student2 where id not in(select min(id) from student2 group by name);

//可是，以下语句没有问题：

select * from student2 where id not in(select min(id) from student2 group by name);

//因而，我想先把分组的结果作成虚表，而后从虚表中选出结果，最后再将结果做为删除的条件数据。

delete from student2 where id not in(select mid from (select min(id) mid

from student2 group by name) as t);

或者：

delete from student2 where id not in(select min(id) from (select * from s

tudent2) as t group by t.name);

4.航空网的几个航班查询题：

表结构以下：

flight{flightID,StartCityID ,endCityID,StartTime}

city{cityID, CityName)

实验环境：

create table city(cityID int auto_increment primary key,cityName varchar(20));

create table flight (flightID int auto_increment primary key,

StartCityID int references city(cityID),

endCityID int references city(cityID),

StartTime timestamp);

//航班原本应该没有日期部分才好，可是下面的题目当中涉及到了日期

insert into city values(null,'北京'),(null,'上海'),(null,'广州');

insert into flight values

(null,1,2,'9:37:23'),(null,1,3,'9:37:23'),(null,1,2,'10:37:23'),(null,2,3,'10:37:23');

一、查询起飞城市是北京的全部航班，按到达城市的名字排序

参与运算的列是我起码可以显示出来的那些列，但最终我不必定把它们显示出来。各个表组合出来的中间结果字段中必须包含全部运算的字段。

select * from flight f,city c

where f.endcityid = c.cityid and startcityid =

(select c1.cityid from city c1 where c1.cityname = "北京")

order by c.cityname asc;

mysql> select flight.flightid,'北京' startcity, e.cityname from flight,city e wh

ere flight.endcityid=e.cityid and flight.startcityid=(select cityid from city wh

ere cityname='北京');

mysql> select flight.flightid,s.cityname,e.cityname from flight,city s,city e wh

ere flight.startcityid=s.cityid and s.cityname='北京' and flight.endCityId=e.cit

yID order by e.cityName desc;

二、查询北京到上海的全部航班纪录（起飞城市，到达城市，起飞时间，航班号）

select c1.CityName,c2.CityName,f.StartTime,f.flightID

from city c1,city c2,flight f

where f.StartCityID=c1.cityID

and f.endCityID=c2.cityID

and c1.cityName='北京'

and c2.cityName='上海'

三、查询具体某一天（2005-5-8）的北京到上海的的航班次数

select count(*) from

(select c1.CityName,c2.CityName,f.StartTime,f.flightID

from city c1,city c2,flight f

where f.StartCityID=c1.cityID

and f.endCityID=c2.cityID

and c1.cityName='北京'

and c2.cityName='上海'

and 查帮助得到的某个日期处理函数(startTime) like '2005-5-8%'

mysql中提取日期部分进行比较的示例代码以下：

select * from flight where date_format(starttime,'%Y-%m-%d')='1998-01-02'

5.查出比经理薪水还高的员工信息：

Drop table if not exists employees;

create table employees(id int primary key auto_increment,name varchar(50)

,salary int,managerid int references employees(id));

insert into employees values (null,' lhm',10000,null), (null,' zxx',15000,1

),(null,'flx',9000,1),(null,'tg',10000,2),(null,'wzg',10000,3);

Wzg大于flx,lhm大于zxx

解题思路：

根据sql语句的查询特色，是逐行进行运算，不可能两行同时参与运算。

涉及了员工薪水和经理薪水，全部，一行记录要同时包含两个薪水，全部想到要把这个表自关联组合一下。

首先要组合出一个包含有各个员工及该员工的经理信息的长记录，譬如，左半部分是员工，右半部分是经理。而迪卡尔积会组合出不少垃圾信息，先去除这些垃圾信息。

select e.* from employees e,employees m where e.managerid=m.id and e.sala

ry>m.salary;

六、求出小于45岁的各个老师所带的大于12岁的学生人数

数据库中有3个表 teacher 表，student表，tea_stu关系表。

teacher 表 teaID name age

student 表 stuID name age

teacher_student表 teaID stuID

要求用一条sql查询出这样的结果

1.显示的字段要有老师name, age 每一个老师所带的学生人数

2 只列出老师age为40如下，学生age为12以上的记录

预备知识：

1.sql语句是对每一条记录依次处理，条件为真则执行动做（select,insert,delete,update）

2.只要是迪卡尔积，就会产生“垃圾”信息，因此，只要迪卡尔积了，咱们首先就要想到清除“垃圾”信息

实验准备：

drop table if exists tea_stu;

drop table if exists teacher;

drop table if exists student;

create table teacher(teaID int primary key,name varchar(50),age int);

create table student(stuID int primary key,name varchar(50),age int);

create table tea_stu(teaID int references teacher(teaID),stuID int references student(stuID));

insert into teacher values(1,'zxx',45), (2,'lhm',25) , (3,'wzg',26) , (4,'tg',27);

insert into student values(1,'wy',11), (2,'dh',25) , (3,'ysq',26) , (4,'mxc',27);

insert into tea_stu values(1,1), (1,2), (1,3);

insert into tea_stu values(2,2), (2,3), (2,4);

insert into tea_stu values(3,3), (3,4), (3,1);

insert into tea_stu values(4,4), (4,1), (4,2) , (4,3);

结果：2?3,3?2,4?3

解题思路：（真实面试答题时，也要写出每一个分析步骤，若是纸张不够，就找别人要）

1要会统计分组信息，统计信息放在中间表中：

select teaid,count(*) from tea_stu group by teaid;

2接着其实应该是筛除掉小于12岁的学生，而后再进行统计，中间表必须与student关联才能获得12岁如下学生和把该学生记录从中间表中剔除，代码是：

select tea_stu.teaid,count(*) total from student,tea_stu

where student.stuid=tea_stu.stuid and student.age>12 group by tea_stu.teaid

3.接着把上面的结果作成虚表与teacher进行关联，并筛除大于45的老师

select teacher.teaid,teacher.name,total from teacher ,(select tea_stu.tea

id,count(*) total from student,tea_stu where student.stuid=tea_stu.stuid and stu

dent.age>12 group by tea_stu.teaid) as tea_stu2 where teacher.teaid=tea_stu2.tea

id and teacher.age<45;

7.求出发帖最多的人：

select authorid,count(*) total from articles

group by authorid

having total=

(select max(total2) from (select count(*) total2 from articles group by authorid) as t);

select t.authorid,max(t.total) from

（select authorid,count(*) total from articles ）as t

这条语句不行，由于max只有一列，不能与其余列混淆。

select authorid,count(*) total from articles

group by authorid having total=max(total)也不行。

十、一个用户表中有一个积分字段，假如数据库中有100多万个用户，若要在每一年第一天凌晨将积分清零，你将考虑什么，你将想什么办法解决?

alter table drop column score;

alter table add colunm score int;

可能会很快，可是须要试验，试验不能拿真实的环境来操刀，而且要注意，

这样的操做时没法回滚的，在个人印象中，只有inert update delete等DML语句才能回滚，

对于create table,drop table ,alter table等DDL语句是不能回滚。

解决方案一，update user set score=0;

解决方案二，假设上面的代码要执行好长时间，超出咱们的容忍范围，那我就alter table user drop column score;alter table user add column score int。

下面代码实现每一年的那个凌晨时刻进行清零。

Runnable runnable =

new Runnable(){

public void run(){

clearDb();

schedule(this,new Date(new Date().getYear()+1,0,0));

}

};

schedule(runnable,

new Date(new Date().getYear()+1,0,1));

十、一个用户具备多个角色，请查询出该表中具备该用户的全部角色的其余用户。

select count(*) as num,tb.id

from

tb,

(select role from tb where id=xxx) as t1

where

tb.role = t1.role and tb.id != t1.id

group by tb.id

having

num = select count(role) from tb where id=xxx;

8. xxx公司的sql面试

Table EMPLOYEES Structure:

EMPLOYEE_ID NUMBER Primary Key,

FIRST_NAME VARCHAR2(25),

LAST_NAME VARCHAR2(25),

Salary number(8,2),

HiredDate DATE,

Departmentid number(2)

Table Departments Structure:

Departmentid number(2) Primary Key,

DepartmentName VARCHAR2(25).

(2）基于上述EMPLOYEES表写出查询：写出雇用日期在今年的，或者工资在[1000,2000]之间的，或者员工姓名（last_name）以’Obama’打头的全部员工，列出这些员工的所有我的信息。（4分）

select * from employees

where Year(hiredDate) = Year(date())

or (salary between 1000 and 200)

or left(last_name,3)='abc';

(3) 基于上述EMPLOYEES表写出查询：查出部门平均工资大于1800元的部门的全部员工，列出这些员工的所有我的信息。（4分）

mysql> select id,name,salary,deptid did from employee1 where (select avg(salary)

from employee1 where deptid = did) > 1800;

(4) 基于上述EMPLOYEES表写出查询：查出我的工资高于其所在部门平均工资的员工，列出这些员工的所有我的信息及该员工工资高出部门平均工资百分比。（5分）

select employee1.*,(employee1.salary-t.avgSalary)*100/employee1.salary

from employee1,

(select deptid,avg(salary) avgSalary from employee1 group by deptid) as t

where employee1.deptid = t.deptid and employee1.salary>t.avgSalary;

一、注册Jdbc驱动程序的三种方式

一、用JDBC如何调用存储过程

代码以下：

package com.huawei.interview.lym;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Types;

public class JdbcTest {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

Connection cn = null;

CallableStatement cstmt = null;

try {

//这里最好不要这么干，由于驱动名写死在程序中了

Class.forName("com.mysql.jdbc.Driver");

//实际项目中，这里应用DataSource数据，若是用框架，

//这个数据源不须要咱们编码建立，咱们只需Datasource ds = context.lookup()

//cn = ds.getConnection();

cn = DriverManager.getConnection("jdbc:mysql:///test","root","root");

cstmt = cn.prepareCall("{call insert_Student(?,?,?)}");

cstmt.registerOutParameter(3,Types.INTEGER);

cstmt.setString(1, "wangwu");

cstmt.setInt(2, 25);

cstmt.execute();

//get第几个，不一样的数据库不同，建议不写

System.out.println(cstmt.getString(3));

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

finally

{

/*try{cstmt.close();}catch(Exception e){}

try{cn.close();}catch(Exception e){}*/

try {

if(cstmt != null)

cstmt.close();

if(cn != null)

cn.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

一、JDBC中的PreparedStatement相比Statement的好处

答：一个sql命令发给服务器去执行的步骤为：语法检查，语义分析，编译成内部指令，缓存指令，执行指令等过程。

select * from student where id =3----缓存--?xxxxx二进制命令

select * from student where id =3----直接取-?xxxxx二进制命令

select * from student where id =4--- -?会怎么干？

若是当初是select * from student where id =?--- -?又会怎么干？

上面说的是性能提升

能够防止sql注入。

1. 写一个用jdbc链接并访问oracle数据的程序代码

二、Class.forName的做用?为何要用?

答：按参数中指定的字符串形式的类名去搜索并加载相应的类，若是该类字节码已经被加载过，则返回表明该字节码的Class实例对象，不然，按类加载器的委托机制去搜索和加载该类，若是全部的类加载器都没法加载到该类，则抛出ClassNotFoundException。加载完这个Class字节码后，接着就能够使用Class字节码的newInstance方法去建立该类的实例对象了。

有时候，咱们程序中全部使用的具体类名在设计时（即开发时）没法肯定，只有程序运行时才能肯定，这时候就须要使用Class.forName去动态加载该类，这个类名一般是在配置文件中配置的，例如，spring的ioc中每次依赖注入的具体类就是这样配置的，jdbc的驱动类名一般也是经过配置文件来配置的，以便在产品交付使用后不用修改源程序就能够更换驱动类名。

三、大数据量下的分页解决方法。

答：最好的办法是利用sql语句进行分页，这样每次查询出的结果集中就只包含某页的数据内容。再sql语句没法实现分页的状况下，能够考虑对大的结果集经过游标定位方式来获取某页的数据。

sql语句分页，不一样的数据库下的分页方案各不同，下面是主流的三种数据库的分页sql：

sql server:

String sql =

"select top " + pageSize + " * from students where id not in" +

"(select top " + pageSize * (pageNumber-1) + " id from students order by id)" +

"order by id";

mysql:

String sql =

"select * from students order by id limit " + pageSize*(pageNumber-1) + "," + pageSize;

oracle:

String sql =

"select * from " +

(select *,rownum rid from (select * from students order by postime desc) where rid<=" + pagesize*pagenumber + ") as t" +

"where t>" + pageSize*(pageNumber-1);

四、用 JDBC 查询学生成绩单, 把主要代码写出来（考试几率极大）.

Connection cn = null;

PreparedStatement pstmt =null;

Resultset rs = null;

try

{

Class.forname(driveClassName);

cn = DriverManager.getConnection(url,username,password);

pstmt = cn.prepareStatement(“select score.* from score ,student “ +

“where score.stuId = student.id and student.name = ?”);

pstmt.setString(1,studentName);

Resultset rs = pstmt.executeQuery();

while(rs.next())

{

system.out.println(rs.getInt(“subject”) + “ ” + rs.getFloat(“score”) );

}

}catch(Exception e){e.printStackTrace();}

finally

{

if(rs != null) try{ rs.close() }catch(exception e){}

if(pstmt != null) try{pstmt.close()}catch(exception e){}

if(cn != null) try{ cn.close() }catch(exception e){}

}

五、这段代码有什么不足之处?

try {

Connection conn = ...;

Statement stmt = ...;

ResultSet rs = stmt.executeQuery("select * from table1");

while(rs.next()) {

}

} catch(Exception ex) {

}

答：没有finally语句来关闭各个对象，另外，使用finally以后，要把变量的定义放在try语句块的外面，以便在try语句块以外的finally块中仍能够访问这些变量。

3六、说出数据链接池的工做机制是什么?

J2EE服务器启动时会创建必定数量的池链接，并一直维持很多于此数目的池链接。客户端程序须要链接时，池驱动程序会返回一个未使用的池链接并将其表记为忙。若是当前没有空闲链接，池驱动程序就新建必定数量的链接，新建链接的数量有配置参数决定。当使用的池链接调用完成后，池驱动程序将此链接表记为空闲，其余调用就能够使用这个链接。

实现方式，返回的Connection是原始Connection的代理，代理Connection的close方法不是真正关链接，而是把它代理的Connection对象还回到链接池中。

四、为何要用 ORM? 和 JDBC 有何不同?

orm是一种思想，就是把object转变成数据库中的记录，或者把数据库中的记录转变成objecdt，咱们能够用jdbc来实现这种思想，其实，若是咱们的项目是严格按照oop方式编写的话，咱们的jdbc程序无论是有意仍是无心，就已经在实现orm的工做了。

如今有许多orm工具，它们底层调用jdbc来实现了orm工做，咱们直接使用这些工具，就省去了直接使用jdbc的繁琐细节，提升了开发效率，如今用的较多的orm工具是hibernate。也据说一些其余orm工具，如toplink,ojb等。

8. XML部分

一、xml有哪些解析技术?区别是什么?

答:有DOM,SAX,STAX等

DOM:处理大型文件时其性能降低的很是厉害。这个问题是由DOM的树结构所形成的，这种结构占用的内存较多，并且DOM必须在解析文件以前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不须要一次所有装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户经过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问

STAX:Streaming API for XML (StAX)

讲解这些区别是不须要特别去比较，就像说传智播客与其余培训机构的区别时，咱们只需说清楚传智播客有什么特色和优势就好了，这就已经间接回答了彼此的区别。

二、你在项目中用到了xml技术的哪些方面?如何实现的?

答:用到了数据存贮，信息配置两方面。在作数据交换平台时，将不能数据源的数据组装成XML文件，而后将XML文件压缩打包加密后经过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在作软件配置时，利用XML能够很方便的进行，软件的各类配置参数都存贮在XML文件中。

三、用jdom解析xml文件时如何解决中文问题?如何解析?

答:看以下代码,用编码方式加以解决

package test;

import java.io.*;

public class DOMTest

{

private String inFile = "c:\\people.xml"

private String outFile = "c:\\people.xml"

public static void main(String args[])

{

new DOMTest();

}

public DOMTest()

{

try

{

javax.xml.parsers.DocumentBuilder builder =

javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();

org.w3c.dom.Document doc = builder.newDocument();

org.w3c.dom.Element root = doc.createElement("老师");

org.w3c.dom.Element wang = doc.createElement("王");

org.w3c.dom.Element liu = doc.createElement("刘");

wang.appendChild(doc.createTextNode("我是王老师"));

root.appendChild(wang);

doc.appendChild(root);

javax.xml.transform.Transformer transformer =

javax.xml.transform.TransformerFactory.newInstance().newTransformer();

transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312");

transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");

transformer.transform(new javax.xml.transform.dom.DOMSource(doc),

new

javax.xml.transform.stream.StreamResult(outFile));

}

catch (Exception e)

{

System.out.println (e.getMessage());

}

四、编程用JAVA解析XML的方式.

答:用SAX方式解析XML，XML文件以下：

<?xml version=1.0 encoding=gb2312?>

<notes>男,1955年生,博士，95年调入海南大学</notes>

</person>

事件回调类SAXHandler.java

import java.io.*;

import java.util.Hashtable;

import org.xml.sax.*;

public class SAXHandler extends HandlerBase

{

private Hashtable table = new Hashtable();

private String currentElement = null;

private String currentValue = null;

public void setTable(Hashtable table)

{

this.table = table;

}

public Hashtable getTable()

{

return table;

}

public void startElement(String tag, AttributeList attrs)

throws SAXException

{

currentElement = tag;

}

public void characters(char[] ch, int start, int length)

throws SAXException

{

currentValue = new String(ch, start, length);

}

public void endElement(String name) throws SAXException

{

if (currentElement.equals(name))

table.put(currentElement, currentValue);

}

JSP内容显示源码,SaxXml.jsp:

<HTML>

<HEAD>

<TITLE>剖析XML文件people.xml</TITLE>

</HEAD>

<BODY>

<%@ page errorPage=ErrPage.jsp

contentType=text/html;charset=GB2312 %>

<%@ page import=java.io.* %>

<%@ page import=java.util.Hashtable %>

<%@ page import=org.w3c.dom.* %>

<%@ page import=org.xml.sax.* %>

<%@ page import=javax.xml.parsers.SAXParserFactory %>

<%@ page import=javax.xml.parsers.SAXParser %>

<%@ page import=SAXHandler %>

File file = new File(c:\people.xml);

FileReader reader = new FileReader(file);

Parser parser;

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser sp = spf.newSAXParser();

SAXHandler handler = new SAXHandler();

sp.parse(new InputSource(reader), handler);

Hashtable hashTable = handler.getTable();

out.println(<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>);

out.println(<TR><TD>姓名</TD> + <TD> +

(String)hashTable.get(new String(name)) + </TD></TR>);

out.println(<TR><TD>学院</TD> + <TD> +

(String)hashTable.get(new String(college))+</TD></TR>);

out.println(<TR><TD>电话</TD> + <TD> +

(String)hashTable.get(new String(telephone)) + </TD></TR>);

out.println(<TR><TD>备注</TD> + <TD> +

(String)hashTable.get(new String(notes)) + </TD></TR>);

out.println(</TABLE>);

</BODY>

</HTML>

70、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？

a: 两种形式 dtd schema，b: 本质区别:schema自己是xml的，能够被XML解析器解析(这也是从DTD上发展schema的根本目的)，c:有DOM,SAX,STAX等

DOM:处理大型文件时其性能降低的很是厉害。这个问题是由DOM的树结构所形成的，这种结构占用的内存较多，并且DOM必须在解析文件以前把整个文档装入内存,适合对XML的随机访问

SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不须要一次所有装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户经过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问

STAX:Streaming API for XML (StAX)

9. 流行的框架与新技术

一、谈谈你对Struts的理解。

答:

1. struts是一个按MVC模式设计的Web层框架，其实它就是一个大大的servlet，这个Servlet名为ActionServlet，或是ActionServlet的子类。咱们能够在web.xml文件中将符合某种特征的全部请求交给这个Servlet处理，这个Servlet再参照一个配置文件（一般为/WEB-INF/struts-config.xml）将各个请求分别分配给不一样的action去处理。

一个扩展知识点：struts的配置文件能够有多个，能够按模块配置各自的配置文件，这样能够防止配置文件的过分膨胀；

2. ActionServlet把请求交给action去处理以前，会将请求参数封装成一个formbean对象（就是一个java类，这个类中的每一个属性对应一个请求参数），封装成一个什么样的formbean对象呢？看配置文件。

3.要说明的是， ActionServlet把formbean对象传递给action的execute方法以前，可能会调用formbean的validate方法进行校验，只有校验经过后才将这个formbean对象传递给action的execute方法，不然，它将返回一个错误页面，这个错误页面由input属性指定，（看配置文件）做者为何将这里命名为input属性，而不是error属性，咱们后面结合实际的运行效果进行分析。

4.action执行完后要返回显示的结果视图，这个结果视图是用一个ActionForward对象来表示的，actionforward对象经过struts-config.xml配置文件中的配置关联到某个jsp页面，由于程序中使用的是在struts-config.xml配置文件为jsp页面设置的逻辑名，这样能够实现action程序代码与返回的jsp页面名称的解耦。

你对struts可能还有本身的应用方面的经验，那也要一并说出来。

二、谈谈你对Hibernate的理解。

答:

1. 面向对象设计的软件内部运行过程能够理解成就是在不断建立各类新对象、创建对象之间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，无论程序运行的过程和操做怎么样，本质上都是要获得一个结果，程序上一个时刻和下一个时刻的运行结果的差别就表如今内存中的对象状态发生了变化。

2.为了在关机和内存空间不够的情况下，保持程序的运行状态，须要将内存中的对象状态保存到持久化设备和从持久化设备中恢复出对象的状态，一般都是保存到关系数据库来保存大量对象信息。从Java程序的运行功能上来说，保存对象状态的功能相比系统运行的其余功能来讲，应该是一个很不起眼的附属功能，java采用jdbc来实现这个功能，这个不起眼的功能却要编写大量的代码，而作的事情仅仅是保存对象和恢复对象，而且那些大量的jdbc代码并无什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活和重复性的工做。

3.经过数据库保存java程序运行时产生的对象和恢复对象，其实就是实现了java对象与关系数据库记录的映射关系，称为ORM（即Object Relation Mapping），人们能够经过封装JDBC代码来实现了这种功能，封装出来的产品称之为ORM框架，Hibernate就是其中的一种流行ORM框架。使用Hibernate框架，不用写JDBC代码，仅仅是调用一个save方法，就能够将对象保存到关系数据库中，仅仅是调用一个get方法，就能够从数据库中加载出一个对象。

4.使用Hibernate的基本流程是：配置Configuration对象、产生SessionFactory、建立session对象，启动事务，完成CRUD操做，提交事务，关闭session。

5.使用Hibernate时，先要配置hibernate.cfg.xml文件，其中配置数据库链接信息和方言等，还要为每一个实体配置相应的hbm.xml文件，hibernate.cfg.xml文件中须要登记每一个hbm.xml文件。

6.在应用Hibernate时，重点要了解Session的缓存原理，级联，延迟加载和hql查询。

三、AOP的做用。

三、你对Spring的理解。

1.Spring实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（其实是一个接口），在程序中一般BeanFactory的子类ApplicationContext。Spring至关于一个大的工厂类，在其配置文件中经过<bean>元素配置用于建立实例对象的类名和实例对象的属性。

2. Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想能够很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），什么叫依赖注入呢？

譬如，Class Programmer

{

Computer computer = null;

public void code()

{

//Computer computer = new IBMComputer();

//Computer computer = beanfacotry.getComputer();

computer.write();

}

public void setComputer(Computer computer)

{

this.computer = computer;

}

另外两种方式都由依赖，第一个直接依赖于目标类，第二个把依赖转移到工厂上，第三个完全与目标和工厂解耦了。在spring的配置文件中配置片断以下：

</bean>

</bean>

3. Spring提供了对AOP技术的良好封装， AOP称为面向切面编程，就是系统中有不少各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。实现AOP功能采用的是代理技术，客户端程序再也不调用目标，而调用代理类，代理类与目标类对外具备相同的方法声明，有两种方式能够实现相同的方法声明，一是实现相同的接口，二是做为目标的子类在，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，若是要为某个类生成子类，则能够用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以Advice对象进行提供，显然要建立出代理对象，至少须要目标类和Advice类。spring提供了这种支持，只须要在spring配置文件中配置这两个元素便可实现代理和aop功能，例如，

</bean>

十一、谈谈Struts中的Action servlet。

十二、Struts优缺点

优势：

1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.

2．有丰富的tag能够用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提升开发效率

3. 页面导航

使系统的脉络更加清晰。经过一个配置文件，便可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤为是当另外一批开发者接手这个项目时，这种优点体现得更加明显。

4. 提供Exception处理机制 .

5. 数据库连接池管理

6. 支持I18N

缺点

1、转到展现层时，须要配置forward，若是有十个展现层的jsp，须要配置十次struts，并且还不包括有时候目录、文件变动，须要从新修改forward，注意，每次修改配置以后，要求从新部署整个项目，而tomcate这样的服务器，还必须从新启动服务器

2、 2、 Struts 的Action必需是thread－safe方式，它仅仅容许一个实例去处理全部的请求。因此action用到的全部的资源都必需统一同步，这个就引发了线程安全的问题。

5、对Servlet的依赖性过强. Struts处理Action时必须要依赖ServletRequest 和ServletResponse，全部它摆脱不了Servlet容器。

6、前端表达式语言方面.Struts集成了JSTL，因此它主要使用JSTL的表达式语言来获取数据。但是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。

7、对Action执行的控制困难. Struts建立一个Action，若是想控制它的执行顺序将会很是困难。甚至你要从新去写Servlet来实现你的这个功能需求。

8、对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操做。

11九、STRUTS的应用(如STRUTS架构)

Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有以下的主要功能：一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。二.JSP自由tag库，而且在controller servlet中提供关联支持，帮助开发员建立交互式表单应用。三.提供了一系列实用对象：XML处理、经过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

1十、说说struts1与struts2的区别。

1.都是MVC的WEB框架,

2 struts1的老牌框架，应用很普遍，有很好的群众基础，使用它开发风险很小，成本更低！struts2虽然基于这个框架，可是应用群众并多，相对不成熟，未知的风险和变化不少，开发人员相对很差招，使用它开发项目的风险系数更大，用人成本更高！

3.struts2毕竟是站在前辈的基础设计出来，它会改善和完善struts1中的一些缺陷，struts1中一些悬而未决问题在struts2获得了解决。

4.struts1的前端控制器是一个Servlet，名称为ActionServlet，struts2的前端控制器是一个filter，在struts2.0中叫FilterDispatcher，在struts2.1中叫StrutsPrepareAndExecuteFilter。

5.struts1的action须要继承Action类，struts2的action能够不继承任何类；struts1对同一个路径的全部请求共享一个Action实例，struts2对同一个路径的每一个请求分别使用一个独立Action实例对象，全部对于struts2的Action不用考虑线程安全问题。

6.在struts1中使用formbean封装请求参数，在struts2中直接使用action的属性来封装请求参数。

7.struts1中的多个业务方法放在一个Action中时（即继承DispatchAction时），要么都校验，要么都不校验；对于struts2，能够指定只对某个方法进行校验，当一个Action继承了ActionSupport且在这个类中只编写了validateXxx()方法，那么则只对Xxx()方法进行校验。

（一个请求来了的执行流程进行分析，struts2是自动支持分模块开发，并能够不一样模块设置不一样的url前缀，这是经过package的namespace来实现的；struts2是支持多种类型的视图；struts2的视图地址能够是动态的，即视图的名称是支持变量方式的，举例，论坛发帖失败后回来还要传递boardid。视图内容显示方面：它的标签用ognl，要el强大不少，在国际化方面支持分模块管理，两个模块用到一样的key，对应不一样的消息；）

与Struts1不一样，Struts2对用户的每一次请求都会建立一个Action，因此Struts2中的Action是线程安全的。

给我印象最深入的是：struts配置文件中的redirect视图的url不能接受参数，而struts2配置文件中的redirect视图能够接受参数。

1十、hibernate中的update()和saveOrUpdate()的区别，session的load()和get()的区别。

1十、简述 Hibernate 和 JDBC 的优缺点? 如何书写一个 one to many 配置文件.

七、iBatis与Hibernate有什么不一样?

相同点：屏蔽jdbc api的底层访问细节，使用咱们不用与jdbc api打交道，就能够访问数据。

jdbc api编程流程固定，还将sql语句与java代码混杂在了一块儿，常常须要拼凑sql语句，细节很繁琐。

ibatis的好处：屏蔽jdbc api的底层访问细节；将sql语句与java代码进行分离;提供了将结果集自动封装称为实体对象和对象的集合的功能，queryForList返回对象集合，用queryForObject返回单个对象；提供了自动将实体对象的属性传递给sql语句的参数。

Hibernate是一个全自动的orm映射工具，它能够自动生成sql语句,ibatis须要咱们本身在xml配置文件中写sql语句，hibernate要比ibatis功能负责和强大不少。由于hibernate自动生成sql语句，咱们没法控制该语句，咱们就没法去写特定的高效率的sql。对于一些不太复杂的sql查询，hibernate能够很好帮咱们完成，可是，对于特别复杂的查询，hibernate就很难适应了，这时候用ibatis就是不错的选择，由于ibatis仍是由咱们本身写sql语句。

七、写Hibernate的一对多和多对一双向关联的orm配置?

九、hibernate的inverse属性的做用?