Preview
Video Player
00:00
00:00
Fetching Data with Hibernate
9:27We now have data stored in our database - great! Eventually you will want to retrieve that data, so in this video you will use a Hibernate `Session` to get a list of all contacts stored in the database. You will do this by leveraging a Hibernate `Criteria` object.
Once again way to go on verifying that
your Contact objects are being persisted
0:00
into your database.
0:05
With simple console output,
we were able to spy on the sequel that
0:06
Hibernate was generating and
firing off to H2 for final processing.
0:10
This kind of monitoring of a Hibernate
queries is useful in many scenarios.
0:15
Especially when fine-tuning
the performance of Hibernate and
0:19
minimizing both the number of times
your application has to hit the DB
0:23
as well as the amount of
time each query is taking.
0:27
In our case though, it's only
a stepping stone to using our data and
0:31
displaying it more naturally
in the application.
0:35
What we'll look at now is how to
use Hibernate to fetch a list of
0:38
all the objects of a certain entity class
that have been persisted to the database.
0:41
Let's have a look at the most basic way of
doing that with what is called Hibernate
0:46
criteria.
0:50
Here in application.java,
I'd like to do some refactoring first.
0:51
Since we currently have code saving
a Contact object, and we're about to
0:58
write code to retrieve contact objects,
let's split those into separate methods.
1:01
Let's create a method named save and
have it persist as supplied contact.
1:06
I'll get the method signature in here now,
private static void save.
1:11
And I want to save a Contact object,
I'll name it contact.
1:16
And into here,
1:20
I'm gonna drop all that code that we
previously put into the main method.
1:21
Great.
Then, back up in main, we can simply call
1:26
the save method with the Contact object we
created using the builder, just like this.
1:29
Save contact.
1:37
Next, let's create a method
that will retrieve or
1:39
fetch all of our Contact
objects from the database.
1:42
Let's call it fetchAllContacts.
1:45
So, private static will return a list,
that's a java.util list,
1:48
of Contact objects and
we'll call it fetchAllContacts.
1:55
Because we're interacting with a database
using Hibernate this will involve
2:01
opening a session, doing some stuff,
then closing the session.
2:05
So let's get that session open and
close in there right away.
2:08
So we'll first open a session,
we'll do some other things but
2:13
finally we'll close the session.
2:17
So again, to open the session,
it's the same code as before,
2:21
session = sessionFactory.openSession.
2:24
And to close the session, we simply call
the close method on that S~ession object.
2:29
Cool.
2:34
Now between these two lines of code,
while the session is open,
2:36
that's where our magical
code will come into play.
2:39
To retrieve all contacts as
a list of contact objects
2:42
we'll use what's called
a Hibernate Criteria object.
2:45
In Hibernate, a Criteria object can be
used to filter results according to one or
2:48
more restrictions.
2:52
In its most basic form,
2:54
a criteria can be used to produce
a list of persisted entity objects.
2:56
Here's how it looks, so first,
we're going to create the Criteria object.
3:00
I'll declare a criteria variable
that comes from org.Hibernate,
3:07
I'll call it criteria and into it I'll
store a call to session.createCriteria.
3:10
And here is where we put
a reference to the contact class,
3:17
that's Contact.class.
3:22
Whereas we could add all sorts of
restrictions to the Criteria object here
3:26
such as restricting results to
contacts whose first name is Fiona or
3:29
whose email contains teentreehouse.com.
3:34
We can simply leave the Criteria object
as is, and call its list method.
3:37
So let's create a list of Contact objects.
3:42
That will be a list of Contact objects,
I'll call it contacts.
3:46
And store into it the results
of calling that list method.
3:51
Criteria.list.
3:54
Let me add a comment here that
says exactly what I'm doing.
3:59
Get a list of Contact objects
4:02
according to the Criteria
object that we just created.
4:07
Now, after we close the session, we'll
need to return that list of contacts,
4:12
return contacts.
4:16
Now, you might notice that you get some
faint highlighting over critera.list.
4:18
What this is is a compiler warning telling
us that we have an unchecked assignment.
4:24
The Criteria objects list method
returns an unparamaterized list and
4:30
we're assigning it to a paramaterized
list that is a list of Contact objects.
4:34
If you recall from our annotations course,
we can suppress compiler warnings.
4:39
Because we don't have access
to alter the hibernate source
4:43
code to resolve this assignment,
4:46
this is one of those few scenarios when
it is acceptable to suppress the warning.
4:48
So let's do that with
a SuppressWarnings annotation.
4:53
SuppressWarnings and
4:58
we will suppress the unchecked assignment
warning using the string unchecked.
5:00
Excellent, the warning is now suppressed.
5:06
Now, to put this to work.
5:10
Let's go back up to the main method and
5:12
display a list of contacts
using its two-string method.
5:14
So, here I'm going to display a list
of contacts by using a for loop.
5:18
So I'm going to iterate over all contacts
5:26
that come back from
the fetchAllContacts method.
5:30
And in here, I'm simply going to
use a System.out.println of c.
5:33
Now, let's run the application again,
to see our Contact objects displayed.
5:40
So I'll right click here and choose Run.
5:44
And you'll see a bunch of Hibernate
output until finally we get
5:48
to our applications output.
5:51
And here are the results of our
two-string method which show that we did
5:54
indeed successfully persist that
Contact object using our method.
5:58
And successfully retrieved
that list of contacts,
6:04
even though there is only one,
using Hibernate, excellent.
6:08
Now you may wonder that after running
this application a few times,
6:12
why is it that you always get just
one contact in your database?
6:17
Each time I run it I still get
just one contact in my database.
6:22
You might be asking, doesn't the data
continue to exist after exiting and
6:27
re-running the application?
6:31
After I run it a second time shouldn't
there be two contacts in there?
6:33
And a third time, shouldn't there
be three contacts in there?
6:37
The answer to those questions is,
well, no.
6:41
And that is because we told
the HBM to DDL tool to create
6:44
our database schema on startup.
6:48
If we go back to that configuration file,
we can remind ourselves that we set
6:50
the HBM to DDL.autoproperty to create.
6:55
That means that any previous data will
be wiped out on application startup.
6:59
And we can change that property value
to update so that only database schema
7:04
changes will be made instead of blowing
away our whole schema and recreating.
7:11
Let me update the comment here.
7:16
Update the database schema on startup.
7:18
So now, when we rerun the application,
if Hibernate detects that there have been
7:20
changes in the schema as
indicated by our JPA annotations.
7:25
The table or
tables will be altered by the HBM to DDL
7:30
tool without changing the data
that exists in those tables.
7:35
So, after making that change,
let me stop the application.
7:41
I will delete all the output in my
terminal here and I will rerun.
7:46
Let's see what kind of data we get now.
7:50
There you have it,
we have two contacts here.
7:54
Of course, because our application
code only specifies information for
7:57
one contact, we'll continue getting
the same info for each contact, but
8:01
with one exception, the id here.
8:05
In the second contact it's 2,
in the first contact it's 1.
8:08
Remember the id field is
automatically generated, so
8:13
that each contact has
a unique id in the database.
8:17
As a fun side note,
if we switch back to application.java,
8:21
we can use some of the new features
offered by Java 8 to condense our code.
8:25
Specifically, this code right here.
8:29
This for each loop can be simplified
by using what's called a stream, and
8:32
on that stream we can call a method named,
for each.
8:36
Passing to it, a reference to the
system.out classes static printlin method.
8:39
Let me show you how that looks.
8:43
We'll call the fetchAllContacts method and
on that list we will create a Java stream.
8:45
And here is where we can call this method
named forEach, passing a method reference,
8:52
which is new in Java 8, to the println.
8:57
The system that out-classes
static println method.
9:00
And, after running this, you should
see that we get the same output.
9:05
Let me stop our previous run of
the application, trash our output, and
9:09
re-run it to see if we
get the same output.
9:14
Excellent, we do get the same output.
9:17
And now we have three contacts,
pretty sweet stuff.
9:19
Check out the Teacher's Notes for
some more features introduced in Java 8.
9:23