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
This lesson demonstrates the use of a Hibernate `SessionFactory` to save a new entity to the database.
Note:
The .save() method in Hibernate is now deprecated. It still functions as expected, though you may see warnings in your IDE. For newer implementations, it's recommended to use the .persist() or .merge() methods, which offer similar functionality.
Java Transaction API Dependency
Though I included the JTA library in the Gradle build file as a compile-time dependency, you could instead list it as a runtime dependency, since no source code references the library:
runtime 'javax.transaction:jta:1.1'
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
[MUSIC]
0:00
We're finally ready to see Hibernate in
action by creating a contact object and
0:04
saving it to the database
using a Hibernate session
0:09
that will come from the session
factory we've created.
0:12
Let's check it out!
0:15
I'm in application.java.
0:16
And so that we can continue
working on our hibernate features,
0:19
I'm going to uncomment
the session factory static field.
0:22
Great.
0:27
Let's head down to the main method.
0:28
Now, we've created this
contact object using this
0:30
findContact builder that we
coded in the previous video.
0:33
It's time to persist this contact.
0:36
That is, it's time to save
the contact to our database.
0:39
I'm going to take out this
display of our contact object and
0:43
drop in some comments of what we need
to do in order to persist our contact.
0:47
So the first thing we're going
to do is open a session.
0:52
Then we will begin a transaction.
0:56
Third, we'll use this session
to save the contact object.
1:02
Then we'll commit the transaction,
and finally, we'll close the session.
1:08
We'll need just one statement for each
comment, so this should be fairly quick.
1:17
First, to open a session, we simply
use the SessionFactory we spent so
1:21
much time discussing while coding, and
we call its open session method like this.
1:26
We'll declare the session variable,
I'll call it session.
1:31
And using that SessionFactory static
field, we'll call this openSession method.
1:35
Great.
1:40
The next thing we need to
do is begin a transaction.
1:41
Now remember, a transaction is
a thing that we use to contain
1:44
several queries into a single operation.
1:47
So let's say that if one query fails,
we abort the whole transaction by
1:50
undoing all the previous
queries within the transaction.
1:53
This would be called rolling
back the transaction.
1:56
In hibernate, to begin a transaction,
it's pretty straightforward.
1:59
sesson.beginTransaction.
2:03
While we're on the topic of transactions,
in order to support hibernate
2:06
transactions, we'll need to add one more
dependency to our gradle build file.
2:10
So I'll go ahead and open that now.
2:14
This new dependency is the JTA library,
or Java Transaction API, and
2:17
here is how it looks in
the gradle build file.
2:22
javax.transaction is the group ID.
2:25
jta is the artifact ID.
2:29
And version 1.1 is the one
we're currently using.
2:32
Great, I'll save that.
2:35
And in my Gradle Tool Window,
I will refresh my Dependencies.
2:37
Excellent, done with this build file so
I'll close it.
2:44
Now back in the Application class,
here's the one line of
2:48
code that will save us a bunch of time
in interacting with our database.
2:51
It's the one that actually
persists object to the database.
2:55
It is the save method, session.save, and
2:59
we simply pass it the object that
we would like it to persist.
3:02
Now this object will have had to be
annotated with those JPA annotations,
3:07
which we have done.
3:11
Next we will commit the transaction, which
finalizes the transaction in the database.
3:13
To do that,
we do session.getTransaction().commit();.
3:18
And finally, we'll close the hibernate
session, session.close();.
3:26
And we're done.
3:33
Now because we're only inserting
data into the database and
3:35
not selecting data from the database for
3:39
display, let's do something that let's us
know our session save is actually working.
3:41
Let's hop over to the hibernate
configuration file.
3:46
And use a property that tells hibernate to
display its queries as they're executed.
3:50
Let me create a comment for this, And
3:54
in this property we will tell hibernate to
show the queries prepared by Hibernate.
4:01
Now the property name, Is show_sql,
4:11
and we are going to set that value
to true, pretty straightforward.
4:16
We want hibernate to show SQL queries,
so we set the show_sql property to true.
4:23
Now, we can run the application and
4:30
what we should see are the queries
performed by hibernate.
4:32
So let's go ahead and
right click on application and
4:35
choose run and let's see what
is displayed in the terminal.
4:38
You're gonna get a bunch of output
here but in that output you should see
4:42
a create table statement
is executed by Hibernate.
4:47
This will create a contact table.
4:52
Now this is generated by that hbm2ddl tool
right here since we set this property,
4:54
hbm2ddl.auto we set that value to create.
5:00
Our database schema will be created by
this tool based on those JPA annotations.
5:05
Then, a little further down in
the output you should see this hibernate
5:11
insert statement,
5:16
which is where our contact object is
actually persisted to the database.
5:17
Success!
5:22
Now, you might be wondering why you see
question marks here instead of the actual
5:23
values used to create the object.
5:28
This is because hibernate uses what
are called, prepared statements.
5:30
These are also referred to as parametrized
statements, like statement templates that
5:34
the database, in our case H2, can optimize
and keep on hand for repeated use.
5:39
Then, hibernate passes the parameter
of values to stick into those question
5:45
mark placeholders.
5:49
Prepared statements help databases execute
similar queries with different values
5:51
extremely efficiently.
5:55
Prepared statements aren't
a feature of hibernate but
5:56
rather of a database system, but as you
can see hibernate fully supports them.
5:59
Hey, nice work.
6:04
You've now bridged the gap between
your application and a database and
6:06
you built that bridge with hibernate.
6:09
These results are promising but
may not be completely convincing.
6:11
Let's break here so
you can answer a couple questions.
6:16
And then, we'll explore some more
features that Hibernate has to offer.
6:18
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