Search

In Chapter 5, we discussed the need to create mappings between the database model and the object model. Mappings can be created as separate XML files, or as annotations inline with the source code for your POJOs. In this chapter, we discuss the use of annotations, and in the next chapter, we will discuss the use of XML files.

The purpose of Hibernate is to allow you to treat your database as if it stores Java objects. However, in practice, relational databases do not store objects – they store data in tables and columns. Unfortunately, there is no simple way to correlate the data stored in a relational database with the data represented by Java objects.

Hibernate provides a number of capabilities beyond the simple “native Hibernate API.” In this chapter, we are going to discuss using the standard JPA configuration resource, Hibernate’s object validation facilities, and object lifecycle events — along with a few other tricks.

We’ve seen a lot about how to use Hibernate, including a series of example models, but none of this has really demonstrated how Hibernate would be used in the "real world." All of our running code has been embedded in tests, which isn’t a bad thing for development, but this isn’t a good way to make it clear how to integrate Hibernate into applications people are likely to use.

In this chapter, we’re going to explore a decent subset of Spring configuration, and we’re going to shift attention away from "Hello, World" into a simple application that will allow us to explore features and configuration. We’ll introduce the sample application first, then walk through a few different ways to configure it. There’s a lot of code here, much of it redundant on the surface, but we’ll use some base classes to help reduce the tendency to repeat ourselves.

It’s time we started looking at how we actually access data. Spring has multiple ways of accessing data; here, we’re going to look at JdbcTemplate, a facade that provides trivial access to common operations, and we’re going to address some of Chapter 7’s other issues with data access.

Spring is an application framework providing dependency injection features for the Java Virtual Machine – features that enable testability, reliability, and flexibility to application developers. It changed how Java is developed, and here’s how and why.

Spring can certainly be used in a standalone environment, but the most common environment for Spring has historically been in an enterprise environment, powering web applications and backend services in a managed server. This chapter will demonstrate some aspects of integration in a Jakarta EE container (formerly known as Java EE, or J2EE, or maybe even just "Tomcat" depending on your level of exposure, currency, and experience).

In Chapter 8 we finally stopped looking at configuration and presentation mechanisms, and we looked at accessing a relational database with JdbcTemplate. In this chapter, we’re going to look at accessing data again – with a Spring project called "Spring Data," which can provide a mostly data-agnostic view of data access.

Your application will often need to process only a subset of the data in the database tables. In these cases, you can create a Hibernate filter to eliminate the unwanted data. Filters provide a way for your application to limit the results of a query to data that passes the filter’s criteria. Filters are not a new concept — you can achieve much the same effect using SQL database views or, well, named queries — but Hibernate offers a centralized management system for them.

You may have noticed that the Session object is the central point of access to Hibernate functionality. We will now look at what it embodies and what that implies about how you should use it.

Hibernate provides three different ways to retrieve data. We have already discussed HQL and the use of native SQL queries; now we add criteria.

In this chapter, you’ll take another look at some of the steps necessary to get the example from Chapter 1 up and running. You’ll also build a somewhat larger application from scratch. All of the code in this book is available for download from the Apress site (www.apress.com).

In the last chapter, we discussed how the Hibernate session is used to interact with the database. Some of the session's methods take query strings in their parameter lists or return Query objects. These methods are used to request arbitrary information from the database. In order to fully show how they're used, we must introduce the Hibernate Query Language (HQL), used to phrase these requests. As well as extracting information (with SELECT), HQL can be used to alter the information in the database (with INSERT, UPDATE, and DELETE). We cover all of this basic functionality in this chapter. Note: Hibernate's query facilities do not allow you to alter the database structure.

In the previous chapter, you saw how to use Hibernate Query Language (HQL) and Java Persistence Query Language (JPA QL). HQL forces you to interact with the database using SQL-like syntax. You must have some knowledge of SQL to create complex queries, which makes it difficult to develop applications that use multicriteria queries.

When you use JDBC to access databases, you write SQL statements for the query and update tasks. In such cases, you’re dealing with tables, columns, and joins. When you use Hibernate, most update tasks can be accomplished through the provided APIs. However, you still need to use a query language for the query tasks, and Hibernate provides a powerful query language called Hibernate Query Language (HQL).

An object model uses the principles of abstraction, encapsulation, modularity, hierarchy, typing, concurrency, polymorphism, and persistence. The object model enables you to create well-structured and complex systems. In an object model system, objects are the components of the system. Objects are instances of classes, and classes are related to other classes via inheritance relationships. An object has an identity, a state, and a behavior. An object model helps you create reusable application frameworks and systems that can evolve over time. In addition, object-oriented systems are usually smaller than non-object-oriented implementations.

A many-valued association is by definition a collection of references to entities. The collection can be of type List, Set, Map, and so on in Java.

This chapter discusses the states an object goes through during its life cycle. The session is responsible for managing object state in Hibernate, and the EntityManager does the same in Java Persistence. Hibernate provides a persistence mechanism that is transparent to the entities and the application; the application has to know the state of an object.

is the processing of groups of elements. From an application standpoint, batch processing means reading data from a persistent store, doing something with the data, and then possibly storing the processed data in the persistent store as a single conceptual operation. Batch processing, which allows for the automation and sharing of computer resources, is usually run when computer resources are less busy.

In general, entities are related or associated to each other. For example, a Customer entity is associated with an Address entity. A Customer entity can have one or more than one Address entity (for example, Billing and Shipping). These relationships or associations are represented differently in a relational model and the domain/object model.

A primary key in a database table is used to uniquely identify a record in that table. The primary key value can't be null and is unique within a table. The primary key is also used to establish a relationship between two tables; it is defined as a foreign key in the associated table. Because the primary key is used to identify a particular record, it can also be called the database identifier, which is exposed to the application by Hibernate through an identifier property of the persistent entity. This chapter discusses the various ways to generate an identifier (primary key) for a database record. You learn about metadata configurations and their effect on the persistence mechanism.

Let’s say that a buyer logs in to the bookshop application and purchases a book. The following actions should take place in the event of a purchase