javaEE面试重点

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在查询数据的时候。数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟载入。他节省了server的内存开销，从而提升了server的性能。
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.视图对象负责渲染返回给client。


为何用：
AOP 让开发者可以建立非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。


IOC 赞成建立一个可以构造对象的应用环境，而后向这些对象传递它们的协做对象。正如单词 倒置 所代表的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用 其协做对象构造的。

所以是由容器管理协做对象（collaborator）。

Spring即便一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，仅仅要用 JavaBean 属性和配置文件增长依赖性（协做对象）。而后可以很是easy地在需要时替换具备相似接口的协做对象。

网友自出的几道面试题


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

二、 Spring的Bean有多种做用域，包含：
singleton、prototype、request、session、global session、application、本身定义


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


四、 Hibernate中的update()和saveOrUpdate()的差异


五、 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.新建project
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怎样实现数据表映射的继承关系


一、两个表。子类反复父类的属性。

二、一个表，子类父类共用一个表










三、两个表。子类引用父类的主键，享用公共的字段或属性。

批量删除
Query query=session.createQuery(“update”或”delete”);
query.executeUpdate();
jdbc、Hibernate、ibatis的差异


jdbc:手动
手动写sql
delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。

select:返回的是一个resultset。要从ResultSet中一行一行、一个字段一个字段的取出，而后封装到一个对象中，不直接返回一个对象。
ibatis的特色:半本身主动化
sql要手动写
delete、insert、update:直接传入一个对象
select:直接返回一个对象
hibernate:全本身主动
不写sql,本身主动封装
delete、insert、update:直接传入一个对象
select:直接返回一个对象


Detached Object（游离对象）可以传递到不论什么层直到表现层而不是用不论什么DTO(Data Transfer Objects). 而后你还可以又一次把游离对象赋给另一个Session.


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. Hibernate有哪几种查询数据的方式


3种：hql、QBC——Query By Criteria API、原生sql （经过createSQLQuery创建）


2. 谈谈Hibernate中inverse的做用


inverse属性默认是false,就是说关系的两端都来维护关系。
比方Student和Teacher是多对多关系。用一个中间表TeacherStudent维护。

Gp)i
假设Student这边inverse=”true”, 那么关系由还有一端Teacher维护，就是说当插入Student时，不会操做TeacherStudent表（中间表）。仅仅有Teacher插入或删除时才会触发对中间表的操做。因此两边都inverse=”true”是不正确的。会致使不论什么操做都不触发对中间表的影响。当两边都inverse=”false” 或默认时，会致使在中间表中插入两次关系。


3. 说说Hibernate中的update()和saveOrUpdate()的差异。session的load()和get()的差异。


saveOrUpdate()方法可以实现update()的功能，但会多些步骤。详细例如如下：
假设对象在该session中已经被持久化，不进行操做。对象的标识符属性(identifier property)在数据库中不存在或者是个临时的值。调用save()方法保存它。假设session中的还有一个对象有一样的标识符抛出一个异常；以上皆不符合则调用update()更新之。

Session.load/get方法均可以依据指定的实体类和id从数据库读取记录，并返回与之相应的实体对象。

其差异在于：
假设未能发现符合条件的记录，get方法返回null。而load方法会抛出一个ObjectNotFoundException；load方法可返回实体的代理类实例，而get方法永远直接返回实体类。load方法可以充分利用内部缓存和二级缓存中的现有数据。而get方法则只在内部缓存中进行数据查找，如没有发现相应数据，将越过二级缓存，直接调用SQL完毕数据读取。


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在查询数据的时候。数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟载入，他节省了server的内存开销。从而提升了server的性能。

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.视图对象负责渲染返回给client。


为何用：
{AOP 让开发者可以建立非行为性的关注点，称为横切关注点。并将它们插入到应用程序代码中。

使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。

IOC 赞成建立一个可以构造对象的应用环境。而后向这些对象传递它们的协做对象。正如单词 倒置 所代表的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协做对象构造的。

所以是由容器管理协做对象（collaborator）。

Spring即便一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。

有了 Spring，仅仅要用 JavaBean 属性和配置文件增长依赖性（协做对象）。

而后可以很是easy地在需要时替换具备相似接口的协做对象。}


同类其它面试题 点击新一篇或旧一篇可浏览全部同类面试题


Hibernate里面sorted collection和ordered collection有什么差异


sorted collection是在内存中经过java比較器进行排序的
ordered collection是在数据库中经过order by进行排序的


Hibernate都支持哪些缓存策略


Read-only: 这样的策略适用于那些频繁读取却不会更新的数据。这是眼下为止最简单和最有效的缓存策略
* Read/write:这样的策略适用于需要被更新的数据，比read-only更耗费资源，在非JTA环境下，每个事务需要在session.close和session.disconnect()被调用
* Nonstrict read/write: 这样的策略不保障两个同一时候进行的事务会改动同一块数据，这样的策略适用于那些经常读取但是极少更新的数据
* Transactional: 这样的策略是全然事务化得缓存策略。可以用在JTA环境下


怎样查看Hibernate生成并运行的sql


在定义数据库和数据库属性的文件applicationConfig.xml里面，把hibernate.show_sql 设置为true
这样生成的SQL就会在控制台出现了
注意：这样作会加剧系统的负担，不利于性能调优


比較Hibernate的三种检索策略优缺点


1立刻检索；
长处：相应用程序全然透明，不管对象处于持久化状态，仍是游离状态。应用程序都可以方便的从一个对象导航到与它关联的对象；
缺点：1.select语句太多；2.可能会载入应用程序不需要訪问的对象白白浪费不少内存空间；
2延迟检索：
长处：由应用程序决定需要载入哪些对象，可以避免可运行多余的select语句。以及避免载入应用程序不需要訪问的对象。

所以能提升检索性能，并且能节省内存空间；
缺点：应用程序假设但愿訪问游离状态代理类实例，必须保证他在持久化状态时已经被初始化。
3 迫切左外链接检索
长处：1相应用程序全然透明，不管对象处于持久化状态。仍是游离状态，应用程序都可以方便地冲一个对象导航到与它关联的对象。2使用了外链接，select语句数目少；
缺点：1 可能会载入应用程序不需要訪问的对象。白白浪费不少内存空间；2复杂的数据库表链接也会影响检索性能；


ssh面试精华


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在查询数据的时候，数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟载入，他节省了server的内存开销，从而提升了server的性能。
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.视图对象负责渲染返回给client。


为何用：
{AOP 让开发者可以建立非行为性的关注点，称为横切关注点。并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同一时候不会添加域对象的对象模型的复杂性。
IOC 赞成建立一个可以构造对象的应用环境。而后向这些对象传递它们的协做对象。正如单词 倒置 所代表的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction）。每一个对象都是用其协做对象构造的。所以是由容器管理协做对象（collaborator）。

Spring即便一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，仅仅要用 JavaBean 属性和配置文件增长依赖性（协做对象）。而后可以很是easy地在需要时替换具备相似接口的协做对象。}


面试中常出现的Hibernate试题


1.在数据库中条件查询速度很是慢的时候,怎样优化?

1.建索引


2.下降表之间的关联


3.优化sql，尽可能让sql很是快定位数据，不要让sql作全表查询，应该走索引,把数据量大的表排在前面


4.简化查询字段，无用的字段不要。已经对返回结果的控制，尽可能返回少许数据


2.在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并无一个实体类与之相应,怎样解决问题?


解决方式一，依照Object[]数据取出数据，而后本身组bean


解决方式二，对每个表的bean写构造函数，比方表一要查出field1,field2两个字段。那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，而后在hql里面就可以直接生成这个bean了。详细怎么用请看相关文档，我说的不是很是清楚。


3.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 做为主键生成机制。


三框架整合链接数据库的方法


第一种在Spring applicationContext.xml中链接：




oracle.jdbc.driver.OracleDriver


jdbc:oracle:thin:@localhost:1521:test


cpiclh


cpiclh






com/Hibernate/Pojo/FactUsers.hbm.xml


org.hibernate.dialect.Oracle9Dialect true
另一种在Hibernate hibernate.cfg.xml中链接：




root
jdbc:oracle:thin:@192.168.0.1:1521:test


org.hibernate.dialect.Oracle9Dialect root
oracle.jdbc.driver.OracleDriver


第三种在Tomcat中的 apache-tomcat-5.5.17\conf\Catalina文件夹下放一个


和文件夹同名的XML。内容例如如下






username="root" password="root" driverClassName="oracle.jdbc.driver.OracleDriver"


url="jdbc:oracle:thin:@192.168.0.1:1521:test"/>


什么是Hibernate并发机制 怎么处理并发问题


Hibernate并发机制：
a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工做单元(即单个事务,单个线程),它一般仅仅使用一次,
而后就丢弃。

假设一个Session 实例赞成共享的话，那些支持并发执行的,好比Http request,session beans将会致使出现资源争用。
假设在Http Session中有hibernate的Session的话,就可能会出现同步訪问Http Session。

仅仅要用户足够快的点击浏览器的“刷新”,
就会致使两个并发执行的线程使用同一个Session。

b、多个事务并发訪问同一块资源,可能会引起第一类丢失更新，脏读。幻读，不可反复读，第二类丢失更新一系列的问题。


解决方式：设置事务隔离级别。

Serializable：串行化。

隔离级别最高
Repeatable Read：可反复读
Read Committed：已提交数据读
Read Uncommitted：未提交数据读。

隔离级别最差
设置锁：乐观锁和悲观锁。

乐观锁：使用版本号号或时间戳来检測更新丢失,在的映射中设置 optimistic-lock=”all”可以在没有版本号或者时间戳属性映射的状况下实现 版本号检查，此时Hibernate将比較一行记录的每个字段的状态 行级悲观锁：Hibernate老是使用数据库的锁定机制，从不在内存中锁定对象！仅仅要为JDBC链接指定一下隔 离级别，而后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不一样的锁定级别：LockMode.UPGRADE,LockMode.UPGRADE_NOWAIT,LockMode.READ;


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的性能很是好，因为它是个轻量级框架。

映射的灵活性很是出色。它支持各类关系数据库。从 一对一到多对多的各类复杂关系。


Hibernate缓存机制


1. 内部缓存存在Hibernate中又叫一级缓存。属于应用事物级缓存
2. 二级缓存：
a) 应用及缓存
b) 分布式缓存
条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据
c) 第三方缓存的实现


Hibernate的查询方式


Sql、Criteria,object comptosition
Hql：
一、 属性查询
二、 參数查询、命名參数查询
三、 关联查询
四、 分页查询
五、 统计函数


怎样优化Hibernate


1. 使用双向一对多关联。不使用单向一对多
2. 灵活使用单向一对多关联
3. 不用一对一，用多对一代替
4. 配置对象缓存，不使用集合缓存
5. 一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰


Hibernate拒接链接、server崩溃的缘由


1. db没有打开
2. 网络链接可能出了问题
3. 链接配置错了
4. 驱动的driver，url是否都写对了
5. LIB下增长对应驱动，数据链接代码是否有误
6. 数据库配置可能有问题
7. 当前联接太多了。server都有訪问人数限制的
8. server的对应port没有开，即它不提供对应的服务
9 hibernate有哪些缓存。分别怎么使用?
10 你对hibernate的了解到了一个什么样的程度？
11 写出一个sql语句体现hibernate中一对多的关系


常见的Hibernate面试题


1.Hibernate有哪几种查询数据的方式
(1)导航对象图查询
(2)OID查询
(3)HQL
(4)QBC
(5)本地SQL
2.load()和get()的差异
load载入方法：
Java代码
Users user = (Users)session.load(Users.class, userId);
get载入方法：
Java代码
Users user = (Users)session.get(Users.class, userId);
两载入方法差异：
差异1：假设数据库中，没有userId的对象。假设经过get方法载入。则返回的是一个null；假设经过load载入，则返回一个代理对象，假设后面代码假设调用user对象的某个属性（比方user.getPassword()）会抛出异常：org.hibernate.ObjectNotFoundException。


差异2：load支持延迟载入。get不支持延迟载入。

也就是说：
Java代码
Users user = (Users)session.load(Users.class, userId);
这句代码不会去运行数据库查询。仅仅实用到user时才会去运行数据库查询。
而Java代码
Users user = (Users)session.get(Users.class, userId);
则立刻去运行数据库查询。 因此Users user = (Users)session.load(Users.class, userId);不会运行不论什么sql。

注意Java代码


Users user = (Users)session.load(Users.class, userId);
System.out.println(user.getId());
Users user = (Users)session.load(Users.class, userId);
System.out.println(user.getId());


上面这2句代码，不会去运行数据库操做。因为load后会在hibernate的一级缓存里存放一个map对象。该map的key就是userId的值，但是当你getId()时，它会去一级缓存里拿map的key值，而不去运行数据库查询。因此不会报不论什么错。不会运行不论什么数据库操做。

3. 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的性能很是好。因为它是个轻量级框架。映射的灵活性很是出色。它支持各类关系数据库。从一对一到多对多的各类复杂关系。
4． Hibernate是怎样延迟载入?

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


5． Hibernate中如何实现类之间的关系?

(如：一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操做。它们都市对对象进行操做，咱们程序中把所有的表与类都映射在一块儿，它们经过配置文件里的many-to-one、one-to-many、many-to-many、


5． 说下Hibernate的缓存机制
1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
2. 二级缓存：
a) 应用及缓存
b) 分布式缓存
条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非重要数据
c) 第三方缓存的实现


6． Hibernate的查询方式


Sql、Criteria,object comptosition


Hql：


一、 属性查询


二、 參数查询、命名參数查询


三、 关联查询


四、 分页查询


五、 统计函数


7． 怎样优化Hibernate？


1. 使用双向一对多关联，不使用单向一对多


2. 灵活使用单向一对多关联


3. 不用一对一，用多对一代替


4. 配置对象缓存，不使用集合缓存


5. 一对多集合使用Bag,多对多集合使用Set


6. 继承类使用显式多态


7. 表字段要少，表关联不要怕多。有二级缓存撑腰


=====================Hibernate笔试题==========================


(1)普通状况下。关系数据模型与对象模型之间有哪些匹配关系（多选）
A)表相应类
B)记录相应对象
C)表的字段相应类的属性
D)表之间的參考关系相应类之间的依赖关系


(2)下面关于SessionFactory的说法哪些正确？（多选）
A)对于每个数据库事务，应该建立一个SessionFactory对象
B)一个SessionFactory对象相应一个数据库存储源。

C)SessionFactory是重量级的对象。不该该任意建立。假设系统中仅仅有一个数据库存储源。仅仅需要建立一个。

D)SessionFactory的load()方法用于载入持久化对象


(3)Customer类中有一个Set类型的orders属性。用来存放Order订单对象，在Customer.hbm.xml文件里。用哪一个元素映射orders属性？
A) B) C) D)


(4)元素有一个cascade属性。假设但愿Hibernate级联保存集合中的对象，casecade属性应该取什么值？（单选）
A)none
B)save
C)delete
D)save-update


(5)下面哪些属于Session的方法？
A)load()
B)save()
C)delete()
D)update()
E)open()
F)close()


(6)下面程序的打印结果是什么？（单选）


tx = session.beginTransaction();
Customer c1=(Customer)session.load(Customer.class,new Long(1));
Customer c2=(Customer)session.load(Customer.class,new Long(1));
System.out.println(c1==c2);
tx.commit();
session.close();


A)执行出错。抛出异常
B)打印false
C)打印true


(7)下面程序代码对Customer的name属性改动了两次：
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,
new Long(1));
customer.setName(\”Jack\”);
customer.setName(\”Mike\”);
tx.commit();


运行以上程序，Hibernate需要向数据库提交几条update语句？（单选）
A)0 B)1 C)2 D)3


(8)在持久化层，对象分为哪些状态？（多选）
A)暂时状态
B)独立状态
C)游离状态
D)持久化状态


(9)对于下面程序，Customer对象在第几行变为持久化状态？（单选）
Customer customer=new Customer(); //line1
customer.setName(\”Tom\”); //line2
Session session1=sessionFactory.openSession(); //line3
Transaction tx1 = session1.beginTransaction(); //line4
session1.save(customer); //line4
tx1.commit(); //line5
session1.close(); //line6


A) line1 B)line2 C)line3 D)line4 E)line5 F)line6


(10)对于下面程序，Customer对象在第几行变为游离状态？（单选）
Customer customer=new Customer(); //line1
customer.setName(\”Tom\”); //line2
Session session1=sessionFactory.openSession(); //line3
Transaction tx1 = session1.beginTransaction(); //line4
session1.save(customer); //line4
tx1.commit(); //line5
session1.close(); //line6


A) line1 B)line2 C)line3 D)line4 E)line5 F)line6


(11)下面哪种检索策略利用了外连结查询？（单选）
A)立刻检索 B)延迟检索 C)迫切左外连结检索


(12)若是对Customer类的orders集合採用延迟检索策略，编译或执行下面程序，会出现什么状况（单选）
Session session=sessionFactory.openSession();
tx = session.beginTransaction();
Customer customer=(Customer)session.get(Customer.class,new Long(1));
tx.commit();
session.close();
Iterator orderIterator=customer.getOrders().iterator();


A)编译出错 B)编译经过。并正常执行 C)编译经过。但执行时抛出异常


(13)关于HQL与SQL，下面哪些说法正确？（多选）
A)HQL与SQL没什么区别
B)HQL面向对象，而SQL操纵关系数据库
C)在HQL与SQL中，都包括select,insert,update,delete语句
D)HQL仅用于查询数据。不支持insert,update和delete语句


(14)事务隔离级别是由谁实现的？（单选）
A)Java应用程序 B)Hibernate C)数据库系统 D)JDBC驱动程序


(15)悲观锁与乐观锁，哪一个具备较好的并发性能？（单选）
A)悲观锁 B)乐观锁


答案：
(1)A,B,C (2)B,C (3)A (4)D (5)A,B,C,D,F (6)C (7)B (8)A,C,D (9)D (10)F (11)C (12)C (13)B,D (14)C (15)B


1.strust的。

Action是否是线程安全的？假设不是
有什么方式可以保证Action的线程安全？假设是，说明缘由


2.MVC，分析一下struts是怎样实现MVC的


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


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


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


6.load()和get()的差异


1. Struts的工做原理
在Struts中，用户的请求通常以*.do做为请求服务名。所有的*.do请求均被指向ActionSevlet， ActionSevlet依据Struts-config.xml中的配置信息，将用户请求封装成一个指定名称的FormBean，并将此 FormBean传至指定名称的ActionBean，由ActionBean完毕相应的业务操做，如文件操做，数据库操做等。每一个*.do均有相应的 FormBean名称和ActionBean名称。这些在Struts-config.xml中配置。


2. Struts长处与缺点
Struts是开源软件。使开发人员能更深刻的了解其内部实现机制。
Struts 长处：业界”标准”（很是多成功案例），学习资源丰富。
Struts的长处主要集中体现在两个方面：Taglib和页面导航。

a、利用Struts提供的taglib可以大大节约开发时间。
b、维护扩展比較方便。经过一个配置文件。就能够把握整个系统各部分之间的联系，这对于后期的维护有着莫大的优势。
c、表现与逻辑分离
d、表单验证攻克了请求数据的验证问题，加强了系统健壮性。
e、便于团队开发


Struts缺点：a、大量的使用标签，对于刚開始学习的人难度较大。
b、ActionForms使用不便、没法进行单元測试（StrutsTestCase仅仅能用于集成）


3. Struts提供了几个标签库？都是什么标签库？
Struts提供了五个标签库，即：HTML、Bean、Logic、Template和Nested。


HTML 标签 用来建立能够和Struts 框架和其它对应的HTML 标签交互的HTML 输入表单
Bean 标签 在訪问JavaBeans 及其属性。以及定义一个新的bean 时使用
Logic 标签 管理条件产生的输出和对象集产生的循环
Template 标签 随着Tiles框架包的出现。此标记已開始下降使用
Nested 标签 加强对其它的Struts 标签的嵌套使用的能力


4. Tiles框架是什么？
Tiles框架为建立Web页面提供了一种模板机制，它能将网页的布局和内容分离。


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

怎样实现?
答：MVC是Model－View－Controller的简写。“Model”表明的是应用的业务逻辑（经过JavaBean，EJB组件实现）,“View”是应用的表示面（由JSP页面产生）。“Controller”是提供应用的处理过程控制（一般是一个Servlet），经过这样的设计模型把应用逻辑，处理过程和显示逻辑分红不一样的组件实现。

这些组件可以进行交互和重用。


二、说说Struts的应用。
答：Struts 是採用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源代码的framework。

採用Struts能开发出基于MVC设计模式的应用构架。 Struts的主要功能包括：一包括一个controller servlet，能将用户的请求发送到对应的Action对象。二JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员建立交互式表单应用。

三提供了一系列有用对象：XML处理、经过Java reflection APIs本身主动处理JavaBeans属性、国际化的提示和消息。


三、strust的Action是否是线程安全的？假设不是有什么方式可以保证Action的线程安全？假设是请说明缘由。
答：不是线程安全的，仅仅要不申明类变量就可以保证线程安全。因为仅仅存在一个Action类实例。所有线程会共享类变量。


四、应用server详细包含那些？
答：应用server详细包含：BEA WebLogic Server、IBM WebSphere Application Server、Oracle9i Application Server、JBoss和Tomcat等。


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在查询数据的时候。数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟载入。他节省了服务 器的内存开销，从而提升了server的性能。
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.视图对象负责渲染返回给client。
为何用：
{AOP 让开发者可以建立非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后。公共服务 （比方日志、持久性、事务等）就可以分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。
IOC 赞成建立一个可以构造对象的应用环境，而后向这些对象传递它们的协做对象。正如单词 倒置 所代表的，IOC 就像反 过来的 JNDI。

没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协做对象构造的。所以是由容器管理协做对象（collaborator）。

Spring即便一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。

有了 Spring。仅仅要用 JavaBean 属性和配置文件增长依赖性（协做对象）。而后可以很是easy地在需要时替换具备相似接口的协做对象。}
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了建立、配置和管理 bean 的方式，如图 1 所看到的。
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其它一个或多个模块联合实现。

每个模块的功能例如如下：
☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
☆ Spring 上下文：Spring 上下文是一个配置文件。向 Spring 框架提供上下文信息。

Spring 上下文包含企业服务，好比 JNDI、EJB、电子邮件、国际化、校验和调度功能。
☆ Spring AOP：经过配置管理特性。Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。因此，可以很是easy地使 Spring 框架管理的不论什么对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。经过使用 Spring AOP。不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

☆ Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构。可用该结构来管理异常处理和不一样数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地减小了需要编写 的异常代码数量（好比打开和关闭链接）。Spring DAO 的面向 JDBC 的异常听从通用的 DAO 异常层次结构。

☆ Spring ORM：Spring 框架插入了若干个 ORM 框架。从而提供了 ORM 的对象关系工具。当中包含 JDO、Hibernate 和 iBatis SQL Map。

所有这些都听从 Spring 的通用事务和 DAO 异常层次结构。
☆ Spring Web 模块：Web 上下文模块创建在应用程序上下文模块之上。为基于 Web 的应用程序提供了上下文。因此。Spring 框架支持与 Jakarta Struts 的集成。

Web 模块还简化了处理多部分请求以及将请求參数绑定到域对象的工做。
☆ Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。经过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，当中包含 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在不论什么 J2EE server中。大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据訪问对象。

毫无疑问。这种对象可以在不一样 J2EE 环境 （Web 或 EJB）、独立应用程序、測试环境之间重用。

IOC 和 AOP
控制反转模式（也称做依赖性介入）的基本概念是：不建立对象，但是描写叙述建立它们的方式。在代码中不直接与对象和服务链接。但在配置文件里描写叙述哪个 组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器） 负责将这些联系在一块儿。

在典型的 IOC 场景中，容器建立了所有对象。并设置必要的属性将它们链接在一块儿，决定什么时间调用方法。

下表列出了 IOC 的一个实现模式。
Spring 框架的 IOC 容器採用类型 2 和类型3 实现。

面向方面的编程
面向方面的编程。即 AOP，是一种编程技术，它赞成程序猿对横切关注点或横切典型的职责分界线的行为（好比日志和事务管理）进行模块化。

AOP 的核心构造是方面。它将那些影响多个类的行为封装到可重用的模块中。
AOP 和 IOC 是补充性的技术。它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才干实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。

固然，优点就是 Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。

因此。用 Spring AOP 编写的应用程序代码是松散耦合的。
AOP 的功能全然集成到了 Spring 事务管理、日志和其它各类特性的上下文中。
IOC 容器
Spring 设计的核心是 org.springframework.beans 包。它的设计目标是与 JavaBean 组件一块儿使用。

这个包一般不是由用户直接使用，而是由server将其用做其它多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现。赞成经过名称建立和检索对象。

BeanFactory 也可以管理对象之间的关系。

BeanFactory 支持两个对象模型。

□ 单态 模型提供了具备特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很是理想。
□ 原型 模型确保每次检索都会建立单独的对象。

在每个用户都需要本身的对象时，原型模型最适合。

bean 工厂的概念是 Spring 做为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个演示样例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。

  
1.  BeanFactory的做用是什么？   [中]   
BeanFactory是配置、建立、管理bean的容器。有时候也称为bean上下文。Bean与bean的依赖关系，也是由BeanFactory负责维护的。

  
2.  bean在spring的容器中两种基本行为是什么? [中]   
Singleton:单态   
Non-singleton或prototype:原型   
3.  spring配置文件里的ref元素的做用是什么?它的两个基本属性是什么?  [中]   
用于指定属性值为spring容器中的其余bean.两个基本属性是bean和local   
4.  什么是DWR?它有哪些功能？  [中]   
DWR(Direct Web Remoting)是一个WEB远程调用框架.   
可以在client利用JavaScript直接调用服务端的Java方法并返回值给JavaScript   
DWR依据Java类来动态生成JavaScrip代码.   
支持Dom Trees,支持Spring,支持commons-logging   
5.  Ajax的工做原理 ？　［难］   
在会话的開始，浏览器载入Ajax引擎   
请求动做经过JavaScript调用Ajax引擎来取代.    
引擎负责绘制用户界面以及与server端通信。   
Ajax引擎採用异步交互过程－－不用等待server的通信。   
6.  XMLHttpRequest对象是什么，它有哪些常常用法？ [难]      
一个 JavaScript 对象。

是Ajax 的核心。   
该对象的方法和属性。

  
    open()：创建到server的新请求。

   
    send()：向server发送请求。    
    abort()：退出当前请求。    
    readyState：提供当前 HTML 的就绪状态。    
    responseText：server返回的请求响应文本。.   
  
7.  XMLHttpRequest有哪些属性， 它的值分表明什么？[ 中]   
  
    
  
8.  什么是Ajax?

 [易]   
AJAX（Asynchronous JavaScript and XML）。它不是一门新的语言或技术，而是多种技术的综合，包含：   
Javascript   
XHTML   
CSS   
DOM   
XML   
XSTL   
XMLHttpRequest   
  
9.  同步与异步的差异？ [ 难]   
普通B/S模式（同步）AJAX技术（异步）   
同步：提交请求->等待server处理->处理完成返回 这个期间client浏览器不能干不论什么事，而异步则是 请求经过事件触发->server处理->处理完成   
同步是堵塞模式。异步是非堵塞模式。     
同步(发送方发出数据后，等接收方发回) 异步(发送方发出数据后。不等接收方发回响应)   
  
10. Struts+Hibernate+Spring开发模式中Hibernate扮演的角色  [中]   
  答：Hibernate扮演的是数据持久层 它的做用是实现持久化对象和数据库表   
之间的映射，造成持久化对象和数据库表中数据的一个转换平台   
  
11. 什么是Hibernate 的抓取策略  [难]   
  抓取策略是指当应用程序需要利用关联关系进行对象获取的时候。   
12. 何为容器  [中]   
  容器就是符合某种规范的能够提供一系列服务的管理器。

  
13. Spring实现了那几种模式  [中]   
答: 工厂模式 和 单例模式   
  
14 :Hibernate实体对象生命周期的三种状态  [难]   
答 Transient(瞬态) ，persistent(持久态)和Detached(游历态)   
  
15: HQL查询參数的处理方法  [中]   
答：直接将參数拼写为HQL语句   
经过參数名称来标识參数   
  
16. Hibernate实体之间的关联关系的三种形式  [中]   
   答  一对一关联   
       一对多关联   
       多对多关联   
  
17.  Hibernate具用的三种检索方式  [难]   
答：HQL检索方式   
    QBC检索方式   
    SQL检索方式   
18. spring 中<Bean>的depends-on属性是什么  [中]   
Depends-on用于当前Bean初始化以前显示的强制一个或多个bean被初始化   
19.  spring 中的BeanWrapper类是什么  [难]   
BeanWrapper类是一个对JavaBean进行各类操做的工具类   
BeanWrapper自己是一个接口BeanWrapperImpl实现了BeanWrapper   
20 . <set>元素有一个cascade属性，假设但愿Hibernate级联保存集合中的对象，casecade属性应该取什么值？  [难]   
   答:save-update   
21.  Hibernate中session何时是游离态  [中]   
答:session.close();方法后    
22. Hibernate中映射文件<hibernate-mapping> inverse属性和cascade属性的差异  [中]   
   答:inverse属性仅仅存在于集合标记的元素中集合元素包含<set/>,<map/>,<list/>,<array/>,<bag/>   
  Inverse属性的做用是是否将对集合对象的改动反射到数据库中 inverse=”false”时改动反射到数据库中 inverse=”true” 时改动不反射到数据库中   
  Cascade属性的做用是描写叙述关联对象进行操做时的级联特性。所以仅仅有涉及到关系的元素才有cascade属性   
  
23. : Hibernate中Session对象的load()方法和get()方法的差异（请列举出两点）[难]   
答：①记录不存在时 get()方法会返回空（null），而load()方法将会抛出一个HibernateException异常 ② load()方法查询数据时会先找Hibernate的内部缓存和二级缓   
存中的现有数据。get()方法在内部缓存中没有打到相相应的数据时装直接运行SQL语句   
进行查询   
24. : Hibernate中HQL属于什么语言  [易]   
  答：HQL是面向对象的查询语言，它可以查询以对象形式存在的数据。   
  
25.  Hibernate简单介绍以及主要功能  [中]   
  答：Hibernate是採用ORM模式实现数据持久层的一个优秀的JAVA组件，它提供了   
强大，高效的将JAVA对象进行持久化操做的服务   
  
26. 简述Hibernate的长处 [难]   
 答：开源和免费的License，我可以在需要的时候研究源码，改写源码，进行功能的定制。轻量级封装，避免引入过多复杂的问题。调试easy，也减轻程序猿的负担。

   
具备可扩展性。API开放，当自己功能不够用的时候，可以本身编码进行扩展。   
  
27. 如何构建SessionFactory  [难]   
  答: Hibernate的SessionFactory接口提供Session类的实例，Session类用于完毕对数据库的操做。   
由于SessionFactory实例是线程安全的（而Session实例不是线程安全的）。因此每个操做都可以共用同一个SessionFactory来获取Session。Hibernate配置文件分为两种格式，一种是xml格式的配置文件。还有一种是Java属性文件格式的配置文件   
28. :从XML文件读取配置信息构建SessionFactory的详细过程例如如下。  [难]   
（1）建立一个Configuration对象，并经过该对象的configura()方法载入Hibernate配置文件，代码例如如下。

  
Configuration config = new Configuration().configure();   
configura()方法：用于告诉Hibernate载入hibernate.cfg.xml文件。

Configuration在实例化时默认载入classpath中的hibernate.cfg.xml，固然也可以载入名称不是hibernate.cfg.xml的配置文件。好比wghhibernate.cfg.xml，可以经过下面代码实现。

  
Configuration config = new Configuration().configure("wghhibernate.cfg.xml");   
（2）完毕配置文件和映射文件的载入后，将获得一个包含所有Hibernate执行期參数的Configuration实例，经过Configuration实例的buildSessionFactory()方法可以构建一个唯一的SessionFactory，代码例如如下:   
SessionFactory sessionFactory = config.buildSessionFactory();   
构建SessionFactory要放在静态代码块中，因为它仅仅在该类被载入时运行一次。   
  
29. 写出使用构造方法进行注入的关键代码  [难]   
<bean id=”constructBean” class=”com.huang.ConstructBean”>   
 <constructor-arg><ref  bean=”bean_1”/></ constructor-arg >   
<constructor-arg><ref  bean=”bean_2”/></ constructor-arg >   
<constructor-arg><ref  bean=”bean_3”/></ constructor-arg >   
</bean>   
  
  
30. 什么是IOC？  [难]   
不建立对象，但是描写叙述建立它们的方式。

在代码中不直接与对象和服务链接，但在配置文件里描写叙述哪个组件需要哪一项服务。容器（在Spring 框架中是 IOC 容器） 负责将这些联系在一块儿。    
就是由容器控制程序之间的关系。而非传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器。控制权的转移，就是所谓的反转。

  
  
31. 编程题: 写一个Singleton出来。  [难]   
Singleton模式主要做用是保证在Java应用程序中。一个类Class仅仅有一个实例存在。

  
  
第一种形式: 定义一个类，它的构造函数为private的。它有一个static的private的该类变量，在类初始化时实例话，经过一个public的getInstance方法获取对它的引用,继而调用当中的方法。

  
public class Singleton {   
private Singleton(){}   
　　    private static Singleton instance = new Singleton();   
　　    public static Singleton getInstance() {   
　　　　    return instance; 　　   
　　    }    
    }    
    另一种形式:    
public class Singleton {    
　　private static Singleton instance = null;   
　　public static synchronized Singleton getInstance() {   
　　if (instance==null)   
　　　　instance＝new Singleton();   
        return instance; 　　}    
}   
  
  
    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;   
  }   
32. J2EE是技术仍是平台仍是框架？  [中]   
    J2EE自己是一个标准。一个为企业分布式应用的开发提供的标准平台。   
    J2EE也是一个框架。包含JDBC、JNDI、RMI、JMS、EJB、JTA等技术。   
  
33. 咱们在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;   
  }   
３４．怎样使用静态工厂方法来建立Bean的实例  [易]   
   <bean id=”staticFactoryBean” class=”com.huang.StaticFactoryBean”   
factory-method=”静态方法名”/>   
至关于: StaticFactoryBean staticFactoryBean=StaticFactoryBean.静态方法名   
  
使用实例化的工厂方法来建立Bean的实例   
   <!—注意此时bean的class属性为空-->   
  <bean id=”dynamicFactory”class=”com.huang.DynamicFactory”/>   
  <bean id=”dynamiceFactoryBean” factory-bean=”dynamicFactory”   
   Factory-method=”方法名”/>   
至关于: DynamicFactory dynamicFactory=new DynamicFactory();   
      DynamiceFactoryBean dynamiceFactoryBean=dynamicFactory.方法名   
35.  从Java属性文件读取配置信息构建SessionFactory的详细过程例如如下:  [难]   
   （1）建立一个Configuration对象，此时Hibernate会默认载入classpath中的配置文件hibernate.properties。代码例如如下。   
Configuration config = new Configuration();   
（2）由于在配置文件里缺乏对应的配置映射文件的信息，因此此处需要经过编码方式载入。这可以经过Configuration对象的addClass()方法实现，详细代码例如如下。   
config.addClass(BranchForm.class);   
addClass()方法用于载入实体类。   
（3）完毕配置文件和映射文件的载入后，将获得一个包含所有Hibernate执行期參数的Configuration实例。经过Configuration实例的buildSessionFactory()方法可以构建一个唯一的SessionFactory，代码例如如下。   
SessionFactory sessionFactory = config.buildSessionFactory();   
  
  
  
36. spring框架的7个模块是什么？   [ 难]   
答: (1) spring  AOP  --面象切面编程   
   (2)spring  DAO  --数据訪问对象   
   (3)spring ORM   --对象关系影射   
(4)spring Contect  -- 上下文配置，向Spring框架提供上下文信息   
(5)spring WEB  - -WEB上下文模块   
(6)\spring WEB-MVC  --实现了MVC   
(7)spring CORE –核心容器提供Spring框架基本功能   
  
37. 什么是AOP 请祥述  [中]   
  答: 是面向切面编程    
     AOP 把软件系统分为两个部分：核心关注点和横切关注点。

所谓的核心关注点。是业务处理的主要流程。也就是说这个解决方式要作的事。所谓横切关注点，是与核心业务无关的部分。它把常发生在核心关注点的多处，而各处基本类似。如日志，事务，权限等 。   
  
38.  Hinbernate和EJB的差异  [中]   
 答：Hibernate可以用在不论什么JDBC使用的场合，好比Java应用程序的数据库訪问代码，DAO接口的实现类，甚至可以是BMP里面的訪问数据库的代码。

从这个意义上来讲，Hibernate和EB不是一个范畴的东西，也不存在非此即彼的关系。   
  
39.  普通状况下，关系数据模型与对象模型之间有哪些匹配关系 [难]   
   答：表相应类   
记录相应表的对象   
表的字段相应类的属性   
  
40.  事务隔离级别是由谁实现的？  [难]   
 答：数据库系统‘   
  
41. 什么是IOC  [难]   
答：IOC 是控制反转。实现了对象之间的依赖关系的转移成而使程序的菘耦合   
42. 在Spring中给属性有几种赋值方式 请祥叙   [难]   
  答：有四种 各自是   
(1)普通属性赋值    
（2）集合属性赋值   
（3）Properties赋值   
(4)Map 属性赋值     
  
43.  在Spring说说Bean的alias元素和name属性有什么差异  [难]   
 答: <bean>元素name属性可以一次为<bean>定义多个别名   
       例：<bean id=”beanName” name=”alias_1,alias_2”/>   
       <alias>元素一次仅仅能定义一个别名   
         例：<alias name=”beanName” alias=”toName”/>   
      注意: alias元素name属性是bean实例名   
44. Bean 的做用域用几种。请祥叙  [难]   
    答: 用5种    
各自是:    
1. singleton  IOC容器仅仅会建立一个Bean的惟一的实例   
2. prototype  IOC容器在每次请求该Bean的时候都建立一个新的实例   
3. request 在一次Http请求中 IOC容器会返回该Bean的同一个实例。而对于不一样的用户请求。则会返回不一样的实例   
4. session 在一次Http请求Session 中 IOC容器会返回该Bean的同一个实例，而对于不一样的用户Session，则会返回不一样的实例   
5. global session在一个全局Http请求Session 中   
  
45. 简述什么是ORM   [中]   
答：ORM的全称是Object-Relational Mapping 翻译成中文就是“对象－关系映射”   
ORM组件的主要功能就是实现实体域对象的持久化并封装数据库訪问的细节   
   ORM自己并不是一个组件，它是具用某种功能的组件的总称，也可以说是一种框   
架结构   
  
46.：struts中的几个关键对象的做用(说说几个关键对象的做用)  [中]   
 struts中的几个关键对象:Action Global(设置语言靠它了) ModuleConfig(获取mapping)，   
47．Action的做用  [中]   
   Action的做用是接受用户的请求，经过调用业务方法实现业务处理的功能。   
48. 在一般状况下软件系统由表示层，业务层，持久层和数据库层组成，Struts属于哪一层？ [难]   
   Struts属于表示层组件，它的做用主要体现在下面几个方面：   
1)     输出用户界面和接收用户的输入。实现与用户的交互。   
2) 调用业务方法，完毕业务处理，还要包含处理后的显示工做。

  
  
48：Struts标签库由哪些组件组成？  [难]   
标签库是组合在一块儿的一组JSP本身定义标签。   
     标签库由下面组件组成：   
1) 标签处理程序   
2) 标签库描写叙述符(TLD)文件   
3) 应用程序部署描写叙述符(web.xml)文件   
4) JSP页面中标签库的声明   
49. 用<bean:write>读出一个URL和一个名称。    [难]    
  用<html:link>的话怎么组合起来。

   
  即要达到这种效果      
  <a   href="<bean:write   name="data"   property="url">">      
           <bean:write   name="data"   property="tilte">      
  </a>   
<html:link   page="<bean:write   name="data"   property="url">">      
      <bean:write   name="data"   property="title"/>      
  </html:link>     会报出属性data无值的错误!(page="<bean:write   name="data"   property="url">"中的data无值。）     
50：如何才干配置＜html:button＞的资源文件？ [难]   
   在资源文件 ApplicationResourses.properties 中增长  label.login=login      
  在jsp页面写：      
  <html:button   name="btn_login"><bean:message   key="label.login"/></html:button>      
  这样显示页面时，button上就会显示label.login的相应内容“login”   
  
  
51. 说说struts框架,的方法的工做原理或流程   [易]   
  答: 对于採用Struts框架的web应用， 在web应用启动时会载入并初始化ActionServlet。ActionServlet从struts-config.xml中读取配置信息，   
 把它们存放到各类配置对象中，好比把Action的映射信息存放在ActionMapping对象中。   
 当ActionServlet接收到客户请求时。运行下面流程：      
    1.检索和用户请求匹配的ActionMapping实例，假设不存在。就返回用户请求路径无效信息。        
     2.假设ActionForm实例不存在，就建立一个ActionForm对象并在当中保存客户提交的表单内容。        
     3.依据配置信息决定是否调用ActionForm的validate()方法；      
     4.假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActionErrors对象。就表示表单验证成功；      
     5.ActionServlet依据ActionMapping实例包括的映射信息将请求转发给Action（假设Action实例不存在，就先建立Action实例），而后调用Action的excute()方法；        
   6.Action的excute()方法返回一个ActionForward对象。ActionServlet再把客户请求转发给ActionForward对象指向的JSP组件；    
7.ActionForward对象指向的JSP组件生成动态网页。返回给客户。    
  
52： strust的Action是否是线程安全的？ [难]   
    答：线程安全就是你可以在多线程环境下使用它。而不需要你来对它进行特殊的处理。action都是继承至servlet的。由于servlet就是线程不安全的（指多个线程共享一个servlet对象。因此），因此不要再action中定义类变量和实例变量，不然其它线程改变了这些值，可本线程还在使用   
53 ：MVC，分析一下struts是怎样实现MVC的 [难]   
从MVC角度来看看struts的体系结构（Model 2）与工做原理：   
　　1）模型（Model）   
　　在Struts的体系结构中。模型分为两个部分：系统的内部状态和可以改变状态的操做（事务逻辑）。

内部状态一般由一组ActinForm Bean表示。依据设计或应用程序复杂度的不一样，这些Bean可以是自包括的并具备持续的状态。或仅仅在需要时才得到数据（从某个数据库）。大型应用程序一般在方法内部封装事务逻辑（操做），这些方法可以被拥有状态信息的bean调用。

比方购物车bean。它拥实用户购买商品的信息，可能还有checkOut()方法用来检查用户的信用卡，并向仓库发订货信息。 小型程序中。操做可能会被内嵌在Action类，它是struts框架中控制器角色的一部分。当逻辑简单时这种方法很是适合。

建议用户将事务逻辑（要作什么）与Action类所扮演的角色（决定作什么）分开。   
2）视图（View）   
　　视图主要由JSP创建，struts包括扩展本身定义标签库（TagLib），可以简化建立全然国际化用户界面的过程。

眼下的标签库包括：Bean Tags、HTML tags、Logic Tags、Nested Tags 以及Template Tags等。   
　3）控制器（Controller）   
  
　　在struts中。主要的控制器组件是ActionServlet类中的实例servelt，实际使用的servlet在配置文件里由一组映射（由ActionMapping类进行描写叙述）进行定义。

对于业务逻辑的操做则主要由Action、ActionMapping、ActionForward这几个组件协调完毕的，当中Action扮演了真正的业务逻辑的实现者。ActionMapping与ActionForward则指定了不一样业务逻辑或流程的执行方向。

struts-config.xml 文件配置控制器。

  
54  ：简述什么是Struts  [中]   
 Struts仅仅是一个MVC框架（Framework）,用于高速开发Java Web应用。

Struts实现的重点在C(Controller)，包含ActionServlet/RequestProcessor和咱们定制的Action,也为V(View)提供了一系列定制标签（Custom Tag）。但Struts差点儿没有涉及M(Model),因此Struts可以採用JAVA实现的不论什么形式的商业逻辑。    
Spring是一个轻型容器(light-weight container)。其核心是Bean工厂(Bean Factory)，用以构造咱们所需要的M(Model)。

在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现。用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便咱们实现J2EE的应用；DAO/ORM的实现方便咱们进行数据库的开发；Web MVC和Spring Web提供了Java Web应用的框架或与其它流行的Web框架进行集成。    
就是说可将二者一块儿使用。达到将二者自身的特色进行互补。   
  
55   ：Struts有哪些主要功能：[难]   
1.包括一个controller　servlet，能将用户的请求发送到对应的Action对象。   
2. JSP自由tag库，并且在controller　servlet中提供关联支持，帮助开发员建立交互式表单应用。   
3. 提供了一系列有用对象：XML处理、经过Java　reflection　APIs本身主动处理JavaBeans属性、国际化的提示和消息。

  
Struts项目的目标是为建立Java web应用提供一个开放源码的framework。Struts framework的内核是基于好比Java Servlets, JavaBeans, ResourceBundles, 和 XML。以及各类 Jakarta Commons包的标准技术的灵活的控制层。   
Struts提供了它自身的控制器组件。并整合了其它技术，以提供模型和视图。对于模型。同大多数的第三方软件包同样。如Hibernate, iBATIS, 或者 Object Relational Bridge，Struts能够和标准数据链接技术相结合。如JDBC和EJB。对于视图，Struts与JavaServer Pages协同工做，包括JSTL和JSF。   
56   ：Stuts框架中控制器组件的类主要有哪些？  [难]   
ActionServlet ,   
RequestProcessor   
, Action,    
 ActionMapping,   
ActionForward   
41：Validator的组成与做用  [难]   
Validator框架主要包含下面几个部分：   
1) 实现各类验证规则的Java类   
2) 配置文件   
3) 资源文件   
4) JSP本身定义标签   
Validator组件可以很是好地解决用户输入数据的验证问题，但它并不是一个独立执行的组件，它可以被嵌入到眼下大部分的Web应用开发框架中。Validator组件的验证方式有多种，既可以经过JavaScript脚本实现用户输入数据的页面验证，也可以实现在后台处理程序中的Java验证   
57. ActionForm的做用？[难]   
  ActionForm属于一种传输数据对象，联系了前台页面与后台的Action方法，实现了前台与后台之间的数据转换和传递。它的做用主要体现在下面几个方面：    
1) 在显示页面的时候用于完毕页面中各类控件的初始化工做。   
2) 在用户提交请求的时候。ActionForm又表明了用户所提交的数据。供Action以及兴许的业务处理方法使用   
ActionForm还有另一个做用就是对用户提交数据的合法性进行验证   
              Java  基础就业题库   
  
1.  类和对象的差异?

   [易]   
类是对象的抽象,是模型概念,而对象是实实在在存在的事物,是现实中存在的实体   
2.  Java类库中八个标准包各自是什么?

 [易]   
java.lang    提供常用的类、接口、通常异常、系统等编程语言的核心内容。

   
java.util    包括日期、日历、向量、堆栈等有用工具。

   
java.io      包括输入输出流类、文件类等与输入输出I/O有关的类。        
java.awt     包括窗体和屏幕元素类。事件处理接口等与图形用户界面有关的内容。

      
java.applet  提供为编写applet小程序所需要的类。    
java.text    提供与文本有关的类。

   
java.net     包括url类等与网络传输有关的东西。        
java.sql     提供与数据库应用相关的类和接口。   
  
3.  接口和抽象类有什么差异?    [中]   
  
接口是公开的，不能包括私有的方法或变量。而抽象类是可以有私有方法或私有变量的，    
实现接口的必定要实现接口里定义的所有方法。而实现抽象类可以有选择地重写需要用到的方法，   
接口可以实现多重继承，而一个类仅仅能继承一个超类。但可以经过继承多个接口实现多重继承。   
接口还有标识（里面没有不论什么方法，如Remote接口）和数据共享（里面的变量全是常量）的做用.   
通常的应用里，最顶级的是接口，而后是抽象类实现接口，最后才到详细类实现。   
  
  
4.  说说java中的内存分配?  [难]   
Java把内存分红两种，一种叫作栈内存，一种叫作堆内存   
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。

当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间。当超过变量的做用域后，java会本身主动释放掉为该变量分配的内存空间，该内存空间可以立马被另做他用。    
  
堆内存用于存放由new建立的对象和数组。在堆中分配的内存，由java虚拟机本身主动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量。之后就可以在程序中使用栈内存中的引用变量来訪问堆中的数组或者对象。引用变量至关于为数组或者对象起的一个别名。或者代号。    
  
引用变量是普通变量。定义时在栈中分配内存，引用变量在程序执行到做用域外释放。

而数组＆对象自己在堆中分配。即便程序执行到使用new产生数组和对象的语句所在地代码块以外。数组和对象自己占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不肯定的时间被垃圾回收器释放掉。

这个也是java比較占内存的主要缘由。但是在敲代码的时候，可以人为的控制   
  
5.  Character类有哪些常常用法?  [难]   
charValue()    
返回字符对象相应的值。

   
digit(char, int)    
以指定基数返回字符 ch 相应的数值。    
equals(Object)    
比較该对象和指定对象。    
forDigit(int, int)    
肯定以指定基数指定的数相应的字符。    
getNumericValue(char)    
返回此字符相应的 Unicode 的非负整型值。

   
getType(char)    
返回一个表示字符种类的值。    
hashCode()    
返回此字符相应的哈希码。    
isDefined(char)    
断定一个字符在 Unicode 中是否有定义。    
isDigit(char)    
断定指定字符是否为数字。    
isIdentifierIgnorable(char)    
断定指定字符在 Java 标识符中或 Unicode 标识符中是否应看做是一个可忽略字符。

   
isISOControl(char)    
断定指定字符是否为 ISO 控制字符。

   
isJavaIdentifierPart(char)    
断定指定字符是否为 Java 标识符中除首字符外的字符。    
isJavaIdentifierStart(char)    
断定指定字符是否可做为 Java 标识符的首字符。    
isJavaLetter(char)    
断定指定字符是否为 Java 字母，如果。它可做为 Java 语言中一个标识符的首字符。 不推荐使用该方法。

   
isJavaLetterOrDigit(char)    
断定指定字符是否为 Java 字母或数字，如果。它可做为 Java 语言中的一个标识符除首字符外的字符。

不推荐使用该方法。    
isLetter(char)    
断定指定字符是否为字母。

   
isLetterOrDigit(char)    
断定指定字符是否为字母或数字。

   
isLowerCase(char)    
断定指定字符是否为小写字符。    
isSpace(char)    
断定指定字符是否为 ISO-LATIN-1 空格。

不推荐使用该方法。    
isSpaceChar(char)    
断定指定字符是否为 Unicode 空白字符。

   
isTitleCase(char)    
断定指定字符是否为标题字符。    
isUnicodeIdentifierPart(char)    
断定指定字符是否为 Unicode 标识符中除首字符外的字符。

   
isUnicodeIdentifierStart(char)    
断定指定字符是否可做为 Unicode 标识符首字符。

   
isUpperCase(char)    
断定指定字符是否为大写字符。    
isWhitespace(char)    
据 Java 语言，断定指定字符是否为空格。

   
toLowerCase(char)    
将给定字符映射为相应的小写字符，若没有相应的小写字符，返回此字符自己。    
toString()    
返回表示此字符值的串对象。

   
toTitleCase(char)    
将字符參数转换为标题字符。    
toUpperCase(char)    
将字符參数转换为大写字符。    
5.Boolean类有哪些方法?

  
booleanValue()    
返回 Boolean 对象相应的布尔值。    
equals(Object)    
当且仅当參数非空，且是包括与此对象一样的布尔值的布尔对象时，返回 true。    
getBoolean(String)    
当且仅当以參数命名的系统属性存在，且等于 "true" 时，返回为 true。

   
hashCode()    
返回此布尔值相应的哈希码。    
toString()    
返回表示当前布尔值的一个串对象。

   
valueOf(String)    
返回表示指定串的布尔值。   
  
6.  String s = new String("xyz");建立了几个String Object?    [中]   
   两个对象。一个是“xyx”,一个是指向“xyx”的引用对象s。    
7.  String与StringBuffer有什么差异?    [难]   
从表面看来String类仅仅用一个加号（+）便完毕了字符串的拼接，而StringBuffer类却要调用一个append()方法，是否实现起来更简洁，更单纯呢？事实上否则，让咱们了解一下程序执行内部发生了哪些事情：    
  
经编译后程序的bytecode（字节码）展现出了实质： 在用String类对象直接拼接时，JVM会建立一个暂时的StringBuffer类对象。并调用其append()方法完毕字符串的拼接，这是因为String类是不可变的。拼接操做不得不使用StringBuffer类（并且－－JVM会将"You are nice."和"I love you so much."建立为两个新的String对象）。

以后。再将这个暂时StringBuffer对象转型为一个String，代价不菲！可见，在这一个简单的一次拼接过程当中，咱们让程序建立了四个对象：两个待拼接的String，一个暂时StringBuffer，和最后将StringBuffer转型成为的String－－它固然不是最初的str了。这个引用的名称没变。但它指向了新的String对象。    
  
而假设直接使用StringBuffer类。程序将仅仅产生两个对象：最初的StringBuffer和拼接时的String（"I love you so much."）。也再也不需要建立暂时的StringBuffer类对象然后还得将其转换回String对象。   
  
short s1 = 1; s1 = s1 + 1;有什么错?

  
short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）   
    short s1 = 1; s1 += 1;有什么错?

   
short s1 = 1; s1 += 1;（可以正确编译）    
  
8.  可否够继承String类?   [难]   
String类是final类故不可以继承。   
  
  
9.  throw与throws有什么差异?

   [中]   
  
throws是用来声明一个方法可能抛出的所有异常信息   
throw则是指抛出的一个详细的异常类型。   
一般在一个方法（类）的声明处经过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部经过throw声明一个详细的异常信息。   
throws一般不用显示的捕获异常，可由系统本身主动将所有捕获的异常信息抛给上级方法；   
throw则需要用户本身捕获相关的异常。然后在对其进行相关包装，最后在将包装后的异常信息抛出。

  
  
throws语句   
throws用来标明一个成员函数可能抛出的各类"异常"。对大多数Exception子类来讲，Java编译器会强迫你声明在一个成员函数中抛出的"异常"的类型。假设"异常"的类型是Error或RuntimeException。或它们的子类，这个规则不起做用，因为这copy;在程序 的正常部分中是不期待出现的。假设你想明白地抛出一个RuntimeException。你必须用throws语句来声明它的类型。这就又一次定义了成员函数的定义语法：type method-name(arg-list) throws exception-list { }如下是一段程序，它抛出了一个"异常"， 但既没有捕捉它，也没实用throws来声明。这在编译时将不会经过。   
  
try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被运行，何时被运行。在return前仍是后?

  
会运行。在return前运行。   
  
10. 常见的runtime exception有哪些?。   [中]   
ArithmeticException,    
ArrayStoreException,    
BufferOverflowException,    
BufferUnderflowException,    
CannotRedoException, CannotUndoException,   
ClassCastException,   
CMMException,    
ConcurrentModificationException,   
DOMException,    
EmptyStackException, IllegalArgumentException,    
IllegalMonitorStateException,    
IllegalPathStateException,    
IllegalStateException,    
ImagingOpException, IndexOutOfBoundsException,    
MissingResourceException,    
NegativeArraySizeException,    
NoSuchElementException, NullPointerException,    
ProfileDataException,    
ProviderException,    
RasterFormatException,    
SecurityException,    
SystemException, UndeclaredThrowableException,    
UnmodifiableSetException,    
UnsupportedOperationException   
NullPointException   
  
11. 介绍JAVA中的Collection FrameWork(包含怎样写本身的数据结构)?    [难]   
答：Collection FrameWork例如如下：    
Collection    
├List    
│├LinkedList    
│├ArrayList    
│└Vector    
│　└Stack    
└Set    
Map    
├Hashtable    
├HashMap    
└WeakHashMap    
Collection是最主要的集合接口，一个Collection表明一组Object，即Collection的元素（Elements）    
Map提供key到value的映射    
  
  
12. ArrayList和Vector的差异,HashMap和Hashtable的差异  [难]   
答：就ArrayList与Vector主要从二方面来讲.    
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的    
二.数据增加:当需要增加时,Vector 默认增加为原来一培，而ArrayList倒是原来的一半    
就HashMap与HashTable主要从三方面来讲。   
一.历史缘由:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现    
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的。不是同步的    
三.值：仅仅有HashMap可以让你将空值做为一个表的条目的key或value   
  
  
13. Math.round(11.5)等於多少? Math.round(-11.5)等於多少?    [难]   
Math.round(11.5)==12  
Math.round(-11.5)==-11  
round方法返回与參数最接近的长整数.   
14. swtich可否做用在byte上。可否做用在long上。可否做用在String上?  [难]   
switch（expr1）中，expr1是一个整数表达式。

应该是 int、 short、 char byte。   
long,string 都不能做用于swtich。   
  
  
15. GC是什么?

为何要有GC?

   [难]   
GC是垃圾收集的意思（Gabage Collection）   
Java提供的GC功能可以本身主动监測对象是否超过做用域从而达到本身主动回收内存的目的，   
Java语言没有提供释放已分配内存的显示操做方法。   
  
  
  
16. 什么叫方法重载   [中]   
方法重载就是一个同名方法。有多种不一样的签名    
说白了就是一个同名方法可以传入不一样个数或类型的參数    
之间可以互相调用   
  
  
17. 数组有没有length()这种方法? String有没有length()这种方法？  [中]   
数组没有length()这种方法，有length的属性。

String有有length()这种方法   
  
18.   什么是抽象类抽象类  [中]   
仅提供一个类型的部分实现。抽象类可以有实例变量，以及一个或多个构造函数。

抽象类可以同一时候有抽象方法和详细方法。一个抽象类不会有实例，这些构造函数不能被client调用来建立实例。一个抽象类的构造函数可以被其子类调用，从而使一个抽象类的所有子类都可以有一些共同的实现，而不一样的子类可以在此基础上有其本身的实现。

  
  
19．  抽象类的用途　　［中］   
1）  详细类不是用来继承的。 Scott Meyers曾指出。仅仅要有可能，不要丛详细类继承。

2）  若是有2个详细类。类A和类B，类B是类A 的子类，那么一个最简单的改动方案是应当创建一个抽象类（或java接口）C，而后让类A和类B成为抽象类C的子类。3）  抽象类应当拥有尽量多的共同代码。以提升代码的复用率。

4）  抽象类应当拥有尽量少的数据。

  
20  .java中接口有什么用?

  [难]   
java不一样意多重继承，也就是说一个子类仅仅能有一个父类，Son extends FatherA,FatherB 是错误的    
为了弥补这点不足，java赞成实现多个接口。Son extends FatherA implements AnotherFatherA,AnotherFatherB是赞成的    
接口中的方法没有实体。就这一点而言就至关于abstact class。如：    
interface ainter{    
void dosth(int i);    
}    
ainter是一个接口。它只声明了一个方法dosth，而没有详细实现它    
class aclass implements ainter    
{    
public void dosth(int i) {    
  
//在这里你可以不做不论什么处理，但是必须实现方法体    
}    
}    
aclass实现了ainter这个接口，所以它必须实现ainter中的方法dosth   
  
21. 什么叫方法重载  [易]   
方法重载就是一个同名方法。有多种不一样的签名    
说白了就是一个同名方法可以传入不一样个数或类型的參数    
之间可以互相调用   
  
  
22. 垃圾回收机制的原理？  [难]   
在JAVA中 ,JAVA VM 每隔一段时间就会查看每一块由NEW分配的内存空间,看指向它的有效引用是否存在,假设这个引用不存在,系统会本身主动将这块空间纳入空暇内存区.这个过程被称为 垃圾收集.   
  
  
23.. 什么叫面向对象?   [中]   
面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继承、封装、消息等基本概念来进行程序设计。

从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽量运用人类的天然思惟方式。

开发一个软件是为了解决某些问题，这些问题所涉及的业务范围称做该软件的问题域。

其应用领域不不过软件，还有计算机体系结构和人工智能等。   
  
  
  
24. 面向对象的涉及方法有哪些?

  [中]   
 OOA－Object Oriented Analysis 　　　　面向对象的分析   
　　   
　　OOD－Object Oriented Design 　　　　　面向对象的设计   
　　   
OOI－Object Oriented Implementation 　面向对象的实现   
  
  
25. jvm工做原理   [难]   
执行jvm 字符码的工做是由解释器来完毕的。解释执行过程分三步进行：   
  
代码的装入、代码的校验、和代码的运行。

  
装入代码的工做由“类装载器class loader”完毕。类装载器负责装入运   
  
行一个程序需要的所有代码，这也包含程序代码中的类所继承的类和被调   
  
用的类。

当类装载器装入一个类时，该类被放在本身的名字空间中。除了   
  
经过符号引用本身名字空间之外的类，类之间没有其它办法可以影响其它   
  
类。在本台计算机的所有类都在同一地址空间中，而所有从外部引进的类   
  
，都有一个本身独立的名字空间。这使得本地类经过共享一样的名字空间   
  
得到较高的执行效率，同一时候又保证它们与从外部引进的类不会相互影响。   
  
当装入了执行程序需要的所有类后，解释器即可肯定整个可执行程序的内   
  
存布局。解释器为符号引用与特定的地址空间创建相应关系及查询表。

通   
  
过在这一阶段肯定代码的内布局，java很是好地攻克了由超类改变而使子类   
  
崩溃的问题。同一时候也防止了代码的非法訪问。   
随后，被装入的代码由字节码校验器进行检查。校验器可以发现操做数栈   
  
益处、非法数据类型转化等多种错误。经过校验后，代码便開始运行了。

  
java字节码的运行有两种方式：   
1） 即时编译方式：解释器先将字节编译成机器码，而后再运行该机器码   
。

  
2）解释运行方式：解释器经过每次解释并运行一小段代码来完毕java字节   
  
码程序的所有操做。

  
  
  
  
26. .java中输入输出流有哪些相关的类?

 [难]   
Input和Output    
1. stream表明的是不论什么有能力产出数据的数据源。或是不论什么有能力接收数据的接收源。在Java的IO中，所有的stream（包含Input和Out stream）都包含两种类型：    
  
1.1 以字节为导向的stream    
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。

以字节为导向的stream包含如下几种类型：    
1) input stream：    
1) ByteArrayInputStream：把内存中的一个缓冲区做为InputStream使用    
2) StringBufferInputStream：把一个String对象做为InputStream    
3) FileInputStream：把一个文件做为InputStream，实现对文件的读取操做    
4) PipedInputStream：实现了pipe的概念，主要在线程中使用    
5) SequenceInputStream：把多个InputStream合并为一个InputStream    
2) Out stream    
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中    
2) FileOutputStream：把信息存入文件里    
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用    
4) SequenceOutputStream：把多个OutStream合并为一个OutStream    
1.2 以Unicode字符为导向的stream    
以Unicode字符为导向的stream。表示以Unicode字符为单位从stream中读取或往stream中写入信息。

以Unicode字符为导向的stream包含如下几种类型：    
1) Input Stream    
1) CharArrayReader：与ByteArrayInputStream相应    
2) StringReader：与StringBufferInputStream相应    
3) FileReader：与FileInputStream相应    
4) PipedReader：与PipedInputStream相应    
2) Out Stream    
1) CharArrayWrite：与ByteArrayOutputStream相应    
2) StringWrite：无与之相应的以字节为导向的stream    
3) FileWrite：与FileOutputStream相应    
4) PipedWrite：与PipedOutputStream相应    
以字符为导向的stream基本上对有与之相相应的以字节为导向的stream。两个相应类实现的功能一样，字是在操做时的导向不一样。    
如CharArrayReader：和ByteArrayInputStream的做用都是把内存中的一个缓冲区做为InputStream使用，所不一样的是前者每次从内存中读取一个字节的信息。然后者每次从内存中读取一个字符。

   
1.3 两种不现导向的stream之间的转换    
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。    
2. stream加入属性    
2.1 “为stream加入属性”的做用    
运用上面介绍的Java中操做IO的API，咱们就可完毕咱们想完毕的不论什么操做了。但经过FilterInputStream和FilterOutStream的子类，咱们可以为stream加入属性。如下以一个样例来讲明这样的功能的做用。    
假设咱们要往一个文件里写入数据，咱们可以这样操做：    
FileOutStream fs = new FileOutStream(“test.txt”);    
而后就可以经过产生的fs对象调用write()函数来往test.txt文件里写入数据了。但是，假设咱们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件里”的功能时。上面的API就没有一个能知足咱们的需求了。

但是经过FilterInputStream和FilterOutStream的子类，为FileOutStream加入咱们所需要的功能。

   
2.2 FilterInputStream的各类类型    
2.2.1 用于封装以字节为导向的InputStream    
1) DataInputStream：从stream中读取基本类型（int、char等）数据。

   
2) BufferedInputStream：使用缓冲区    
3) LineNumberInputStream：会记录input stream内的行数。而后可以调用getLineNumber()和setLineNumber(int)    
4) PushbackInputStream：很是少用到，通常用于编译器开发    
2.2.2 用于封装以字符为导向的InputStream    
1) 没有与DataInputStream相应的类。

除非在要使用readLine()时改用BufferedReader，不然使用DataInputStream    
2) BufferedReader：与BufferedInputStream相应    
3) LineNumberReader：与LineNumberInputStream相应    
4) PushBackReader：与PushbackInputStream相应    
2.3 FilterOutStream的各类类型    
2.2.3 用于封装以字节为导向的OutputStream    
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。    
2) BufferedOutStream：使用缓冲区    
3) PrintStream：产生格式化输出    
2.2.4 用于封装以字符为导向的OutputStream    
1) BufferedWrite：与相应    
2) PrintWrite：与相应    
3. RandomAccessFile    
1) 可经过RandomAccessFile对象完毕对文件的读写操做    
2) 在产生一个对象时，可指明要打开的文件的性质：r。仅仅读。w。仅仅写。rw可读写    
3) 可以直接跳到文件里指定的位置    
4. I/O应用的一个样例    
import java.io.*;    
public class TestIO{    
public static void main(String[] args)    
throws IOException{    
//1.以行为单位从一个文件读取数据    
BufferedReader in =    
new BufferedReader(    
new FileReader("F:\\nepalon\\TestIO.java"));    
String s, s2 = new String();    
while((s = in.readLine()) != null)    
s2 += s + "\n";    
in.close();    
  
//1b. 接收键盘的输入    
BufferedReader stdin =    
new BufferedReader(    
new InputStreamReader(System.in));    
System.out.println("Enter a line:");    
System.out.println(stdin.readLine());    
  
//2. 从一个String对象中读取数据    
StringReader in2 = new StringReader(s2);    
int c;    
while((c = in2.read()) != -1)    
System.out.println((char)c);    
in2.close();    
  
//3. 从内存取出格式化输入    
try{    
DataInputStream in3 =    
new DataInputStream(    
new ByteArrayInputStream(s2.getBytes()));    
while(true)    
System.out.println((char)in3.readByte());    
}    
catch(EOFException e){    
System.out.println("End of stream");    
}    
  
//4. 输出到文件    
try{    
BufferedReader in4 =    
new BufferedReader(    
new StringReader(s2));    
PrintWriter out1 =    
new PrintWriter(    
new BufferedWriter(    
new FileWriter("F:\\nepalon\\ TestIO.out")));    
int lineCount = 1;    
while((s = in4.readLine()) != null)    
out1.println(lineCount++ + "：" + s);    
out1.close();    
in4.close();    
}    
atch(EOFException ex){    
System.out.println("End of stream");    
}    
  
//5. 数据的存储和恢复    
try{    
DataOutputStream out2 =    
new DataOutputStream(    
new BufferedOutputStream(    
new FileOutputStream("F:\\nepalon\\ Data.txt")));    
out2.writeDouble(3.1415926);    
out2.writeChars("\nThas was pi:writeChars\n");    
out2.writeBytes("Thas was pi:writeByte\n");    
out2.close();    
DataInputStream in5 =    
new DataInputStream(    
new BufferedInputStream(    
new FileInputStream("F:\\nepalon\\ Data.txt")));    
BufferedReader in5br =    
new BufferedReader(    
new InputStreamReader(in5));    
System.out.println(in5.readDouble());    
System.out.println(in5br.readLine());    
System.out.println(in5br.readLine());    
}    
catch(EOFException e){    
System.out.println("End of stream");    
}    
  
  
27. 构造器Constructor是否可被(覆盖)override?  [难]   
构造器Constructor不能被继承，所以不能重写Overriding，但可以被重载Overloading。

  
  
  
28. JAVA反射机制做用是什么?   [难]   
可以于执行时载入、探知、使用编译期间全然未知的    
classes。

换句话说，Java程序可以载入一个执行时才得知名称    
的class，获悉其完整构造（但不包含methods定义），并生成其    
对象实体、或对其fields设值、或唤起其methods1。   
  
  
  
  
29. web应用程序体系结构是如何的?

  [难]   
通常分为表示层、业务层、数据存取层   
30. .GET和POST有什么差异？   [难]   
GET是明码传递，POST是暗码传递   
  
  
31. HTTP协议的特色？  [中]   
使用port发送和接受消息 。port是协议发送和接收数据的信道或机制 ，80是默认port   
经过这样的协议传递数据server不会保存链接信息。所以又称为链接信息。

  
  
32. 怎样经过RandomAccessFile操做文件  [难]    
RandomAccessFile rf =    
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");    
for(int i=0; i<10; i++)    
rf.writeDouble(i*1.414);    
rf.close();    
  
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");    
for(int i=0; i<10; i++)    
System.out.println("Value " + i + "：" + rf.readDouble());    
rf.close();    
  
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");    
rf.seek(5*8);    
rf.writeDouble(47.0001);    
rf.close();    
  
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");    
for(int i=0; i<10; i++)    
System.out.println("Value " + i + "：" + rf.readDouble());    
rf.close();    
}    
}    
  
  
32. 静态方法有什么优势?  [难]   
  
（1）在Java里。可以定义一个不需要建立对象的方法。这个方案就是静态方法。要实现这种效果，仅仅需要在类中定义的方法前加上statickeyword。好比：public static int maximum(int n1,int n2)   
使用类的静态方法时，注意：   
a）           在静态方法里仅仅能直接调用同类中其它的静态成员（包含变量和方法），而不能直接訪问类中的非静态成员。

这是因为，对于非静态的方法和变量。需要先建立类的实例对象后才可以使用。而静态方法在使用前不用建立不论什么对象。   
b）          静态方法不能以不论什么方式引用this和superkeyword。因为静态方法在使用前不用建立不论什么实例对象。当静态方法调用时，this所引用的对象根本没有产生。   
（2）静态变量是属于整个类的变量而不是属于某个对象的。

注意不能把不论什么方法体内的变量声明为静态。好比：   
fun()   
{   
   static int i=0;//非法。   
}   
（3）一个类可以使用不包括在不论什么方法体中的静态代码块，当类被加载时，静态代码块被运行，且之被运行一次，静态块常用来运行类属性的初始化。

好比：   
static  
{   
}   
  
  
33. Set里的元素是不能反复的。那么用什么方法来区分反复与否呢?

是用==仍是equals()?

它们有何差异?

  [中]   
Set里的元素是不能反复的，那么用iterator()方法来区分反复与否。

equals()是推断两个对象是否相等。   
  
  
  
34. JAVA中的静态方法有什么理解?   [难]   
  
在Java里，可以定义一个不需要建立对象的方法。这个方案就是静态方法。要实现这种效果。仅仅需要在类中定义的方法前加上statickeyword。好比：public static int maximum(int n1,int n2)   
使用类的静态方法时，注意：   
a）           在静态方法里仅仅能直接调用同类中其它的静态成员（包含变量和方法），而不能直接訪问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先建立类的实例对象后才可以使用，而静态方法在使用前不用建立不论什么对象。   
b）          静态方法不能以不论什么方式引用this和superkeyword，因为静态方法在使用前不用建立不论什么实例对象。当静态方法调用时，this所引用的对象根本没有产生。   
（2）静态变量是属于整个类的变量而不是属于某个对象的。注意不能把不论什么方法体内的变量声明为静态。好比：   
fun()   
{   
   static int i=0;//非法。

  
}   
（3）一个类可以使用不包括在不论什么方法体中的静态代码块，当类被加载时。静态代码块被运行，且之被运行一次，静态块常用来运行类属性的初始化。好比：   
static  
{   
}   
  
35. JSP中动态INCLUDE与静态INCLUDE的差异？　［难］   
动态INCLUDE用jsp:include动做实现 <jsp:include page="included.jsp" flush="true" />它老是会检查所含文件里的变化，   
适合用于包括动态页面。并且可以带參数。

  
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包括静态页面<%@ include file="included.htm" %>   
  
  
36. Java有没有goto?   
java中的保留字，现在没有在java中使用。

  
  
37. 启动一个线程是用run()仍是start()?   [难]   
启动一个线程是调用start()方法，使线程所表明的虚拟处理机处于可执行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立刻执行。run()方法可以产生必须退出的标志来中止一个线程。   
  
  
38. swtich可否做用在byte上。可否做用在long上，可否做用在String上? [易]   
switch（expr1）中，expr1是一个整数表达式。应该是 int、 short、 char byte。   
long,string 都不能做用于swtich。

  
  
39. try {}里有一个return语句。那么紧跟在这个try后的finally {}里的code会不会被运行。何时被运行，在return前仍是后?  [难]   
会运行，在return前运行。

  
  
40. 两个对象值一样(x.equals(y) == true)，但却可有不一样的hash code，这句话对不正确?   
不正确，有一样的hash code。  [易]   
\   
41. char型变量中能不能存贮一个中文汉字?为何?

  [难]   
可以。因为java中以unicode编码。一个char占16个字节，因此放一个中文是没问题的   
  
42. Java中的线程有四种状态各自是是什么？ [难]   
执行、就绪、挂起、结束。

  
  
43. java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们各自是哪些类？  [难]   
字节流，字符流。   
字节流继承于InputStream \ OutputStream。   
字符流继承于InputStreamReader \ OutputStreamWriter。   
  
44. 静态变量和实例变量的差异？ [中]   
static i = 10; //常量   
class A a;  a.i =10;//可变   
  
45. 什么是java序列化，怎样实现java序列化？  [难]   
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。

可以对流化后的对象进行读写操做，也可将流化后的对象传输于网络之间。

序列化是为了解决在对对象流进行读写操做时所引起的问题。

  
序列化的实现：   
将需要被序列化的类实现Serializable接口。该接口没有需要实现的方法，implements Serializable仅仅是为了标注该对象是可被序列化   
  
46. 可否够从一个static方法内部发出对非static方法的调用？ [难]   
不可以,假设当中包括对象的method()；不能保证对象初始化.   
  
47. 在JAVA中，怎样跳出当前的多重嵌套循环？ [难]   
用break; return 方法。

  
  
48. 面向对象的特征有哪些方面    [中]   
1.抽象：   
抽象就是忽略一个主题中与当前目标无关的那些方面。以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而仅仅是选择当中的一部分，临时不用部分细节。抽象包含两个方面，一是过程抽象。二是数据抽象。

  
2.继承：   
继承是一种联结类的层次模型。并且赞成和鼓舞类的重用，它提供了一种明白表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以改动或添加新的方法使之更适合特殊的需要。   
3.封装：   
封装是把过程和数据包围起来。对数据的訪问仅仅能经过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列全然自治、封装的对象，这些对象经过一个受保护的接口訪问其它对象。   
4. 多态性：   
多态性是指赞成不一样类的对象对同一消息做出响应。多态性包括參数化多态性和包括多态性。多态性语言具备灵活、抽象、行为共享、代码共享的优点，很是好的攻克了应用程序函数同名问题。

  
  
49. String是最主要的数据类型吗?  [中]   
基本数据类型包含byte、int、char、long、float、double、boolean和short。   
java.lang.String类是final类型的。所以不可以继承这个类、不能改动这个类。

为了提升效率节省空间，咱们应该用StringBuffer类   
50. int 和 Integer 有什么差异  [中]   
Java 提供两种不一样的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

  
  
51. 执行时异常与通常异常有何异同？   [ 难]   
异常表示程序执行过程当中可能出现的非正常状态。执行时异常表示虚拟机的一般操做中可能遇到的异常，是一种常见执行错误。java编译器要求方法必须声明抛出可能发生的非执行时异常，但是并不要求必须声明抛出未被捕获的执行时异常。   
  
52. &和&&的差异。 [ 中]    
&是位运算符，表示按位与运算，&&是逻辑运算符。表示逻辑与（and）。   
  
53. final, finally, finalize的差异。  [中]   
final 用于声明属性，方法和类。分别表示属性不可变，方法不可覆盖。类不可继承。   
finally是异常处理语句结构的一部分。表示老是运行。

  
finalize是Object类的一个方法，在垃圾收集器运行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其它资源回收，好比关闭文件等。   
  
  
Jsp/servlet面试题   
1. 四种会话跟踪技术是什么？(jsp) (中)   
答：cookie,url重写,session,隐藏表单域。

  
2.不一样client可不可以共享Session?不可以 (易)   
Jps和Servlet之间可不可以用session传值?

可以   
3.简单介绍cookie的有关知识 (中)   
浏览器与WEBserver之间是使用HTTP协议进行通讯的。当某个用户发出页面请求时，WEBserver仅仅是简单的进行响应，而后就关闭与该用户的链接。所以当一个请求发送到WEBserver时，无论其是不是第一次来訪，server都会把它看成第一次来对待。这种很差之处可想而知。为了弥补这个缺陷，Netscape 开发出了cookie这个有效的工具来保存某个用户的识别信息，所以人们昵称为“小甜饼”。cookies是一种WEBserver经过浏览器在訪问者的硬盘上存储信息的手段：Netscape Navigator使用一个名为cookies.txt本地文件保存从所有网站接收的Cookie信息；而IE浏览器把Cookie信息保存在相似于C: \windows\cookies的文件夹下。当用户再次訪问某个网站时，服务端将要求浏览器查找并返回先前发送的Cookie信息，来识别这个用户。   
　　cookies给站点和用户带来的优势许多：   
一、Cookie能使网站跟踪特定訪问者的訪问次数、最后訪问时间和訪问者进入网站的路径   
二、Cookie能告诉在线广告商广告被点击的次数 ，从而可以更精确的投放广告   
三、Cookie有效期限未到时，Cookie能使用户在不键入password和username的状况下进入之前浏览过的一些网站   
四、Cookie能帮助网站统计用户我的资料以实现各类各样的个性化服务    
JSP是使用例如如下的语法格式来建立cookie的：   
　　Cookie cookie_name =new Cookie(""Parameter"",""Value"");   
　　好比：Cookie newCookie =new Cookie(""username"",""zheng""); response.addCookie(newCookie);   
  
4.在浏览器的打开时再新打开一个浏览器仍是同一个session吗? (中)   
对IE而言不是同一个SESSION   
5.描写叙述Cookie和Session的做用。差异和各自的应用范围 (中)   
Cookie和Session都可以用来在多个页面之间共享数据,差异是Cookie保存在client,可以设置比較长的保存时间.而Session保存在server端,一般生存时间较短。

假设client禁用了Cookie,Cookie将没法工做。而session不受这一影响。通常来讲保密性高、保存时间短的信息适合用session来存放，而Cookie适合存放需要长期保存的非敏感数据。   
  
6.怎样实现购物车加入新项,又不使购物车中原有项目被取消?

(易)   
可以将购物车存放在session其中   
  
7.Cookie的过时时间怎样设置? (易)   
使用setMaxAge(int exp)方法   
  
8.假设BROWSER已关闭了cookies,在JSP中我怎样打开session? (中)   
假设Cookie被禁用。session将经过url重写的方式来传送。因此不会影响session的使用   
  
9.include指令和include动做的差异  (中)   
    
10. Jsp有哪些常用动做?

做用各自是什么?

(jsp)  (中)   
答：JSP有6种常用基本动做 jsp:include：在页面被请求的时候引入一个文件。

   
jsp:useBean：寻找或者实例化一个JavaBean。    
jsp:setProperty：设置JavaBean的属性。

   
jsp:getProperty：输出某个JavaBean的属性。    
jsp:forward：把请求转到一个新的页面。    
jsp:plugin：依据浏览器类型为Java插件生成OBJECT或EMBED标记。   
  
11. "forward与redirect差异? (中)   
Forward是在server端进行分发,分发后地址栏无变化,用户看不到分发后的地址.而redirect是在client进行的页面重定向,地址栏上会显示重定向后的网页.forward的页面仅仅能是在同一个web应用程序以内,而重定向可以定位到外部资源.forward后仍是同一个request请求,而重定向后曾经的request请求就不存在了.   
  
12.Jsp和Servlet中的请求转发分别怎样实现?

(易)   
Jsp中使用<jsp:forward>动做,servlet中使用RequestDistpatcher对象的forward方法"   
  
13.什么是web容器？(易)   
答：给处于当中的应用程序组件（JSP。SERVLET）提供一个环境，使JSP,SERVLET直接更容器中的环境变量接口交互，没必要关注其余系统问题。主要有WEBserver来实现。好比：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵照J2EE规范中的WEB APPLICATION 标准。咱们把遵照以上标准的WEBserver就叫作J2EE中的WEB容器。   
  
14.应用server有那些？ (中)   
答：BEA WebLogic Server。IBM WebSphere Application Server。Oracle9i Application Server，JBoss，Tomcat。"   
  
15.请说出JSP的内置对象及方法 (中)   
答：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实例。   
  
16.使用JSP怎样得到客户浏览器的信息?  (易)   
request对象的getXXXX方法"   
  
17.B/S与C/S的联系与差异。  (中)   
答：C/S是Client/Server的缩写。

server一般採用高性能的PC、工做站或小型机，并採用大型数据库系统。如Oracle、Sybase、Informix或    
SQL Server。client需要安装专用的client软件。   
B/Ｓ是Brower/Server的缩写，客户机上仅仅要安装一个浏览器（Browser），如Netscape    
Navigator或Internet Explorer，server安装Oracle、Sybase、Informix或 SQL    
Server等数据库。在这样的结构下。用户界面全然经过WWW浏览器实现，一部分事务逻辑在前端实现。但是主要事务逻辑在server端实现。浏览器经过Ｗeb    
Server 同数据库进行数据交互。

  
C/S 与 B/S 差异：   
１）．硬件环境不一样:   
　　C/S 通常创建在专用的网络上, 小范围里的网络环境,    
局域网之间再经过专门server提供链接和数据交换服务.   
　　B/S 创建在广域网之上的, 没必要是专门的网络硬件环境,例与电话上网, 租用设备.    
信息本身管理. 有比C/S更强的适应范围, 通常仅仅要有操做系统和浏览器便可   
２）．对安全要求不一样   
　　C/S 通常面向相对固定的用户群, 对信息安全的控制能力很是强.    
通常高度机密的信息系统採用C/S 结构适宜. 可以经过B/S公布部分可公开信息.   
　　B/S 创建在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。   
３）．对程序架构不一样   
　　C/S 程序可以更加注重流程, 可以对权限多层次校验,    
对系统执行速度可以较少考虑.   
　　B/S 对安全以及訪问速度的多重的考虑, 创建在需要更加优化的基础之上.    
比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk    
2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean    
构件技术等,使 B/S更加成熟.   
４）．软件重用不一样   
　　C/S 程序可以不可避免的整体性考虑,    
构件的</ div <>   
  
     
  <DIV class=attachments>   
       
         
        <UL>   
          <LI><A href="http://dl.iteye.com/topics/download/4bb5d3ac-5b81-3821-8979-95a9e6af97e8">打印.rar</A> (98.7 KB)   
          <LI>描写叙述: SSH面试题   
          <LI>下载次数: 4  
        </LI></UL>   
         
       
       
  </DIV>   
  
  
  
  <SCRIPT type=text/javascript><!--   
google_ad_client = "pub-1076724771190722";   
/* JE我的博客468x60 */  
google_ad_slot = "5506163105";   
google_ad_width = 468;   
google_ad_height = 60;   
//-->   
</SCRIPT>   
<SCRIPT type=text/javascript src="http://pagead2.googlesyndication.com/pagead/show_ads.js">   
</SCRIPT><SCRIPT src="http://pagead2.googlesyndication.com/pagead/js/r20110713/r20110719/show_ads_impl.js"></SCRIPT><SCRIPT src="http://googleads.g.doubleclick.net/pagead/test_domain.js"></SCRIPT><SCRIPT src="http://pagead2.googlesyndication.com/pagead/render_ads.js"></SCRIPT><SCRIPT>google_protectAndRun("render_ads.js::google_render_ad", google_handleError, google_render_ad);</SCRIPT><IFRAME id=google_ads_frame1 height=60 marginHeight=0 src="http://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-1076724771190722&output=html&h=60&slotname=5506163105&w=468&lmt=1311752896&ea=0&flash=10.3.181.34&url=http%3A%2F%2Fzhengyunfei.iteye.com%2Fblog%2F1078170&dt=1311752896437&shv=r20110713&jsv=r20110719&saldr=1&correlator=1311752896562&frm=4&adk=2365030428&ga_vid=861167297.1311752897&ga_sid=1311752897&ga_hid=1115300874&ga_fc=0&u_tz=480&u_his=0&u_java=1&u_h=900&u_w=1600&u_ah=876&u_aw=1600&u_cd=32&u_nplug=0&u_nmime=0&biw=1584&bih=726&ref=http%3A%2F%2Fwww.iteye.com%2Fblogs%2Ftag%2F%25E9%259D%25A2%25E8%25AF%2595%3Fpage%3D7&fu=0&ifi=1&dtd=156" frameBorder=0 width=468 allowTransparency name=google_ads_frame1 marginWidth=0 scrolling=no></IFRAME>   
     
  <DIV id=bottoms class=clearfix> <DIV id=digg_bottom class=clearfix><A onclick='digg("blogs", 1078170, false);return false;' href="#"><DIV><STRONG>1</STRONG> <BR>顶</DIV></A><A onclick='digg("blogs", 1078170, true);return false;' href="#"><DIV><STRONG>2</STRONG> <BR>踩</DIV></A></DIV> <DIV id=share_weibo>分享到：<A title=分享到新浪微博 href="javascript:;" data-type="sina"><IMG src="/images/t_sina.gif"></A>   
      <A title=分享到腾讯微博 href="javascript:;" data-type="qq"><IMG src="/images/t_qq.gif"></A>   
    </DIV>   
  </DIV>   
  
  <DIV class=blog_nav>   
    <DIV class=pre_next> <A class=next title=oracle批量更新 href="/blog/1106941">oracle批量更新</A> | <A class=pre title="java 面试题整理2" href="/blog/1072284">java 面试题整理2</A> </DIV>   
  </DIV>   
  <DIV class=blog_bottom>   
    <UL>   
      <LI>23:19  
      </LI><LI><A href="#comments">评论</A> / 浏览 (0 / 166)</LI><LI><A class=favorite onclick="$$('.favorite_form_spinner')[0].show();new Ajax.Request('http://zhengyunfei.iteye.com/links/new_xhr?user_favorite%5Btitle%5D=SSH%E9%9D%A2%E8%AF%95%E9%A2%98%E6%95%B4%E7%90%86&user_favorite%5Burl%5D=http%3A%2F%2Fzhengyunfei.iteye.com%2Fblog%2F1078170', {method: 'get', onSuccess: function(response){$(document.getElementsByTagName('body')[0]).insert({bottom:response.responseText});$$('.favorite_form_spinner')[0].hide();}});return false;" href="http://app.iteye.com/links?

user_favorite%5Btitle%5D=SSH%E9%9D%A2%E8%AF%95%E9%A2%98%E6%95%B4%E7%90%86&user_favorite%5Burl%5D=http%3A%2F%2Fzhengyunfei.iteye.com%2Fblog%2F1078170" target=_blank>收藏</A><IMG style="DISPLAY: none; MARGIN-LEFT: 7px; VERTICAL-ALIGN: bottom" class=favorite_form_spinner alt=Spinner src="http://www.iteye.com/images/spinner.gif?

1308833136"> </LI><LI>分类:<A href="http://www.iteye.com/blogs/category/language">编程语言</A> </LI><LI class=last><A class=more href="http://www.iteye.com/wiki/blog/1078170" target=_blank>相关推荐</A> </LI></UL>      </DIV>         <DIV class=blog_comment> <H5>评论</H5> <A id=comments name=comments></A> </DIV>         <DIV class=blog_comment> <H5>发表评论</H5> <FORM id=comment_form onsubmit="return false;" method=post action=/blog/1078170> <INPUT id=editor_bbcode_flag value=true type=hidden> <DIV id=editor_main><DIV id=editor_wrapper class=clearfix><DIV id=bbcode_emotions><H5>表情图标</H5><IMG src="http://www.iteye.com/images/smiles/icon_biggrin.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_smile.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_sad.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_surprised.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_eek.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_confused.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_cool.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_lol.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_mad.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_razz.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_redface.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_cry.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_evil.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_twisted.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_rolleyes.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_wink.gif" width=19