Chapter 1, Entity and Session, covers the internal working of a session and how Hibernate manages entities inside a session. We will also explore the entity life cycle and discuss other topics related to sessions and entities such as stateless sessions, design patterns such as session-per-request, session-per-conversation, batch processing, and proxy objects.

Chapter 2, Advanced Mapping, talks about fundamental mapping concepts and how Hibernate bridges the gap between the object-oriented world and relational database. You will further read discussions on inheritance, and in-memory and in-database value generation. Moreover, the creation of custom mapped data types is also covered. This chapter also demonstrates how to work with collections and offers tips and tricks, and outlines the pitfalls when working with collections. Additionally, it covers batch updates and deletes. Finally, this chapter shows you how to implement object-oriented topics such as inheritance and polymorphism and map them correctly to a relational database.

Chapter 3, Working with Annotations, demonstrates the use of annotations and why and when to use them. Besides the common annotations, it highlights some rare ones, which can be quite useful for most developers. In addition to the common JPA annotations, this chapter also discusses some annotations that are only available in Hibernate.

Chapter 4, Advanced Fetching, shows various fetching strategies and discusses the use of Hibernate and native query languages, criteria objects, filters, and other topics related to data fetch.

Chapter 5, Hibernate Cache, covers various cache structures such as first-level and second-level. Additionally, it explores various cache strategies and how to collect statistics related to caching.

Chapter 6, Events, Interceptors, and Envers, covers events and interceptors in Hibernate and how you can use them to implement a functionality similar to DB triggers and other event-based functions. Furthermore, it covers Entity Auditing (Envers); which implements entity revision management to automatically store historical snapshots of entities and also provides an auditing mechanism.

Chapter 7, Metrics and Statistics, demonstrates how to generate and collect metrics and statistical data within Hibernate. This includes entity, query, collection, and cache statistics. It further shows how to access this data via JMX, that is, Java Management Extensions.

Chapter 8, Addressing Architecture, shows how architectural concerns and constraints are addressed in Hibernate, which includes concurrency and transaction management, scalability, and performance.

Chapter 9, EJB and Spring Context, shows how to correctly create and deploy your application in two popular Java contexts, EJB and Spring.

All the code in this book is written using Java SE 7. You will need a Java IDE (Integrated Development Environment) such as Eclipse, Netbeans, or IntelliJ. Additionally, you will need a relational database, such as Oracle, DB2, MySQL, or PostgreSQL. The database used to create the examples in this book is PostgreSQL database (version 9.3).

Most of the examples in the initial chapters are single-threaded Java applications that do not need to run inside a Java Enterprise container or Spring. However, in later chapters, you will need to test your enterprise application in a container. In this case, JBoss (AS 7) or Spring (version 4.2) were chosen.

Although, you may not need it, it is highly recommended that you use a dependency manager for your work. The examples in this book use Apache Maven, version 3.

This book covers fundamental concepts of Hibernate. It is intended for highly technical developers who wish to understand the internals of Hibernate. This book can also be used by developers who have already started using Hibernate and wish to get better at it. It is not intended to make you a Java or SQL developer. If you wish to learn about the how and why, then this book is for you. Mastery is about details.

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "The @Any and @ManyToAny annotations are only available in Hibernate."

A block of code is set as follows:

@Entity
public class Person {
@Id
@GeneratedValue
private long id;
private String firstname;
private String lastname;
private String ssn;
private Date birthdate;
// getters and setters
}

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

{
Entity
public class Circle {
@Id
@GeneratedValue
}
}

Any command-line input or output is written as follows:

select
course0_.id as id1_0_0_,
course0_.title as title2_0_0_,
students1_.course_id as course_i4_0_1_,
students1_.id as id1_1_1_,
students1_.gender as gender2_1_2_,
students1_.name as name3_1_2_ 
from
Course course0_

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail <[email protected]>, and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.