精通Hibernate：实战解决方案与最佳实践

需积分: 10 62 浏览量更新于2024-07-22 1 收藏 2.8MB PDF 举报

"Hibernate Recipes(Apress,2ed,2015)" 是一本专注于Java持久化框架Hibernate的实战指南，旨在帮助读者深入理解和应用Hibernate解决实际问题。本书与Spring框架结合，探讨了如何在企业级应用中高效使用Hibernate。书中涵盖了许多关键主题，包括对象映射、组件映射、继承映射、集合映射、查询语言、批处理、缓存管理以及事务和并发控制等。在"Starting with Hibernate"章节中，作者引导读者进入Hibernate的世界，介绍其基本概念和设置过程。这一章可能包括安装配置、创建第一个Hibernate项目、理解Session和Transaction等核心概念。这些基础知识是后续深入学习和应用Hibernate的基础。 "Basic Mapping and Object Identity"章节讲解了如何将数据库表映射到Java对象，以及如何识别和跟踪这些对象。这涉及到Hibernate的实体类、注解、标识符策略等，这些都是ORM（对象关系映射）的关键部分。 "Component Mapping"章节讨论了如何将复杂对象或嵌套结构映射到数据库，使数据结构更贴近业务逻辑。 "Chapter 4: Inheritance and Custom Mapping"深入讨论了Hibernate对面向对象继承的支持，包括单表继承、联合继承和表分片等策略，以及自定义映射的技巧。 "Many-to-One and One-to-One Mapping"和"Collection Mapping"章节则关注于不同类型的关联映射，如多对一、一对一和一对多，以及集合如列表、集合和映射的处理。 "Many-Valued Associations"章节进一步探讨多值关联，如多对多映射，这是数据库设计中常见的一种关系。 "HQL and JPA Query Language"章节涵盖了Hibernate查询语言（HQL）和Java Persistence API（JPA）的查询表达式，使读者能够编写复杂的数据库查询，而不直接依赖SQL。 "Querying with Criteria and Example"章节介绍了基于Criteria的查询，这是一种更加面向对象的查询方式，还有通过实例进行查询的功能。 "Working with Objects"章节讨论了对象的状态管理，包括持久化、脱管和瞬时状态的转换，以及对象的生命周期。 "Batch Processing and Native SQL"章节涵盖了批量操作和如何使用原生SQL来优化性能，这对于大数据量处理至关重要。 "Caching in Hibernate"章节讲述了如何利用第二级缓存和查询缓存提高应用程序的响应速度，减少数据库交互。 "Transactions and Concurrency"章节讲解了Hibernate中的事务管理和并发控制，这对于保持数据一致性至关重要。 "Web Applications"章节则介绍了如何在Web环境中集成Hibernate，可能是通过Spring MVC或其他Web框架。 "Hibernate Recipes"提供了丰富的实例和模板，是开发者掌握和应用Hibernate的实用参考资料，适合希望提升Java持久化技术的开发者阅读。

CHAPTER 1 ■ STARTING WITH HIBERNATE

insert into book(isbn, name, publisher, publishDate, price)

values ('PBN123', 'Spring Recipes', '001', DATE('2008-02-02'), 30);

insert into book(isbn, name, publisher, publishDate, price)

values ('PBN456', 'Hibernate Recipes', '002', DATE('2008-11-02'), 40);

1-3. Configuring Hibernate

Problem

How do you configure a Java project that uses an object/relational framework such as Hibernate as a

persistence framework? How do you configure Hibernate programmatically?

Solution

Import the required JAR files into your project’s classpath and create mapping files that map the state of a Java

entity to the columns of its corresponding table. From the Java application, execute Create, Read, Update,

Delete (CRUD) operations on the object entities. Hibernate takes care of translating the object state from the

object model to the relational model.

How It Works

To configure a Java project to use the Hibernate framework, start by downloading the required JARs and

configuring them in the build path.

If you add the following dependency to the Maven pom.xml file, all dependent libraries are downloaded

under Maven Dependencies:

<groupId>org.hibernate</groupId>

<artifactId>hibernate-core</artifactId>

<version>4.3.5.Final</version>

</dependency>

Although we use both annotations and XML configurations for the Hibernate setup wherever possible,

the preference is to use annotations instead of XML.

Configuration

Before Hibernate can retrieve and persist objects for you, you have to tell it your application’s settings.

For example, which kind of objects are persistent objects? What kind of database are you using? How do

you connect to the database? You can configure Hibernate in three ways:

• Programmatic configuration: Use the API to load the hbm file, load the database

driver, and specify the database connection details.

• XML configuration: Specify the database connection details in an XML file that’s

loaded along with the hbm file. The default file name is hibernate.cfg.xml. You can

use another name by specifying the name explicitly.

• Properties file configuration: Similar to the XML configuration, but uses a

.properties file. The default name is hibernate.properties.

www.it-ebooks.info

CHAPTER 1 ■ STARTING WITH HIBERNATE

This solution introduces only the first two approaches (programmatic and XML configuration).

The properties file configuration is much like XML configuration.

Programmatic Configuration

The following code loads the configuration programmatically. If you have a very specific use case to

configure programmatically, you can use this method; otherwise, the preferred way is to use annotations.

The Configuration class provides the API to load the hbm files, to specify the driver to be used for the

database connection, and to provide other connection details:

Configuration configuration = new Configuration()

.addResource("com/metaarchit/bookshop/Book.hbm.xml")

.setProperty("hibernate.dialect", "org.hibernate.dialect.DerbyTenSevenDialect")

.setProperty("hibernate.connection.driver_class", "org.apache.derby.jdbc.EmbeddedDriver")

.setProperty("hibernate.connection.url", "jdbc:derby://localhost:1527/BookShopDB")

.setProperty("hibernate.connection.username", "book")

.setProperty("hibernate.connection.password", "book");

ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings

(configuration.getProperties()).build();

sessionFactory = configuration.buildSessionFactory(serviceRegistry);

Instead of using addResource() to add the mapping files, you can also use addClass() to add a

persistent class and let Hibernate load the mapping definition for this class:

Configuration configuration = new Configuration()

.addClass(com.metaarchit.bookshop.Book.class)

.setProperty("hibernate.dialect", "org.hibernate.dialect.DerbyDialect")

.setProperty("hibernate.connection.driver_class", "org.apache.derby.jdbc.EmbeddedDriver")

.setProperty("hibernate.connection.url", "jdbc:derby://localhost:1527/BookShopDB")

.setProperty("hibernate.connection.username", "book")

.setProperty("hibernate.connection.password", "book");

ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings

(configuration.getProperties()).build();

sessionFactory = configuration.buildSessionFactory(serviceRegistry);

If your application has hundreds of mapping definitions, you can pack it in a JAR file and add it to the

Hibernate configuration. This JAR file must be found in your application’s classpath:

Configuration configuration = new Configuration()

.addJar(new File("mapping.jar"))

.setProperty("hibernate.dialect", "org.hibernate.dialect.DerbyDialect")

.setProperty("hibernate.connection.driver_class", "org.apache.derby.jdbc.EmbeddedDriver")

.setProperty("hibernate.connection.url", "jdbc:derby://localhost:1527/BookShopDB")

.setProperty("hibernate.connection.username", "book")

.setProperty("hibernate.connection.password", "book");

ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings

(configuration.getProperties()).build();

sessionFactory = configuration.buildSessionFactory(serviceRegistry);

www.it-ebooks.info

CHAPTER 1 ■ STARTING WITH HIBERNATE

SeSSionFaCtory

The following statement creates a Hibernate SessionFactory to use in the preceding code:

SessionFactory factory = configuration.buildSessionFactory(serviceRegistry);

A session factory is a global object for maintaining org.hibernate.Session objects. It i’s

instantiated once and i’s thread-safe. You can look up the SessionFactory from a Java Naming and

Directory Interface (JNDI) context in an ApplicationServer or any other location.

XML Configuration

Another way to configure Hibernate is to use an XML file. You create the file hibernate.cfg.xml in the

source directory, so Eclipse copies it to the root of your classpath:

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

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="connection.driver_class">org.h2.Driver</property>

<property name="connection.url">jdbc:h2:file:./chapter1</property>

<property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>

<property name="hibernate.hbm2ddl.auto">create</property>

</session-factory>

</hibernate-configuration>

Now the code fragment to build up a session factory can be simplified. The configuration loads the

hibernate.cfg.xml file from the root of the classpath:

Configuration configuration = new Configuration().configure();

This method loads the default hibernate.cfg.xml file from the root classpath. The new Configuration()

loads the hibernate.properties file, and the configure() method loads the hibernate.cfg.xml file if

hibernate.properties isn’t found. If you need to load another configuration file located elsewhere (not in the

root classpath), you can use the following code:

new Configuration().configure("/config/recipes.cfg.xml")

This code looks for recipes.cfg.xml in the config subdirectory of the classpath.

www.it-ebooks.info

CHAPTER 1 ■ STARTING WITH HIBERNATE

Opening and Closing Sessions

A Hibernate Session object represents a unit of work and is bound to the current thread. It also represents a

transaction in a database. A session begins when getCurrentSession() is first called on the current thread.

The Session object is then bound to the current thread. When the transaction ends with a commit or

rollback, Hibernate unbinds the session from the thread and closes it.

Just as with JDBC, you need to do some initial cleanup for Hibernate. First, ask the session factory to

open a new session for you. After you finish your work, you must remember to close the session

Session session = factory.openSession();

try {

// Using the session to retrieve objects

}catch(Exception e)

{

e.printStackTrace();

} finally {

session.close();

}

Creating Mapping Definitions

First ask Hibernate to retrieve and persist the book objects for you. For simplicity, ’ignore the publisher right

now. Create a Book.hbm.xml XML file in the same package as the Book class. This file is called the mapping

definition for the Book class. The Book objects are called persistent objects or entities because they can be

persisted in a database and represent the real-world entities:

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

</property>

</property>

</property>

<many-to-one name="publisher" column="PUBLISHERCODE" cascade="all"/>

</class>

</hibernate-mapping>

The sample code rarely includes the exception handling for Hibernate, because we want to focus on how Hibernate is

used, rather than on Java’s exception mechanism.

www.it-ebooks.info

CHAPTER 1 ■ STARTING WITH HIBERNATE

Each persistent object must have an identifier, which’ is used by Hibernate to uniquely identify that

object. Here, you use the ISBN as the identifier for a Book object.

Retrieving and Persisting Objects

Given the ID of a book (an ISBN in this case), you can retrieve the unique Book object from the database. There

are multiple ways to do it - session.load() and session.get() are merely two common ones you’ll see:

Book book = (Book) session.load(Book.class, isbn);

and

Book book = (Book) session.get(Book.class, isbn);

What’s the difference between a load() method and a get() method? First, when the given ID can’t be

found, the load() method throws an org.hibernate.ObjectNotFoundException exception, whereas the

get() method returns a null object. Second, the load() method just returns a proxy by default; the database

isn’t hit until the proxy is first invoked. The get() method hits the database immediately. The load()

method is useful when you need only a proxy, not’ a database call. You need only a proxy in a given session

when you have to associate an entity before persisting.

Just as you can use SQL to query a database, you can use Hibernate to query objects using HQL. For

example, note the following code queries for all the Book objects:

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

List books = query.list();

If you’re sure that only one object matches, you can use the uniqueResult() method to retrieve the

unique result object:

Query query = session.createQuery("from Book where isbn = ?");

query.setString(0, isbn);

Book book = (Book) query.uniqueResult();

The create() method inserts a new row into the BOOK table. It also loads the object from the database to

validate that it exists and is the correct object.

@Test

public void testCreate() {

Session session = SessionManager.getSessionFactory().openSession();

Transaction tx = session.beginTransaction();

Publisher publisher = new Publisher();

publisher.setCode("apress");

publisher.setName("Apress");

publisher.setAddress("233 Spring Street, New York, NY 10013");

session.persist(publisher);

tx.commit();

session.close();

session = SessionManager.getSessionFactory().openSession();

tx = session.beginTransaction();

Publisher publisher1 = (Publisher) session.load(Publisher.class, "apress");

assertEquals(publisher.getName(), publisher1.getName());

tx.commit();

session.close();

}

www.it-ebooks.info

剩余270页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

精通Hibernate：实战解决方案与最佳实践

Hibernate Recipes

numerical recipes: the art of scientific computing, 3rd ed.

numerical recipes c语言实现

pytorch recipes csdn下载

numerical recipes 3rd source code

numerical recipes 源码

bitbake 编译如何剔除recipes-gnome 的编译

nr.h numerical recipes in c++

numerical recipes 代码

基于ssm框架的参考文献

最新资源