Part 1

1.      持久化对象

Event event = new Event();

// populate the event

Session session = factory.openSession();

session.save(event);

session.flush();

session.close();

当保存一个对象的时候，hibernate出于性能的考虑不会马上将改对象写到db。如果想要强制写，就要用flush()方法。

经常将save和update合在一起使用，为saveOrUpdate()。Hibernate根据对象的id是null（或0），还是已经存在来判断应该save还是update。

 

 

2.      读取对象

根据id

Event event = (Event) session.load(Event.class, eventId);

session.close();

使用hql

Query query = session.createQuery("from Event");

List events = query.list();

 

 

3.      会话缓存session cache

出于性能的考虑，默认情况hibernate并不将一个操作立即反映到db中，而是做一些缓存的处理。

对一个会话期间的被load或save的每个对象，都能支持一个相应的缓存。

比如可以在一次会话中对对象a做load，update等多个处理，最后才flush提交，如

Session session = factory.openSession();

Event e = (Event) session.load(Event.class, myEventId);

e.setName("New Event Name");

session.saveOrUpdate(e);

// later, with the same Session instance

Event e = (Event) session.load(Event.class, myEventId);

e.setDuration(180);

session.saveOrUpdate(e);

session.flush();

缓存会带来一些问题：

初学者容易犯NonUniqueObjectException，即在一个会话中对同一个对象做了不同步的操作，比如：

Session session = factory.openSession();

Event firstEvent = (Event) session.load(Event.class, myEventId);

// ... perform some operation on firstEvent

Event secondEvent = new Event();

secondEvent.setId(myEventId);

session.save(secondEvent);

可以看到secondEvent是一个与firstEvent同ID的对象，最后却使用save，而不是update，显然不对了。

 

对每个“经过”了会话的对象，都会被加到会话的缓存中。

“经过”的含义：保存对象，读取对象。

session.contains()可以检查某个对象是否在缓存中。

session.evict()可以将对象从缓存中清除。

session.clear()可以将所有对象从缓存清除。

Session session = factory.openSession();

Event firstEvent = (Event) session.load(Event.class, myEventId);

// ... perform some operation on firstEvent

if (session.contains(firstEvent)) {

session.evict(firstEvent);

}

Event secondEvent = new Event();

secondEvent.setId(myEventId);

session.save(secondEvent);

 

 

Part 2

 

1.      连接池connection pools

出于性能的考虑，不能为每一个到数据库的请求，都给一个连接。而是使用连接池。

连接池保存了可以重用的一组到数据库的连接。

应用服务器通常通过JNDI数据源datasource，提供自己的连接池支持，hibernate利用了服务器的这个特性。并且对没有连接池支持的服务器也有相关支持，参见C3P0。

 

 

2.      事务

有的服务器支持简单的JDBC事务，有的则能支持java transaction api（JTA）。

Jdbc和jta是两种事务策略，到底使用哪种策略，可以在hibernate.cfg.xml设置。Jta的好处是可以允许你将多个独立的事务当作一个事务对待。

在Hibernate中，对多个事务的处理是这样的：

Transaction tx0 = session.beginTransaction();

Event event = new Event();

// ... populate the event instance

session.saveOrUpdate(event);

Transaction tx1 = session.beginTransaction();

Location location = new Location();

// ... populate the Location instance

session.saveOrUpdate(location);

tx0.commit();

tx1.commit();

上面，用一个会话创建了两个事务，但是无论哪个事务的操作都会当作是第一个事务的操作来处理。显然，是一个问题。（利用jta？）

<property name="transaction.factory_class">

org.hibernate.transaction.JTATransactionFactory

</property>

<property name="jta.UserTransaction">

java:comp/UserTransaction

</property>

当前，默认是使用jdbc的。

事务的一个示例：

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

Event event = new Event();

// ... populate the Event instance

session.saveOrUpdate(event);

tx.commit();

注意：这里没有使用flush方法来强制将event写入db，因为提交操作commit时会完成写入。

 

Cache提供者provider

未完.........................................

 

 

 

Part 3 HQL

 

1.      Hql具有properties：

Id和class

使用id可以引用对象的primary key，而不论你实际使用的是什么名字，例如：

from MyObject m where m.id > 50

查询所有主健大于50的。

class是对象的完整java名字，如：

from Attendee a join a.payment p where p.class =

com.manning.hq.ch06.CashPayment

class属性在对象树结构中很有用。

 

2.      表达式

hql支持通常的sql表达式，比如：

size：返回子集合中的元素个数

    from Event e where size(e.attendees) > 0

对有序集合：

 

支持的逻辑操作：

and, any, between, exists, in,

like, not, or, and some

支持的比较操作：

=, >, <, >=,

<=, and <>

 

3.      条件查询criteria query

条件查询为查询提供了灵活性。当查询参数的数目不定时，使用。

但是，条件查询不支持聚集函数，并且只能得到这个对象，而不能只得到部分。

即，条件查询没有hql的全部功能，但是提高了灵活性。

两种使用方式：

List results = session.createCriteria(Event.class).

.add( Restrictions.between("duration", new Integer(60),

new Integer(90) )

.add( Restrictions.like("name", "Presen%") )

.addOrder( Order.asc("name") )

.list();

以及：

Criteria criteria = session.createCriteria(Event.class);

criteria.add(Restrictions.between("duration",

new Integer(60), new Integer(90) );

criteria.add( Restrictions.like("name", "Presen%") );

criteria.addOrder( Order.asc("name") );

List results = criteria.list();

 

 

Part 4 利用spring和dao

 

1.      Dao

为了将所有的hql（好处显然：管理），有如下分解，将对象与db见加入一个专门处理持久化的对象dao。

可以为每一个类建立一个dao，可以为一个应用建立一个dao，建议前者。

 

简单dao：

为具体对象承担了如下责任：

每一个操作一个会话；

每一个操作一个事务，并负责打开和关闭事务；

处理异常；

客户代码不必考虑对象cast。

从Dao程序片断体会上面的责任：

public class SimpleEventDao {

Log log = LogFactory.getLog(SimpleEventDao.class);

private Session session;

private Transaction tx;

public SimpleEventDao() {

HibernateFactory.buildIfNeeded();

}

public void delete(Event event)

throws DataAccessLayerException {

try {

startOperation();

session.delete(event);

tx.commit();

} catch (HibernateException e) {

handleException(e);

} finally {

HibernateFactory.close(session);

}

}

...

}

注意：其他真正的功能代码只有一行session.delete(event)，其他代码被称为excise税，消费税。编程时的内存管理是典型的税代码，java帮我们上了税，程序员就用再管了。

 

2.      层次化的dao

其他的CRUD操作都是类似上面的结构，

因此：可以在简单dao中不同的方法里看到结构和内容重复的代码。

所以，需要简化dao，见下：

将公共行为提取到父类。

父类中的delete片断，可以对比前面的delete，区别只在参数一个是具体对象，一个是Object，而对象的cast问题就交给子类dao。

protected void delete(Object obj) {

try {

startOperation();

session.delete(obj);

tx.commit();

} catch (HibernateException e) {

handleException(e);

} finally {

HibernateFactory.close(session);

}

}

 

 

dao还要一些问题：因为每个操作一个会话，一个事务，因此一个按id号更新对象的过程，因为有两个操作find和update，所以使用了两个会话（每个会话又分别使用一事务）来完成，如下：

Event foundEvent = eventDao.find(event.getId());

foundEvent.setDuration(30);

eventDao.update(foundEvent);

但是，从效率上来说，一个会话，一个事务就可以了。

 

 

3.      Spring的HibernateTemplate

Spring对hibernate的支持体现在为hibernate和重要的jdbc需求处理了资源管理税代码resource management excise。

前面谈到dao中有重复代码，重复代码可以通过重构的手段解决，而dao中的重复代码跟资源管理有关，因此Spring引入template来完成所有的资源处理部分，

Spring的HibernateTemplate帮我们完成了如下工作：

获取会话，

开始事务，

处理异常，

显式提交变化到db，

关闭会话。

可以看到，上面的流程就却那个起到功能作用的方法（如CRUD了，因此dao中可以简化为

protected void create(Event event) {

SessionFactory sf = HibernateFactory.getSessionFactory();

HibernateTemplate template = new HibernateTemplate(sf);

template.saveOrUpdate(event);

}

但是可以注意到上面的代码还是使用的一个操作一个事务的模式。

 

 

有两种方式与HibernateTemplate交互：

持久化方法和回调：

使用持久化方法的片断：

SessionFactory sessionFactory =

HibernateFactory.getSessionFactory();

HibernateTemplate template =

new HibernateTemplate(sessionFactory);

Event event1 = new Event();

event1.setName("Event 1");

Event event2 = new Event();

event2.setName("Event 2");

try {

template.save (event1);

template.save (event2);

Event obj = (Event) template.load(Event.class,

event1.getId());

System.out.println("Loaded the event" + obj.getName());

List events = (List) template.find("from Event");

System.out.println("# of Events " + events.size());

} finally {

template.delete(event1);

template.delete(event2);

}

 

不是所有的操作（如非CRUD）都可以简化为事务中的一个query。这时spring提供回调接口，写将在 HibernateTemplate中调用的回调函数。比如，有这样一个操作根据一个复杂查询的结果，更新结果集中的对象的属性，最后保存。这是一个复杂的操作，要前面的CRUD是无法完成的，因此利用HibernateTemplate可以这样做：

template.execute(new HibernateCallback() {

public Object doInHibernate(Session session)

throws HibernateException, SQLException {

Query query = session.createQuery("from Event");

query.setMaxResults(2);

List events = query.list();

for (Iterator it = events.iterator(); it.hasNext();) {

Event event = (Event) it.next();

event.setDuration(60);

}

return null;

}

});

HibernateTemplate的接口就是一个实现doInHibernate方法的

HibernateCallback对象。

Execute方法以HibernateCallback对象为参数，应该还是替客户代码处理了资源处理税代码的。

 

 

4.      Spring对java bean的配置和管理功能

Spring擅长配置和使用简单的java bean。Spring可以做为一个工厂factory来配置和建造bean。

基于上面的功能，spring可以用来配置configure很多已存在的结构和类库，比如hibernate。

 

Spring通过配置文件来管理bean。

配置文件指定了如何创建各种对象，包括Datasource，SessionFactory，所有的dao。

因此，可以从配置文件中：查找dao。

典型的spring配置文件ApplicaitonContext.xml如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC

"-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="dataSource"

class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

<property name="driverClassName">

<value>com.mysql.jdbc.Driver</value>

</property>

<property name="url">

<value>jdbc:mysql://localhost/events_calendar</value>

</property>

<property name="username">

<value>root</value>

</property>

<property name="password">

<value></value>

</property>

</bean>

<bean id="factory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="mappingResources">

<list>

<value>com/manning/hq/ch07/Event.hbm.xml</value>

<value>com/manning/hq/ch07/Location.hbm.xml</value>

</list>

</property>

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">

org.hibernate.dialect.MySQLDialect

</prop>

<prop key="hibernate.show_sql">false</prop>

</props>

</property>

<property name="dataSource">

<ref bean="dataSource"/>

</property>

</bean>

<bean id="eventDao"

class="com.manning.hq.ch07.EventSpringDao">

<property name="sessionFactory">

<ref bean="factory" />

</property>

</bean>

</beans>

如上，来分析spring的配置文件：

1处利用Apache Commons database connection pool (DBCP)定义了使用的数据源，DBCP是在hibernate中集成了的。

2处利用spring内建的LocalSessionFactoryBean创建一个SessionFactory。并在3处连接到数据源。

4处配置dao，并在5处将dao连接到SessionFactory，这让dao能够打开会话，处理查询。

 

Spring的applicationContext.xml可以替代hibernate的

hibernate.cfg.xml。

另外，有点spring比hibernate进步的地方：

对比前面的dao，在dao的构造函数中有这样的代码（来自hibernate quickly，其中HibernateFactory是hibernate quickly自己写的。）

public SimpleEventDao() {

HibernateFactory.buildIfNeeded();

}

dao利用这段代码会调用一个configureSessionFactory方法，根据hibernate的配置文件创建session，如下

private static SessionFactory configureSessionFactory() throws HibernateException {

        Configuration configuration = new Configuration();

        configuration.configure();

        sessionFactory = configuration.buildSessionFactory();

        return sessionFactory;

}

spring中不需要用代码显式创建SessionFactory，只要读

applicationContext.xml，其中有LocalSessionFactoryBean来处理创建

SessionFactory的问题。

 

结合下面的代码和上面SimpleEventDao的构造器

Event event = new Event();

event.setName("A new Event");

EventDao eventDao = new EventDao();

eventDao.create(event);

可以看到：使用dao的步骤是，先创建dao对象，然后dao对象会创建SessionFactory。

Spring中不用显示创建SessionFactory（这是第一点），

ClassPathXmlApplicationContext ctx = new

ClassPathXmlApplicationContext("applicationContext.xml");

EventSpringDao eventDao = (EventSpringDao) ctx.getBean("eventDao",

EventSpringDao.class);

Event event = new Event();

eventDao.saveOrUpdate(event);

注意：applicationContext.xml应该放在classpath里指定的path的root（似乎）。

 

总结一下就是：

在Hibernate中用户代码的责任：

创建dao对象，用new的方式，

dao对象创建SessionFactory对象，供dao中的CRUD操作使用。

而在spring中用户代码的责任：

创建dao对象，用getBean的方式（这似乎是一种create method方法，参见《重构与模式》中6.1《用Creation Method替换构造函数》）。

 

其实，上面提到“spring擅长配置和使用简单的java bean”，所以使用上面代码中的

ClassPathXmlApplicationContext.getBean()方法来完成。

 

 

Spring对层次化的dao的支持：

org.springframework.orm.hibernate3.support.HibernateDaoSupport。

其代码：

public abstract class HibernateDaoSupport

implements InitializingBean {

protected final Log logger;

private HibernateTemplate hibernateTemplate;

public final void

setSessionFactory(SessionFactory sessionFactory);

public final SessionFactory getSessionFactory();

public final void

setHibernateTemplate(HibernateTemplate hibernateTemplate);

public final HibernateTemplate getHibernateTemplate();

protected final Session getSession()

throws DataAccessResourceFailureException,

IllegalStateException;

protected final void closeSessionIfNecessary(Session session);

}

可以看到：HibernateDaoSupport的支持support体现在：

提供logger，以支持日志功能；

管理HibernateTemplate（有一个私有的hibernateTemplate）；

管理SessionFactory（HibernateTemplate从HibernateAccessor继承了SessionFactory）；

上面的代码虽然表明HibernateDaoSupport是抽象类，但是每个方式实际上有实现的（为什么？）。所以，关于 SessionFactory，Session，HibernateTemplate的操作可以直接在客户代码中使用，而不用重载然后实现之。所以从该类继承一个dao的话，可以简化操作，如：

public abstract class AbstractSpringDao

extends HibernateDaoSupport{

public AbstractSpringDao() { }

protected void saveOrUpdate(Object obj) {

getHibernateTemplate().saveOrUpdate(obj);

}

protected void delete(Object obj) {

getHibernateTemplate().delete(obj);

}

protected Object find(Class clazz, Long id) {

return getHibernateTemplate().load(clazz, id);

}

protected List findAll(Class clazz) {

return getHibernateTemplate().find(

"from " + clazz.getName());

}

}

其实，上面的类已经是可以实例化的类了，不必标记为abstract。

上面的dao再被继承为eventDao：一个dao应该有一个对应的session，dao的所有对数据库的操作都要基于这个session 里来完成（考察最初形式的dao可以看到Session类的变量），这个问题在配置文件中指明了一个SessionFactory来创建需要的 Session：

<bean id="eventDao" class="com.manning.hq.ch07.EventSpringDao>

<property name="sessionFactory">

<ref bean="factory" />

</property>

</bean>

 

 

5.      集成spring对hibernate的支持，简化代码

下面用一个类来集成spring对hibernate的支持

public class CalendarRegistry {

private static ApplicationContext ctx;

static {

ctx = new ClassPathXmlApplicationContext(

"applicationContext.xml");

}

private CalendarRegistry() {

}

public static SessionFactory getSessionFactory() {

return (SessionFactory) ctx.getBean(

"factory", SessionFactory.class);

}

public static EventSpringDao getEventDao() {

return (EventSpringDao)ctx.getBean(

"eventDao", EventSpringDao.class);

}

}

客户代码：

EventSpringDao eventDao = CalendarRegistry.getEventDao();

eventDao.saveOrUpdate(event);

评论 (0) All

登陆 还没注册？