hibernate题库

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

 工作原理：

1. 读取并解析配置文件

2. 读取并解析映射信息，创建SessionFactory

3. 打开Sesssion

4. 创建事务Transation

5. 持久化操作

6. 提交事务

7. 关闭Session

8. 关闭SesstionFactory

 

  为什么要用：

       * 简化JDBC操作，因为JDBC方式对数据库的操作方法过于冗余，而Hibernate进行了很好的封装。

       * Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。可以很大程度上简化DAO层的编码工作。

       * hibernate支持各种关系数据库，从一对一到多对多的各种复杂关系。

       * hibernate采用Java反射机制，而不是字节码可以增强程序的透明性。

 

 

2.Hibernate是如何实现延迟加载的?

* Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

* Hibernate3提供了属性延迟加载的功能，也就是当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

 

 

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

解：类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，Hibernate中，将类与表对应，将类中的属性和表中的字段对应，记录对应于对象；反应到程序主要是通过表于类的映射xml文件管理的，一对多的关系反应为：many-to-one、one-to-many、多对多：many-to-many、

 

4.说下Hibernate的缓存机制

  解答：Hibernate提供了一级缓存和二级缓存；而所谓的一级缓存实质就是Session缓存，此缓存的生命周期是伴随着Session的销毁而销毁的，而Session在进行数据库的操作之后，肯定是要关闭的，此缓存也就随之消失，因此很少使用。二级缓存实质SessionFactory缓存，SessionFactory是Hibernate的核心类，此类实例对象用于储存数据源，且不是随意创建的，一般为单例模式，因此有用。二级缓存在Hibernate中默认是关闭的，防止给服务器增加压力，需要手工启动并进行相关设置：二级缓存的配置方法如下：

  1.首先需要在Hibernate的核心配置文件的位于hibernate.format_sql 的同级位置处，加上如下的相关属性

     hibernate_provide_class   值为 org.hibernate.cache.EhcacheProvider 

     use_second_leve   值为 true

     use_query    值为true

  2.为需要二级缓存的对象打开缓存策略，因为并是所有的对象都要去采用二级缓存的，则样会给服务器带来过去的压力，所以需要有争对的性对对象增加二级缓存，在对象的xml文件中加上<cache usage="" />

   usage中的值即缓存策略有：

   （1）read-only: 只读策略，这也使用最多最有效的方式，即对不常的修改的对象采用此种缓存策略。

   优点在于：性能最高，缺点：不灵活，只能读，不能写

   （2）read-write:可读写策略，这种即对数据即可以读，也可以写。优点：在于灵活性高  缺点：性能低

   （3）nostrict-read-write策略：此种是一种对数据修改以后，不会立即进行跟新，而会有延迟，这种经常使用于新闻的显示，优点在于：性能得到提高，缺点在于：准确性不高

   （4）transaction策略：事务策略，现在已经没有使用了被前面的替换了。

   3.初上述配置以外，还需要支持文件，而二级缓存有两种一种是ehcache  第二种是oscache 一般使用第一种，在src文件下填入相应的配置xml可以从hibernate的etc下找到。

   （5）支持文件加入以后，还需要在支持的HQL语句中，启动二级缓存即：query.setCacheable(true)

 

 

5.Hibernate的查询方式

  (1)Session查询：按主键查询方式，如get(),load()

  (2)Query查询：即hql语句查询

 （3）Cretria查询：通过程序来拼凑查询条件。

 

6.如何优化Hibernate？

  （1）采用缓存机制

  （2）采用load()方法代替get()方法，因为load()支持二级缓存，get（）不支持

  （3）采用sql语句查询，因为Hibernate支持Sql语句

  （4）关联查询方式的fetch采用select，不用join即采用分别查询方式

  （5）不采用一对一，而采用多对一

7.Struts工作机制？为什么要使用Struts？

  工作机制：

  Struts的工作原理为：*.jsp页面提交到*.do的时候加载web.xml，而web.xml中会初始化ActionServlet,ActionServlet会加载Struts的核心配置文件struts-config.xml，而此核心配置文件会反射生成ActionForm,和Action,首先会进行ActionForm，ActionForm负责参数的接收和验证操作，验证的方法名为validate(),validate()的返回类型为ActionErrors，错误的添加是通过ActionMessage，存放在struts.properties下，在validate验证通过后，会进行Action中execute()，在Action中主要负责逻辑判断和调用数据库操作，以及路径的跳转，采用方法的为mapping.findForward；返回错误采用的是mapping.getInputForward.跳转的路径配置在核心配置文件中<forward name="" path="" />;如果actionForm没有验证通过返回的是错误页，错误页的路径在核心配置文件中的errror="".

  为什么要用：

  首先要弄懂什么是框架，因为Struts是一个框架，而框架就是方便使用的一种结构，有了这种结构，只要使用者遵循使用规则，就可以达到代码的统一和规范，而Struts也基于这种目的，此外，Struts是MVC是模式的很好体现，虽然不采用Struts，采用jsp+servlet+javabean也可以的很好的完成企业开发，但在Servlet过于冗余，并且很杂乱，所以采用Struts比较合理。

8.基于Struts开发的应用是由3类组件构成的？

  因为Struts采用是MVC的体现，所以三类组件为：M（模型组件）  V（视图组件）  C（控制器组件）

 

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

  1.首先在struts.properties中配置具体的错误提示，

  2.然后在ActionForam对象的FormBean中执行validate()方法的调用。

这道题如果是Struts2.1？的话，怎么回答呢？

 

10.单例模式

   单例设计模式的特点在于：

   （1）类的构造方法被私有化

   （2）类外操作的时候，直接通过类名称调用static的静态方法来获取实例对象

   （3）无论在类外创建了多个实例对象，实质只有类中的这一个实例化对象。

   程序：

   class Singleton{

       private static final Singleton INSTANCE = new Singleton();

       private Singleton(){}

 

       public static Singleton getInstance(){

return INSTANCE();

       }

 

       public void print(){

System.out.println("hello world");

       }

   }

 

   public class Test{

public static void main(String args[]){

Singleton.getInstance().print();

       }

   }

 

 

11.Factory(工厂模式)：

   工厂设计模式的特点在于：解决耦合性过于精密的问题，即创建一个工厂专门用于生成主类所需的实例对象

   程序：

   interface Fruit{

      public void eat();

   }

   class Orange implements Fruit{

public void eat(){

System.out.println("吃橘子");

}

   }

 

   class Apple implements Fruit{

public void eat(){

System.out.println("吃苹果");

}

   }

 

   class Factory{

   

public static Fruit getInstance(String f){

if("o".equals(f)){

return new Orange();

}else if("a".equals(f)){

return new Apple();

}

return null;

}

   }

 

   public class Test{

public static void main(String args[]){

        if(args.length != 1){

             System.out.println("请输入一个字母");

     System.exit(1);

}

Factory.getInstance(args[0]).eat();

}

   }

 

 

12.Proxy(代理模式)

   代理设计模式的特点：代理主体和真实主体的目的一样的,只是真实主题无法自己一个人完成，需要代理主体来帮助完成，代理主体需要做准备和收尾的工作，具体的内容还是真实主题的。

   程序：

   interface Subject(){

public void fly();

   }

   calss RealSubject() implements Subject{

public void fly(){

System.out.println("飞向北京");

}

   }

   class ProxySubject() implements Subject{

private Subject sub;

 

public ProxySubject(Subject s){

this.sub = s;

}

 

public void prepare(){

System.out.println("请买票");

}

 

public void exit(){

System.out.println("请下机");

}

        

 

public void fly(){

this.prepare();

this.sub.fly();

this.exit();

}

   } 

   public class Test{

public static void main(String args[]){

Subject sub =  new ProxySubject(new RealSubject());

sub.fly();

}

   }

 

 

 

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

   Spring工作原理：

   1.springmvc请所有的请求都提交到DispatherServlet中，它委托应用系统的其它模块待负责完成这些请求操作。

   2.DispathcerServlet去查询一个或多个HanderMapping,通过HanderMapping找到处理请求的Controller.

   3.DispathcerServlet将所有的请求提交到目标Controller中

   4.Controller在处理完逻辑业务以后，会返回一个ModelAndView.

   5.DispatcherServlet会去查询一个或多个ViewResolver视图解析器，通过视图解析器找到ModelAndView对象的对应的视图对象

   6.通过视图对象渲染后返回客户端。

   为什么要用：

   1.同样的道理，Spring也是一个框架，而框架能够带来统一的规范和可维护性。

   2.体现在Spring的两个主要功能及：IOC和AOP

   IOC：控制反转，是用于创建对象的，即通过一个配置文件，配置文件中描述了类的属性和属性对应的值，通过反射的方法加载配置文件创建对象，而通过这个IOC方式创建的对象，会自动把属性对应的属性值带上，而属性除了基本数据类型外，也可以是引用数据类型，所以IOC也叫做依赖注入。在实际开发中主要可以用Spring来替换工厂类。

   AOP：面向切面的编程，在Spring中Aop,主要体现在动态的代理设计；即将一系列相同的代理操作都封装到一个代理规则类中，在调用真实类的时候，都先经过这个规则类进行之前和之后的处理和收尾操作。实际开发中可以用来简化ServicImpl的代码。

   3、Spring可以很好的进行分层架构，即对你需要的层进行架构，而不需要的层可以不关心。

   4.Spring可以很好的控制组件的解耦合。

 

 

14.Spring中实现DI（Dependency Injection）的几种方式。

    有三种：1.接口，2.setter getter 方法  3.构造方法注入，通常采用setter getter 方法注入

 

15.Spring的Bean有多种作用域，包括哪些？

     有：singleton、prototype、request、session、global session、application、自定义

 

16.简单描述Spring Framework与Struts Framework的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？

    Spring 框架 和Struts 框架的不用之处在于：

    1.Spring框架不能单独使用，Struts框架可以单独使用

2.Spring框架主要功能是AOP和IOC，Struts框架的主要功能是替换Servlet的。

3.Spring主要用来是解耦合的，Struts主要用来管理统一提交的路径的。

    Spring和Struts的整合可以通过在web.xml中加入<plug-in></plug-in>插件和<controler>控制的方法来让spring创建Struts的Action.其它的方法，暂时没用过。

 

17.Hibernate中的update()和saveOrUpdate()的区别？

   Hibernate中的update（）和savaOrUpdate()都可以用来修改某个对象，但是saveOrUpdate的特殊在于，当某个对象是不存在的情况会创建这个对象，update（）,没有这个功能。

 

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

   解析：主要体现在Hibernate将一些对象交给了Spring来管理和创建，如数据库连接类，通过Spring来管理创建，另外像SeesionFactory类也是由Spring来实现，在DAO的实现类上，继承了HibernateDAOSupport,在类中主要的核心对象，super.getHibernateTemplate()也由Spring完成，另外Hibernate的事务配置，也可以由Spring来进行相依的事务处理。

 

19.在hibernate中进行多表查询,每个表中各取几个字段,那么查询出来的结果集不是一个实体类与之对应,如何解决这个问题?

解决方案一，按照Object[]数据取出数据，然后采用set,get方法自己组件bean。

解决方案二，改POJO，创建先的构造函数，与你的查询字段进行对应，这样也可以做到使之返回一个实体类的结果集，但一般采用第一种解决方案都。

 

 

20.session.load()和session.get()的区别

  （1）都Session的主键查询方式

  （2）load在查询的时候，如果没有查找到数据，将会报异常，而get()在没有查询到数据的时候将会返null

   (3)load()采用的是懒汉式，get()采用的是恶汉式；因此get()方法会一次性查询出你所有关联的数据，也就是会多次执行SELECT语句，而load（）是懒汉式的，当你用到的时候才会去查询数据。

  （4）load（）支持二级缓存，get()不支持二级缓存，因此如果缓存中有load（）方法要查询的数据的时候，可能会直接从缓存中取出来，而一次都可不能去执行select语句。get()方法采用的是一级缓存。

 

 

下面的了解即可：{

   首先，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方法。返回数据对象。

 

 

 

}

 

21.Hibernate的主键生成机制

1) assigned 手工生成主键。

2）native  自动生成主键，使用Mysql类似数据库

3）sequence 自动生成主键，使用于Oracle类似数据库

4）increment  程序生成主键， 使用于任何数据库

5）uuid.hex   随机生成32位16进制的主键。

 

 

 

 

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

   解答：hibernate的核心类，主要集中才如何创建数据库连接的，已经操作数据的方法中。回忆HibenateSessionFactory的创建过程和数据库操作的方法既可以解答：

   常用的核心类：Session SessionFactory  Configuration 

   new Configuration().configure().bulidSessionFactory() 可以创建出SessionFactory实例对象

   SessionFactory的实例对象调用openSession()方法可以打开Session的一个实例

   常用方法：save()  update()  delete()   createQuery()  createSqlQuery() query.setXXXX query.getXXX() query.executeUpdate()  query.executeQuery()  query.list(); 

   session.beginTransaction().commit();

   session.beginTransaction().rollback();

   session.close()

这道题，可以采用另外一道题的答法，即简要介绍Hibernate？的答案

 

 

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

   解答：Hibernate数据表映射关系指的就是类与表之间关联的那个xml文件，叫做数据表映射关系xml文件。

     其中主要的类型有：

     <id></id>  指的是主键  <key></key> 指的是外键

     <property></property>普通属性

     <one-to-many> <many-to-one>  <many-to-many>  <set></set>

24.inverse,cascade,lazy 都是什么含义，取值有哪些？

    inverse：（true）表示关系由对方维护，在一对多中，关系应该有多的一方维护，在多对多中，是指中间表由随维护，这个要根据业务来判断，如果多对多中双方都没有设置inverse，则有两方维护，那么会产生问题，即任何一方的操作，都会让中间表增加数据，这样数据会重复，应该由一方来维护，看业务。

    

    例如：

    {

       如果Student这边inverse=”true”, 那么关系由另一端Teacher维护，就是说当插入Student时，不会操作TeacherStudent表（中间表）。只有Teacher插入或删除时才会触发对中间表的操作。所以两边都inverse=”true”是不对的，会导致任何操作都不触发对中间表的影响；当两边都inverse=”false” 或默认时，会导致在中间表中插入两次关系。

    

    }

    cascade:级联操作，表示两个对象之间的操作关联关系，即一个对象的操作同时会影响到另一个对象。其取值有四种：

    all:无论什么情况，两则都关联

    none:无论什么情况，两则都不关联

    delete:在删除操作的情况下，两种进行关联

    sava-update:在保存和修改的情况下，两则进行关联。

    lazy:延迟，也称为懒汉。

lazy=false：不懒汉，一下将所有的内容取出，不延时(常用)，如get()方法

lazy=true：懒汉，需要的时候才取出内容，如果load()方法，可能会带来懒汉式异常。

 

25.Hibernate中Criteria和DetachedCriteria的作用是什么？

   Criteria和DispatchedCriteria 两则都是通过程序拼凑查询条件，不需要写sql和hql语句。

   区别在于：前者的创建需要Session,Criteria c=session.createCriteria(Customer.class);

             后则的创建不需要Session,DetachedCriteria dc= DetachedCriteria.forClass(Customer.class)

 

 

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

  解答：

1、两个表，子类重复父类的属性。

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

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

 

27.Hibernate如何批量删除？

   Hibernate中的Session删除是采用按主键的方式删除的，即先查找主键，在删除。要批量删除则需要利用

   Query中的hql语句删除即：

hql = ""

Query query=session.createQuery(hql);

       query.executeUpdate();

 

 

 

 

28.jdbc、Hibernate、ibatis的区别

   解答：jdbc 是手动的，需要手写sql语句； 优点在于：简单易学，性能高 ； 缺点在于：在操作数据的方法中setXXX,getXXX过于冗余，查询返回的结果集ResultSet，需要循环后一个一个的get  set 麻烦

         ibatis是半自动，也需要写sql语句，优点在于：比JDBC简单，比Hibernate性能高  缺点在于：比      JDBC的性能低，比hibernate麻烦。可以直接传对象操作

         hibernate是全自动，不需要自己sql语句，优点在于：比jdbc,ibatis都简单，缺点在于：性能较低。可以直接传对象。 

 所以对DAO的操作有三种方法，取哪种看公司决定，各有自己的优缺点。

 要想好性能则选择JDBC模式，要想快速开发，则使用Hibernate模式，折中则采用ibatis方式。

 当然，各种模式中可以尽可能的去优化。如果hibernate如何优化性能，前面已经讲了。

 

29.Hibernate的三种状态？

  瞬时态，持久态，游离态

  瞬时态：即在数据库没有这条数据，即没有被任何Sesion操作过，如：new 出来的一个实例就是瞬时态

  持久态：即在数据中有这条数据，并且正在被某个Session操作，如：session.save()

  游离态：即在数据中有这条数据，曾经被Session操作过，如：session.close()

  三则之间的转换；

  瞬时 --》 持久  可以通过save()

  持久 --》 瞬时  可以通过delet（）

  持久 --》 游离   可以通过session.close()

  游离 --》 持久  可以通过update（）

 

  另外：

  持久态具有的特性：

   1.支持一级缓存，即如果某个对象，在之前被查询过，那么将会放到Session缓存中，下次在查询次对象的时候不需要在去SQL语句查询，直接可以通过缓存中查到。

   2.支持级联，即对某个对象可以级联同时操作

  游离态具有的特性：

    1.本质上和瞬时态一直，当没有任何变量引用的时候，会垃圾回收

    2.区别瞬时态在于其再数据中有数据库记录标志。

 

 

 

30.Hibernate里面sorted collection和ordered collection有什么区别

sorted collection是在内存中通过java比较器进行排序的

ordered collection是在数据库中通过order by进行排序的

 

 

31.Hibernate都支持哪些缓存策略？

  1.Read-only: 这种策略适用于那些频繁读取却不会更新的数据，这是目前为止最简单和最有效的缓存策略。

  2.Read/write:这种策略适用于需要被更新的数据，性能低。

  3.Nonstrict read/write: 这种策略适用于那些经常读取但是极少更新的数据

  4.Transactional: 这种策略是完全事务化得缓存策略

 

 

32.如何查看Hibernate生成并执行的sql

   解答：在hibernate的核心配置文件hibernate.cfg.xml里面加入property属性分别是：

         hibernate.show_sql  设置为true

         hibernate.format_sql 为true

         这样生成的SQL就会在控制台出现了，但是：这样做会加重系统的负担，不利于性能调优。

 

33.比较Hibernate的三种检索策略优缺点

解答：

1.立即检索：（get方式）

 优点：对应用程序完全透明化，不论对象是持久态还有游离态，一次性都查出来如同get()方法一样，这样方便从一个对象导航到其关联的对象。

  缺点：（1）过多的select语句查询，性能降低 ；（2）应用程序在加载的时候可能会加载到不需要的对象，而造成内存空间的浪费。

2.延迟检索:(load方式)

 优点：由应用程序自己去加载所需要的对象，这样可以减少select语句查询，也可以不造成内存空间的浪费，提供检索性能，减少压力。

 缺点：当需要查询游离态的代理类实例的时候，需要确定其持久态已经初始化了。

 这里也就说明了一个get与load的另一个区别；

 即load可以查询到游离态的代理类实例，而get查询到的永远是实体类实例。

3.迫切左外连接检索

  优点：对应用程序完全透明化，不论对象是持久态还有游离态，一次性都查出来如同get()方法一样，这样方便从一个对象导航到其关联的对象，并且采用了关联查询，所以可以减少select语句

  缺点：采用了关联查询，如果关系表复杂将会降低检索性能，（2） 应用程序在加载的时候可能会加载到不需要的对象，而造成内存空间的浪费。

 

 

额外知识点：

对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成机制。

 

 

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

解答：

Hibernate的并发机制可以从两个方面去看：

   1.Hibernate的Seesion对象是非线程安全的，对单请求，单会话，单工作单元而言都是使用一次后就丢弃的，那如果Hibernate的Session 进行共享，那么就可以产生并发，即Http Session 中 包含Hibernate的Session(因为你共享了)，那么就可以共享一个HttpSession，只要用户点击刷新速度够快即可看到线程并发访问同一个Session。

   2.多个事务去访问同一个资源，这也是并发，但这样会造成资源的错乱。

   因此要解决并发带来的问题：因为是多个事务访问同一个资源带来的问题，因此从两方面着手，

   一是从事务方面：设置事务隔离级别，事务隔离级别有： 注意是有数据库系统来实现的事务隔离级别

       Sequence :串行化  最高

       Repeatedable Read: 可重复读  

       Read commited : 已经提交的读

       read  uncommited : 未提交的读 最低

    二是从资源方面：加锁

       乐观锁  和 悲观锁

        乐观锁的并发性能优于 悲观锁

 

 

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

   （1）Session 

    (2) HQL

    (4)导航对象图查询

    （5）OID

（6）QBC

 

 

=====================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

 

 

 

 

36.strust的Action是不是线程安全的？如果不是有什么方式可以保证Action的线程安全？如果是，说明原因

   解答：不是线程安全的，只要不申明类变量就可以保证线程安全。因为只存在一个Action类实例，所有线程会共享类变量。

Struts中的action是单实例的，所以都会共享这个action。

 

 

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

   Struts中的关键对象有：

      ActionFrom  ActionMessage  ActionErrors  Action  ActionMapping

    ActionForm :是负责接送参数，验证功能的

    ActionMessage:是负责将错误提示信息添加如Struts.properties中

    ActionErrors: 是错误的集合

    Action：是负责逻辑判读和数据库调用的

    ActionMapping :是负责路径跳转的

 

38. Struts优点与缺点：

  优点：

  1.Struts是一个框架，框架就是方便使用的一个结构，可以带来规范和统一。

  2.Struts的标签库（html,logic.bean,template），可以大大节约开发时间。比如回填功能。

  缺点：标签过多，初学难以记忆。

 

39. Struts提供了几个标签库？都是什么标签库？

Struts提供了四大标签库，即：HTML、Bean、Logic、Template

HTML 标签 ：和常用html标签功能差不多，用于表单。

Bean 标签 ：用于国际化程序和数据，日期的格式化输出

Logic标签 ：用于循环输出对象等信息

Template 标签： 模板标签，用于页面模板。

 

40.Tiles框架是什么？

Tiles框架为创建Web页面提供了一种模板机制，它能将网页的布局和内容分离。

 

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

答：MVC是Model－View－Controller的简写。

“Model”代表的模型层，用来对数据的持久化操作，技术有JDBC,hibernate，ibatis

“View” 代表展示层，用来客户端页面的显示，可以通过JSP来实现，

 “Controller”，代表控制层，用来连接模型层和展示层，中间控制，可以通过Servlet来实现。

 

 

42、应用服务器具体包括那些？

答：应用服务器具体包括：WebLogic 、JBoss 、Tomcat等。