Hibernate参考文档：3.1.1版入门指南

需积分: 10 100 浏览量更新于2024-07-30 收藏 999KB PDF 举报

"hibernate-reference-3.1.1.pdf" 《Hibernate参考文档》是针对Hibernate框架的一个详细指南，版本为3.1.1。该文档涵盖了从基础到高级的各种主题，帮助开发者深入理解并有效地使用Hibernate进行对象关系映射（ORM）。 1. **介绍** - Hibernate是一个开源的Java库，它简化了数据库操作，通过提供对象持久化服务，将数据模型转换为数据库中的记录。 - 部分1展示了第一个Hibernate应用的构建过程，包括创建类、定义映射文件、配置Hibernate、使用Ant构建项目、启动与辅助类的使用以及加载和存储对象的操作。 2. **映射关联** - 部分2详细讲解了如何映射不同类型的关联，如单向Set关联、双向关联，以及值集合和双向链接的工作原理。这部分帮助开发者理解和处理实体之间的复杂关系。 3. **EventManager Web应用程序** - 部分3介绍了EventManager，这是一个基于Hibernate的Web应用程序示例。这里展示了编写基础Servlet、处理和渲染请求以及部署和测试应用的基本步骤。 4. **架构** - Hibernate的架构概述，包括实例状态（瞬时、持久、托管），JMX集成，JCA支持以及上下文会话的概念。这些内容有助于理解Hibernate如何在底层工作。 5. **配置** - Hibernate的配置部分详述了如何程序化地配置Hibernate，如何获取SessionFactory，以及JDBC连接的管理。此外，还提到了一些可选的配置属性，如SQL方言，这些都对优化数据库交互至关重要。 6. **JDBC连接** - Hibernate如何管理和使用JDBC连接进行了阐述，包括连接池的设置和管理，这对于高并发的应用性能至关重要。 7. **SQL方言** - Hibernate支持多种SQL方言，使得框架可以适应各种数据库系统。这部分介绍如何配置和使用特定数据库的方言，以确保SQL语句正确执行。《Hibernate参考文档3.1.1版》为开发者提供了全面的指导，从开始使用Hibernate到最后的高级特性，旨在帮助开发者熟练掌握这一强大的ORM工具，有效提升Java应用的数据库操作效率。

to have more verbose output. By default, only Hibernate startup message are shown on stdout.

The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate.

1.2.6. Loading and storing objects

Finally, we can use Hibernate to load and store objects. We write an EventManager class with a main() meth-

od:

package events;

import org.hibernate.Session;

import java.util.Date;

import util.HibernateUtil;

public class EventManager {

public static void main(String[] args) {

EventManager mgr = new EventManager();

if (args[0].equals("store")) {

mgr.createAndStoreEvent("My Event", new Date());

}

HibernateUtil.getSessionFactory().close();

}

private void createAndStoreEvent(String title, Date theDate) {

Session session = HibernateUtil.getSessionFactory().getCurrentSession();

session.beginTransaction();

Event theEvent = new Event();

theEvent.setTitle(title);

theEvent.setDate(theDate);

session.save(theEvent);

session.getTransaction().commit();

}

We create a new Event object, and hand it over to Hibernate. Hibernate now takes care of the SQL and ex-

ecutes INSERTs on the database. Let's have a look at the Session and Transaction-handling code before we run

this.

A Session is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity

between a Hibernate Session and a database transaction. To shield our code from the actual underlying transac-

tion system (in this case plain JDBC, but it could also run with JTA) we use the Transaction API that is avail-

able on the Hibernate Session.

What does sessionFactory.getCurrentSession() do? First, you can call it as many times and anywhere you

like, once you get hold of your SessionFactory (easy thanks to HibernateUtil). The getCurrentSession()

method always returns the "current" unit of work. Remember that we switched the configuration option for this

mechanism to "thread" in hibernate.cfg.xml? Hence, the scope of the current unit of work is the current Java

thread that executes our application. However, this is not the full truth. A Session begins when it is first

needed, when the first call to getCurrentSession() is made. It is then bound by Hibernate to the current

thread. When the transaction ends, either committed or rolled back, Hibernate also unbinds the Session from

the thread and closes it for you. If you call getCurrentSession() again, you get a new Session and can start a

Introduction to Hibernate

Hibernate 3.1.1 8

new unit of work. This thread-bound programming model is the most popular way of using Hibernate.

Have a look at Chapter 11, Transactions And Concurrency for more information about transaction handling and

demarcation. We also skipped any error handling and rollback in the previous example.

To run this first routine we have to add a callable target to the Ant build file:

</java>

</target>

The value of the action argument is set on the command line when calling the target:

C:\hibernateTutorial\>ant run -Daction=store

You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log out-

put. At the end you will find the following line:

[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)

This is the INSERT executed by Hibernate, the question marks represent JDBC bind parameters. To see the val-

ues bound as arguments, or to reduce the verbosity of the log, check your log4j.properties.

Now we'd like to list stored events as well, so we add an option to the main method:

if (args[0].equals("store")) {

mgr.createAndStoreEvent("My Event", new Date());

}

else if (args[0].equals("list")) {

List events = mgr.listEvents();

for (int i = 0; i < events.size(); i++) {

Event theEvent = (Event) events.get(i);

System.out.println("Event: " + theEvent.getTitle() +

" Time: " + theEvent.getDate());

}

We also add a new listEvents() method:

private List listEvents() {

Session session = HibernateUtil.getSessionFactory().getCurrentSession();

session.beginTransaction();

List result = session.createQuery("from Event").list();

session.getTransaction().commit();

return result;

}

What we do here is use an HQL (Hibernate Query Language) query to load all existing Event objects from the

database. Hibernate will generate the appropriate SQL, send it to the database and populate Event objects with

the data. You can create more complex queries with HQL, of course.

Now, to execute and test all of this, follow these steps:

Introduction to Hibernate

Hibernate 3.1.1 9

• Run ant run -Daction=store to store something into the database and, of course, to generate the database

schema before through hbm2ddl.

• Now disable hbm2ddl by commenting out the property in your hibernate.cfg.xml file. Usually you only

leave it turned on in continous unit testing, but another run of hbm2ddl would drop everything you have

stored - the create configuration setting actually translates into "drop all tables from the schema, then re-

create all tables, when the SessionFactory is build".

If you now call Ant with -Daction=list, you should see the events you have stored so far. You can of course

also call the store action a few times more.

Note: Most new Hibernate users fail at this point and we see questions about Table not found error messages

regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates

the database schema on the first run, and subsequent application restarts will use this schema. If you change the

mapping and/or database schema, you have to re-enable hbm2ddl once again.

1.3. Part 2 - Mapping associations

We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll

add people to our application, and store a list of events they participate in.

1.3.1. Mapping the Person class

The first cut of the Person class is simple:

package events;

public class Person {

private Long id;

private int age;

private String firstname;

private String lastname;

public Person() {}

// Accessor methods for all properties, private setter for 'id'

}

Create a new mapping file called Person.hbm.xml (don't forget the DTD reference at the top):

<hibernate-mapping>

</id>

</class>

</hibernate-mapping>

Finally, add the new mapping to Hibernate's configuration:

Introduction to Hibernate

Hibernate 3.1.1 10

We'll now create an association between these two entities. Obviously, persons can participate in events, and

events have participants. The design questions we have to deal with are: directionality, multiplicity, and collec-

tion behavior.

1.3.2. A unidirectional Set-based association

We'll add a collection of events to the Person class. That way we can easily navigate to the events for a particu-

lar person, without executing an explicit query - by calling aPerson.getEvents(). We use a Java collection, a

Set, because the collection will not contain duplicate elements and the ordering is not relevant for us.

We need a unidirectional, many-valued associations, implemented with a Set. Let's write the code for this in

the Java classes and then map it:

public class Person {

private Set events = new HashSet();

public Set getEvents() {

return events;

}

public void setEvents(Set events) {

this.events = events;

}

Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or,

we could create another collection on the Event, if we want to be able to navigate it bi-directional, i.e. an-

Event.getParticipants(). This is not necessary, from a functional perspective. You could always execute an

explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is

clear from this discussion is the multiplicity of the association: "many" valued on both sides, we call this a

many-to-many association. Hence, we use Hibernate's many-to-many mapping:

</id>

<many-to-many column="EVENT_ID" class="events.Event"/>

</set>

</class>

Hibernate supports all kinds of collection mappings, a <set> being most common. For a many-to-many associ-

ation (or n:m entity relationship), an association table is needed. Each row in this table represents a link

between a person and an event. The table name is configured with the table attribute of the set element. The

identifier column name in the association, for the person's side, is defined with the <key> element, the column

name for the event's side with the column attribute of the <many-to-many>. You also have to tell Hibernate the

class of the objects in your collection (correct: the class on the other side of the collection of references).

The database schema for this mapping is therefore:

Introduction to Hibernate

Hibernate 3.1.1 11

_____________ __________________

| | | | _____________

|_____________| |__________________| | PERSON |

| | | | |_____________|

| TITLE | |__________________| | AGE |

|_____________| | FIRSTNAME |

| LASTNAME |

|_____________|

1.3.3. Working the association

Let's bring some people and events together in a new method in EventManager:

private void addPersonToEvent(Long personId, Long eventId) {

Session session = HibernateUtil.getSessionFactory().getCurrentSession();

session.beginTransaction();

Person aPerson = (Person) session.load(Person.class, personId);

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

aPerson.getEvents().add(anEvent);

session.getTransaction().commit();

}

After loading a Person and an Event, simply modify the collection using the normal collection methods. As

you can see, there is no explicit call to update() or save(), Hibernate automatically detects that the collection

has been modified and needs to be updated. This is called automatic dirty checking, and you can also try it by

modifying the name or the date property of any of your objects. As long as they are in persistent state, that is,

bound to a particular Hibernate Session (i.e. they have been just loaded or saved in a unit of work), Hibernate

monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory

state with the database, usually only at the end of a unit of work, is called flushing. In our code, the unit of work

ends with a commit (or rollback) of the database transaction - as defined by the thread configuration option for

the CurrentSessionContext class.

You might of course load person and event in different units of work. Or you modify an object outside of a

Session, when it is not in persistent state (if it was persistent before, we call this state detached). You can even

modify a collection when it is detached:

private void addPersonToEvent(Long personId, Long eventId) {

Session session = HibernateUtil.getSessionFactory().getCurrentSession();

session.beginTransaction();

Person aPerson = (Person) session

.createQuery("select p from Person p left join fetch p.events where p.id = :pid")

.setParameter("pid", personId)

.uniqueResult(); // Eager fetch the collection so we can use it detached

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

session.getTransaction().commit();

// End of first unit of work

aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached

Introduction to Hibernate

Hibernate 3.1.1 12

剩余222页未读，继续阅读

wongyi1

粉丝: 15
资源: 84

Hibernate参考文档：3.1.1版入门指南

Python库girder-sentry-3.1.1.dev30.tar.gz使用教程

Python库girder-sentry最新版本3.1.1.dev130发布

PyPI 官网发布最新Python库girder-homepage-3.1.1.dev145

beanlib-hibernate-3.1.1.jar

hibernate-api-3.1.1.rar

hibernate-search-3.1.1.GA-dist

mqtt-cn 3.1.1.pdf.gz

mybatis-3-mybatis-3.1.1.tar.gz

hadoop-eclipse-plugin-3.1.1.tar.gz

spring-context-support-3.1.1.RELEASE.jar

最新资源