Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
We 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.
Update for Hibernate 5.2+
As of Hibernate 5.2.0, the createCriteria approach of fetching entities is deprecated. So, if you list hibernate-core 5.2.0 or later in build.gradle, then you'll get a message in your IDE, with the method call likely crossed out. Here is an example of what you should do in Application.java, to bring your code up to date:
private static List<Contact> fetchAllContacts() {
// Open a session
Session session = sessionFactory.openSession();
// DEPRECATED: Create Criteria
// Criteria criteria = session.createCriteria(Contact.class);
// DEPRECATED: Get a list of Contact objects according to the Criteria object
// List<Contact> contacts = criteria.list();
// UPDATED: Create CriteriaBuilder
CriteriaBuilder builder = session.getCriteriaBuilder();
// UPDATED: Create CriteriaQuery
CriteriaQuery<Contact> criteria = builder.createQuery(Contact.class);
// UPDATED: Specify criteria root
criteria.from(Contact.class);
// UPDATED: Execute query
List<Contact> contacts = session.createQuery(criteria).getResultList();
// Close the session
session.close();
return contacts;
}
Java 8 Features
Using Github With This Course
You can complete this course entirely using code created by you on your local machine. However, if you choose to use the code I've made available to you, you have two options:
- Use the project files linked at the bottom of this page, or
- Use the Github repository I've made available (recommended)
If you choose the recommended option of using the Github repository, it can be found at
https://github.com/treehouse/contactmgr-hibernate
To utilize Github with this course, you can download the Github desktop client for your system or use the command line interface provided with Git.
Clone this repository to your machine using the Github desktop client, or using the following command:
git clone git@github.com:treehouse/contactmgr-hibernate.git
To update your local repository to match a video's starting point, you can use the git checkout ... command in combination with the stage and video number. For example, to update your local repository to match the starting point of Stage 5, Video 4, you'd use the following:
git checkout -f s5v4
Notice the use of the -f option. This forces Git to override all local changes, so be aware: this will cause any changes you made to be lost.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
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
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up