Hibernate-面试题

1、在myeclipse加入hibernate环境的全过程是什么?

Db-browers加入配置连接

新建工程

加入hibernate环境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置

2、hibernate的核心配置文件是什么及其作用?

Hibernate.cfg.xml:数据库连接、指定相关的映射文件

    *.hbm.xml:具体的o/r mapping说明

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

Configuration

SessionFactory

        Session如下方法

            Save

            load

            Update

            Delete

            Query q=CreateQuery(“from Customer where customerName=:customerName”)

            beginTransaction

            close

            Transaction

            Commit()       

4、关联:

    one-to-many

    inverse:主控方，外键的关系有谁控制

        inverse=false 是主控方，外键是由它控制的           

        inverse=true 是被控方，外键与它没关系

        要想实现主控方的控制必须将被控方作为主控方的属性

    cascade:级联

        主表增从表增

        主表修从表修

        主表删从表删

    lazy:延迟

    lazy=false：一下将所有的内容取出，不延时(常用)

        lazy=true：取出部分内容，其余内容动态去取

        通过get可以取出对方的所有内容     

5、hibernate中的one-to-many或many-to-one中常用的方式是什么?

主控方在many这边，不及连删除

6、Criteria 的作用?

    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行

7、DetachedCriteria的作用？

产生时不需要session

    DetachedCriteria dc= DetachedCriteria.forClass(Customer.class)

    Criteria c=Dc.getExecutableCriteria(session)

8、Query

1 个或多个属性查询:

    Query query=session.createQuery(”select customername,customerid from Customer”)

    List l=query.list();

    For(int i=0;i<l.size();i++)

{

    Obejct[] object=(Object[])l.get(i);

    Object[0]  object[1]

}

}

分组: "select count(*),productname from Product group by productname order by productname"

取值与属性一样

配置的查询,在*.hbm.xml中

    <query name="sql">

    <![CDATA[

        from Product where productid=:productid

    ]]>

</query>

    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"

9、继承关系的实现

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

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

          <class name="Users" table="users" discriminator-value="Users">

            <discriminator column="DISCRIMINATOR_USERTYPE" type="string"/>

<subclass name="admin" discriminator-value="admin">

                    <property name="adminRemark" column="admin_remark" type="string" />

              </subclass>

          </class>

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

    <class name="Users" table="users">

        <id name="userid" column="USERID" type="string">

            <generator class="assigned"/>

        </id>

        <property name="pwd" column="pwd" type="string" />

        <joined-subclass name="Guest" table="guest">

            <key column="USERID"/>

            <property name="guestRemark" column="guest_remark" type="string" />

        </joined-subclass>

</class>

批量删除

    Query query=session.createQuery("update"或"delete");

    query.executeUpdate();

 

10、tomcat连接池:在容器中预先产生了n个连接实例,客户端不用重新实例化，可以直接取。

    6.1、在tomcat-5.0\conf\server.xml中</host>前面加入如下内容

    <Context path="/app1" docBase="app1" debug="0"    reloadable="true" crossContext="true">  

    <Resource name="jdbc/sa" auth="Container" type="javax.sql.DataSource"/>  

              <ResourceParams name="jdbc/sa">  

            <parameter>    

                <name>factory</name>       

    <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>      

            </parameter>             

        <parameter>    

                        <name>driverClassName</name>       

                <value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>    

            </parameter>           

        <parameter>

                <name>url</name>       

                  <value>jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=jspdev;SelectMethod=cursor</value>  

        </parameter>       

            <parameter>            

            <name>username</name>      

                    <value>sa</value>            

        </parameter>       

            <parameter>            

            <name>password</name>              

            <value></value>

            </parameter>       

            <parameter>            

            <name>maxActive</name>             

                <value>20</value>            

        </parameter>

            <parameter>    

                <name>maxIdle</name>               

            <value>10</value>            

        </parameter>             

        <parameter>

                <name>maxWait</name>               

            <value>-1</value>            

        </parameter>       

            </ResourceParams>    

</Context>

    6.2、将sql-server包拷贝到C:\tomcat-5\common\lib

    6.3、jdbc测试代码

        Context initCtx = new InitialContext();

        Context envCtx = (Context)initCtx.lookup("java:comp/env");

        ds = (DataSource)envCtx.lookup("jdbc/sa");

        Connection conn = ds.getConnection();

    6.4、hibernate通过连接池实现连接

        <session-factory name="foo">

            <property name="connection.datasource">java:comp/env/jdbc/sa</property>  <!--指定tomcat连接池-->

            <property name="show_sql">true</property> <!--是否显示sql-->

            <property name="dialect">org.hibernate.dialect.SQLServerDialect</property> <!--hibernate的驱动管理器-->

            <mapping resource="com/accp/t15/Customer.hbm.xml"/>

        </session-factory>

 

11、对象的三大状态

    自由(transient)

        与session无关

    持久(persistent)

        由session来管理

        在持久状态中通过get方法取出对方

    游离(detached)

        被session抛弃 

12、hibernate常见优化策略

    用最新版本的hibernate

    制定合理的缓存策略

    采用合理的session管理机制

    尽量使用延迟加载

        many

        大文本、大文件

    设定合理的批处理参数(batch-size)

    如有可能，选用uuid作为主键生成器

    如有可能，选用基于version的乐观锁替代悲观锁

    开发过程中，打开hibernate的SQl日志输出(hibernate.show_sql=true)，通过观察hibernate生成的sql语句进一步了解其实现原理，从而指事实上更好的实现策略。