Hibernate -- 2

=====================Hibernate面试题==========================

 

1.Hibernate有哪几种查询数据的方式
   a) HQL

   b) 本地sql

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

load加载方法：
Users user = (Users)session.load(Users.class, userId);

get加载方法：
Users user = (Users)session.get(Users.class, userId);

---------------------------------------------------------------------------------------------------
两种加载方法区别：load支持延迟加载，get不支持延迟加载。
举例：
1）
Users user = (Users)session.load(Users.class, userId);
这句代码不会去执行数据库查询，只有用到user时才会去执行数据库查询。
而：
Users user = (Users)session.get(Users.class, userId); 立即去执行数据库查询。
sers user = (Users)session.load(Users.class, userId); 不会执行任何sql。

2）
在数据库中如果没有userId的对象，此时：
如果通过get方法加载，则返回的是一个null；
如果通过load加载，则返回一个代理对象，如果后面代码如果调用user对象的某个属性(比如user.getPassword())会抛出异常：org.hibernate.ObjectNotFoundException；

---------------------------------------------------------------------------------------------------
注意:
Users user = (Users)session.load(Users.class, userId);
System.out.println(user.getId());
如果session中已经加载了User对象，上面这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. 是一个优秀的ORM框架。简化DAO层的编码工作。
2. 映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

------------------------------------------------------------------------------------------------------
                                                     ORM简介：
ORM：
即Ojbect-Relation Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了。

优点：
1.提高了开发效率。由于ORM可以自动对Entity对象与数据库中的Table进行字段与属性的映射，所以我们实际可能已经不需要一个专用的、庞大的数据访问层。 

2.ORM提供了对数据库的映射，不用sql直接编码，能够像操作对象一样从数据库获取数据


示例程序(spring+hibernate代码)：
Model层：
User.java:

package com.bjsxt.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class User {
	private int id;
	private String name;
	
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

 

DAO层：
UserDAO.java:

package com.bjsxt.dao;
import com.bjsxt.model.User;

public interface UserDAO {
	public void save(User user);
}

 SuperDAO.java
 

package com.bjsxt.dao.impl;

import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Component;

@Component
public class SuperDAO extends HibernateDaoSupport {
	@Resource(name="sessionFactory")
	public void setSuperSessionFactory(SessionFactory sessionFactory) {
		super.setSessionFactory(sessionFactory);
	}
	
	
}

 

UserDAOImpl.java

package com.bjsxt.dao.impl;

import javax.annotation.Resource;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;

@Component("u") 
public class UserDAOImpl extends SuperDAO implements UserDAO {
	public void save(User user) {
		this.getHibernateTemplate().save(user);
			
	}

}

  
Service层：
  

package com.bjsxt.service;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.bjsxt.dao.LogDAO;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.Log;
import com.bjsxt.model.User;

@Component("userService")
public class UserService {
	
	private UserDAO userDAO;
	//private LogDAO logDAO;
	
	public void init() {
		System.out.println("init");
	}
	
	public User getUser(int id) {
		return null;
	}
	
	//@Transactional(readOnly=true)
	public void add(User user) {
			userDAO.save(user);
		//	Log log = new Log();
		//	log.setMsg("a user saved!");
		//	logDAO.save(log);
		
	}
	public UserDAO getUserDAO() {
		return userDAO;
	}
	
	@Resource(name="u")
	public void setUserDAO( UserDAO userDAO) {
		this.userDAO = userDAO;
	}
	
	/*
	public LogDAO getLogDAO() {
		return logDAO;
	}
	
	@Resource
	public void setLogDAO(LogDAO logDAO) {
		this.logDAO = logDAO;
	}

	public void destroy() {
		System.out.println("destroy");
	}*/
}

 
beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<context:annotation-config />
	<context:component-scan base-package="com.bjsxt" />

	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<value>classpath:jdbc.properties</value>
		</property>
	</bean>

	<bean id="dataSource" destroy-method="close"
		class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName"
			value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		 <property name="packagesToScan">
			<list>
				<value>com.bjsxt.model</value>
				
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
			</props>
		</property>
	</bean>

</beans>

 
jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=bjsxt

 


缺点：
ORM的缺点是会牺牲程序的执行效率，
从系统结构上来看,采用ORM的系统一般都是多层系统，系统的层次多了，效率就会降低。ORM是一种完全的面向对象的做法，而面向对象的做法也会对性能产生一定的影响。


参考：http://tech.it168.com/KnowledgeBase/Articles/8/c/8/8c8fec1557bc365a090cebae4f3b2458.htm

 

5.Hibernate是如何延迟加载?

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

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

    类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类 都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many

7.说下Hibernate的缓存机制

 

8.Hibernate的查询方式

Sql、Criteria,object comptosition
Hql：
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数

 

9.如何优化Hibernate的性能？ 
   1）及即时清除session中不使用的对象
   2）缓存机制，二级缓存，查询缓存

10.在数据库中条件查询速度很慢的时候,如何优化?

    1. 建索引
    2. 优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面
      优化sql方面可以参考oracle的那篇sql优化的文章
    3. 减少表之间的关联    
    5. 简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据
　

11.在Hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?




　　

 

12.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方法。
　　返回数据对象。

 

15. Hibernate的主键生成机制

 

=====================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)<set> B)<one-to-many> C)<many-to-one> D)<property>

(4)<set>元素有一个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