Hibernate 4.3 教程与参考指南

5星 · 超过95%的资源需积分: 10 152 浏览量更新于2024-07-24 收藏 1.25MB PDF 举报

"hibernate 4.3 参考手册，PDF文档，涵盖了Hibernate ORM的详细使用教程和架构概述，适合Java开发者学习关系型数据库持久化技术。" Hibernate是Java领域广泛使用的对象关系映射（ORM）框架，4.3版本的参考手册详细介绍了如何在Java应用程序中使用Hibernate进行数据库操作。手册分为多个部分，包括教程、架构概述以及具体的技术细节。 1. **教程**： - **Part1 - 第一个Hibernate应用**：这部分向初学者展示了如何设置Hibernate环境，创建第一个实体类，编写映射文件，配置Hibernate，使用Maven构建项目，以及启动和使用对象加载与存储的基本步骤。 - **Part2 - 映射关联**：这部分深入讨论了如何映射实体间的关联，包括单向Set关联、双向关联、值集合以及如何处理这些关联的详细操作。 - **Part3 - EventManager Web应用**：通过一个简单的Servlet应用示例，演示了如何在Web环境中使用Hibernate处理数据库交互，包括编写基础Servlet，处理和渲染数据，以及部署和测试应用。 2. **架构**： - **Overview**：对Hibernate的整体架构进行了简要介绍，包括最小化架构和全面架构的构成，帮助读者理解Hibernate的核心组件和工作原理。 - **Minimal architecture**：这部分讲解了Hibernate最基本的组成部分，如Session接口、Transaction管理、持久化实体等。 - **Comprehensive architecture**：深入探讨了更复杂的架构设计，如第二级缓存、查询服务、事件监听器等高级特性。手册还包含了其他内容，如查询语言（HQL）、Criteria API、事务管理、缓存策略、实体生命周期管理、性能调优、JPA集成等。对于Java开发者来说，这是一份非常全面且实用的参考资料，能够帮助他们高效地利用Hibernate实现数据库的持久化操作，提升开发效率。

HIBERNATE - Relational Persistence for Idiomatic Java

http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html_single/[2014-02-24 10:49:28]

It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or

rollback, Hibernate automatically unbinds the

org.hibernate.Session from the thread and closes it for you.

If you call

getCurrentSession() again, you get a new org.hibernate.Session and can start a new unit of

work.

Related to the unit of work scope, should the Hibernate

org.hibernate.Session be used to execute one or

several database operations? The above example uses one

org.hibernate.Session for one operation.

However this is pure coincidence; the example is just not complex enough to show any other approach. The

scope of a Hibernate

org.hibernate.Session is flexible but you should never design your application to use

a new Hibernate

org.hibernate.Session for every database operation. Even though it is used in the

following examples, consider session-per-operation an anti-pattern. A real web application is shown later in

the tutorial which will help illustrate this.

See Chapter 13, Transactions and Concurrency for more information about transaction handling and

demarcation. The previous example also skipped any error handling and rollback.

To run this, we will make use of the Maven exec plugin to call our class with the necessary classpath setup:

mvn exec:java -Dexec.mainClass="org.hibernate.tutorial.EventManager" -Dexec.args="store"

Note

You may need to perform mvn compile first.

You should see Hibernate starting up and, depending on your configuration, lots of log output. Towards the

end, the following line will be displayed:

This is the

INSERT executed by Hibernate.

To list stored events an option is added to the main method:

A new

listEvents() method is also added :

Here, we are using a Hibernate Query Language (HQL) 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. See Chapter 16, HQL: The Hibernate Query

Language for more information.

Now we can call our new functionality, again using the Maven exec plugin: mvn exec:java -

Dexec.mainClass="org.hibernate.tutorial.EventManager" -Dexec.args="list"

1.2. Part 2 - Mapping associations

So far we have mapped a single persistent entity class to a table in isolation. Let's expand on that a bit and

add some class associations. We will add people to the application and store a list of events in which they

participate.

1.2.1. Mapping the Person class

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

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()

);

}

private List listEvents() {

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

session.beginTransaction();

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

session.getTransaction().commit();

return result;

}

HIBERNATE - Relational Persistence for Idiomatic Java

http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html_single/[2014-02-24 10:49:28]

The first cut of the Person class looks like this:

Save this to a file named

src/main/java/org/hibernate/tutorial/domain/Person.java

Next, create the new mapping file as src/main/resources/org/hibernate/tutorial/domain/Person.hbm.xml

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

Create an association between these two entities. Persons can participate in events, and events have

participants. The design questions you have to deal with are: directionality, multiplicity, and collection

behavior.

1.2.2. A unidirectional Set-based association

By adding a collection of events to the Person class, you can easily navigate to the events for a particular

person, without executing an explicit query - by calling

Person#getEvents. Multi-valued associations are

represented in Hibernate by one of the Java Collection Framework contracts; here we choose a

java.util.Set because the collection will not contain duplicate elements and the ordering is not relevant to

our examples:

Before mapping this association, let's consider the other side. We could just keep this unidirectional or

create another collection on the

Event, if we wanted to be able to navigate it from both directions. This is

not necessary, from a functional perspective. You can 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 is called a many-to-many association.

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

package org.hibernate.tutorial.domain;

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'

}

<hibernate-mapping package="org.hibernate.tutorial.domain">

</id>

</class>

</hibernate-mapping>

public class Person {

private Set events = new HashSet();

public Set getEvents() {

return events;

}

public void setEvents(Set events) {

this.events = events;

}

</id>

HIBERNATE - Relational Persistence for Idiomatic Java

http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html_single/[2014-02-24 10:49:28]

Hibernate supports a broad range of collection mappings, a set being most common. For a many-to -many

association, or n:m entity relationship, an association table is required. Each row in this table represents a

link between a person and an event. The table name is declared using the

table attribute of the set

element. The identifier column name in the association, for the person 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 (the class on the other side of the collection

of references).

The database schema for this mapping is therefore:

1.2.3. Working the association

Now we will bring some people and events together in a new method in EventManager :

After loading a

Person and an Event, simply modify the collection using the normal collection methods.

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

org.hibernate.Session, 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.

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

org.hibernate.Session, when it is not in persistent state (if it was persistent before, this state is called

detached). You can even modify a collection when it is detached:

The call to

update

makes a detached object persistent again by binding it to a new unit of work, so any

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

</set>

</class>

_____________ __________________

| | | | _____________

|_____________| |__________________| | PERSON |

| | | | |_____________|

| TITLE | |__________________| | AGE |

|_____________| | FIRSTNAME |

| LASTNAME |

|_____________|

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();

}

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

// Begin second unit of work

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

session2.beginTransaction();

session2.update(aPerson); // Reattachment of aPerson

session2.getTransaction().commit();

}

HIBERNATE - Relational Persistence for Idiomatic Java

http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html_single/[2014-02-24 10:49:28]

modifications you made to it while detached can be saved to the database. This includes any modifications

(additions/deletions) you made to a collection of that entity object.

This is not much use in our example, but it is an important concept you can incorporate into your own

application. Complete this exercise by adding a new action to the main method of the

EventManager and call

it from the command line. If you need the identifiers of a person and an event - the

save() method returns

it (you might have to modify some of the previous methods to return that identifier):

This is an example of an association between two equally important classes : two entities. As mentioned

earlier, there are other classes and types in a typical model, usually "less important". Some you have

already seen, like an

int or a java.lang.String. We call these classes value types, and their instances

depend on a particular entity. Instances of these types do not have their own identity, nor are they shared

between entities. Two persons do not reference the same

firstname object, even if they have the same first

name. Value types cannot only be found in the JDK , but you can also write dependent classes yourself

such as an

Address or MonetaryAmount class. In fact, in a Hibernate application all JDK classes are

considered value types.

You can also design a collection of value types. This is conceptually different from a collection of references

to other entities, but looks almost the same in Java.

1.2.4. Collection of values

Let's add a collection of email addresses to the Person entity. This will be represented as a java.util.Set of

java.lang.String instances:

The mapping of this

Set is as follows:

The difference compared with the earlier mapping is the use of the

element part which tells Hibernate that

the collection does not contain references to another entity, but is rather a collection whose elements are

values types, here specifically of type

string. The lowercase name tells you it is a Hibernate mapping

type/converter. Again the

table attribute of the set element determines the table name for the collection.

The

key element defines the foreign-key column name in the collection table. The column attribute in the

element element defines the column name where the email address values will actually be stored.

Here is the updated schema:

You can see that the primary key of the collection table is in fact a composite key that uses both columns.

This also implies that there cannot be duplicate email addresses per person, which is exactly the semantics

we need for a set in Java.

You can now try to add elements to this collection, just like we did before by linking persons and events. It

is the same code in Java:

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

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

Long personId = mgr.createAndStorePerson("Foo", "Bar");

mgr.addPersonToEvent(personId, eventId);

System.out.println("Added person " + personId + " to event " + eventId);

}

private Set emailAddresses = new HashSet();

public Set getEmailAddresses() {

return emailAddresses;

}

public void setEmailAddresses(Set emailAddresses) {

this.emailAddresses = emailAddresses;

}

</set>

_____________ __________________

| | | | _____________

|_____________| |__________________| | PERSON | | |

| | | | |_____________| | PERSON_EMAIL_ADDR

| *EVENT_ID | <--> | *EVENT_ID | | | |___________________|

| TITLE | |__________________| | AGE | | *EMAIL_ADDR |

|_____________| | FIRSTNAME | |___________________|

| LASTNAME |

|_____________|

HIBERNATE - Relational Persistence for Idiomatic Java

http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html_single/[2014-02-24 10:49:28]

This time we did not use a fetch query to initialize the collection. Monitor the SQL log and try to optimize

this with an eager fetch.

1.2.5. Bi-directional associations

Next you will map a bi-directional association. You will make the association between person and event

work from both sides in Java. The database schema does not change, so you will still have many-to-many

multiplicity.

Note

A relational database is more flexible than a network programming language,

in that it does not need a navigation direction; data can be viewed and

retrieved in any possible way.

First, add a collection of participants to the

Event class:

Now map this side of the association in

Event.hbm.xml.

These are normal

set mappings in both mapping documents. Notice that the column names in key and

many-to-many swap in both mapping documents. The most important addition here is the inverse="true"

attribute in the set element of the Event 's collection mapping.

What this means is that Hibernate should take the other side, the

Person class, when it needs to find out

information about the link between the two. This will be a lot easier to understand once you see how the

bi-directional link between our two entities is created.

1.2.6. Working bi-directional links

First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between

Person and an Event in the unidirectional example ? You add an instance of Event to the collection of

event references, of an instance of

Person. If you want to make this link bi-directional, you have to do the

same on the other side by adding a

Person reference to the collection in an Event. This process of "setting

the link on both sides" is absolutely necessary with bi-directional links.

Many developers program defensively and create link management methods to correctly set both sides (for

example, in

Person):

private void addEmailToPerson(Long personId, String emailAddress) {

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

session.beginTransaction();

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

// adding to the emailAddress collection might trigger a lazy load of the

collection

aPerson.getEmailAddresses().add(emailAddress);

session.getTransaction().commit();

}

private Set participants = new HashSet();

public Set getParticipants() {

return participants;

}

public void setParticipants(Set participants) {

this.participants = participants;

}

<many-to-many column="PERSON_ID" class="Person"/>

</set>

剩余266页未读，继续阅读

cmxp2008

粉丝: 10
资源: 27

Hibernate 4.3 教程与参考指南

Hibernate官方中文参考手册

Hibernate4.1.11中文手册

hibernate4.3.5官方英文文档

springmvc4_hibernate4.3_JPA2.1_Shiro1.2_Ehcache

hibernate 中文参考手册

Hibernate 4.3.4中文参考手册

Hibernate 3.x 参考手册

Hibernate参考文档

Hibernate 手册中文版chm格式

thymleaf参考手册

最新资源