Over the last couple videos, we've spent some time configuring our Spring app for

use with Hibernate.

All of this is pretty standard for Spring and Hibernate and

really had nothing specific to our Give Lip application.

That said, it's time to get to work on the code that will be unique to Give Lip.

We ended the last video adding our dependencies for

spring, hibernate and each to our database provider.

Now we'll need to include some configuration that Spring will detect upon

booting our application.

For this we'll follow the same pattern you've seen with app config and

template config.

That is we'll create another configuration class that is specific

to configuring our data source.

Let's call it data config.

So I'm wanna right click on config and choose new Java class and

I'll call it data config.

So that Spring picks it up at boot time will annotate this class with

configuration.

Next will create a spring bean that's configured on boot and

available throughout our app.

This will be the spring equivalent of what the hibernate session factory was

in our hibernate basics course, so

that spring is able to manage hibernate sessions in the spring container

application context instead of directly configuring a session factory.

We'll create a local session factory being object.

Let's create that method now we'll annotated with the @Bean annotation

we'll call it public LocalSessionFactoryBean.

Now and make sure that you choose the one that comes from the hibernate

five package, you see I chose the hibernate

four while I couldn't actually see the package names in my.

Auto suggests, so I'll just change that to hibernate5,

I know that package exists, and I'll call this method, sessionFactory.

You can call it whatever you like.

For now, I will just have this return null.

Let's start by loading a class path resource from hibernate.cfg.xml.

We'll store this into a spring resource object.

So we'll start by creating that object.

Resource, there it is right there from the spring framework.

I'll call it can config, new classpath resource.

Since this file, this hibernate.cfg that XML file is on the classpath,

hibernate.cfg.x.m.l.

Next we'll create a local session factory and be an object.

So let's do that here local session factory bean.

I'll call it session factory.

You can call it session factory bean if you like.

I'll just use the default constructor.

And next, I will set the config location to that class path resource we just

created and for that I'll use the session factory dot set config location method.

And I'll pass it, that resource object I created right here.

And so that I don't forget to update my return value, it's the session

factory variable, which holds that local session factory being object.

It's the session factory that I want to return so let's replace no with that.

In our next step, we'll actually use Spring to scan for JPA annotated entities,

instead of adding an XML mapping element that specifies each annotated entity

separately, like we did in Hibernate basics.

This is a handy feature that Spring offers.

We can use the sessionFactories set packages to scan method to do this, so

I'll do that before I return that, session factory.setPackagesToscan.

Now we don't wanna hard code this package name into our source code here.

So this is a good candidate for what's called externalization.

That is, let's stick the package name in our properties file and

load it from this Java method.

Let's open app.properties.

You'll find that in the resources directory.

It will open app.properties.

Now, this property's file is a standard way to specify

all sorts of configuration in Java.

And then use Java code to load these values into memory.

In general, you'll start with a property name right here, that'll be followed by

an equals sign, and then you'll have the property value listed.

Using these files allows you to externalize values that might change and

prevents you from having to weave these into your source code.

You see only one property in here already.

Which serves as an initializer value or salt for

the hash IDs library we discussed earlier.

Let's add another property here where we can stick the name of the package that

contains our JPA annotated entities for hibernate to load.

Let me add a comment referencing what we're about to do here.

So this is gonna be the property that holds the package where our entities

which are just our models are located.

Then I'll call this property giflib.entity.package.

Now the package where entity classes are located or

com.teamtreehouse.giflib.Model, and there are our category and gif entities there.

So we want to use com.teamtreehouse.giflib.model

as our entity package name.Com.teamtreehouse.

you see I get my nice auto suggest here for my IDE, .model.

Now, after saving those changes, we'll flip back to the data config class.

Now where it's not too difficult to write Java code to create a properties object

and read the properties file with an input stream,

Spring provide some handy functionality for us.

We can annotate the class with properties source up here.

It's a property source and

in parentheses we can provide the name of the properties file, that will

contain the properties we like to use in this class in our case app dot properties.

Then to gain access to these values we can

auto wire a Spring environment object as an instance field.

Here's how that looks.

So we use that auto wired annotation private Environment there's that Spring

framework Environment class I'll just abbreviated env So

what will happen here is spring will load all the properties from app.properties.

Store them into this environment object and

now we can use this environment object throughout this classes methods,

to grab specific property values that came from app.properties.

Let me show you how that looks.

Back to where we wanted to set the package to scan for our entity classes.

What we can do is use ENV dot get property and then all we need to do

is.reference the exact property name that we used in app dot properties.

So the property name remembers is on the left hand side of that equals sign.

So I will drop that in quotes right there.

So this expression right here will evaluate.

To whatever value in app up properties.

The property name to get flipped.entity.package holds

In other words, that expression I have highlighted there will evaluate to

this value at run time, which is exactly what I want.

So I avoid hard coding values in my source code,

it's a wonderful practice to get in the habit of.

The final piece we need to configure for the SessionFactory is the data source.

Now we can do this by using the setDataSource method.

So we use SessionFactory.setDataSource and

I will call a dataSource method here which doesn't actually exist yet.

So let's use the IDE to create that.

When I create this method, now be careful here.

If you are going to annotate this as a bean so that Spring can

manage it in its container, you better set this as a public method.

And your IDE by default,

if this method isn't used outside of the class, will generate this as private.

So be sure that this bean method is listed as a public method.

Now this method is where we'll be using that dbcp library from Apache

to handle database connection pooling.

In this method we'll start by creating a basic

data source object which comes from that Apache library.

I'll abbreviate that name, ds, standing for data source, and

I will use its default constructor to start that object.

Now it's this object that we'll eventually want to return, but before we return

that object, we better have set a bunch of properties related to the DataSource.

Let me add comments here for the things that we need to set.

First we'll need to set the Driver class name.

Then we'll need to set the URL.

If you recall from Hibernate basics, this is going to be our full connection string.

And then, we need to set the username and password.

Now let's go through each one of these pieces of information that we have to set

related to the data source, and drop in a line of code Code or two.

So for the driver class name, this is going to be ds.setDriverClassName.

You'll find that these method names, in the DataSource object,

this basic DataSource object, are gonna be quite intuitive.

Now, we are going to be using that same idea of externalization and

these values will come from that app.properties file.

So we're going to end up using env.get property followed by some string.

So in this case for the name of the driver class let's use gifLib.db.driver and

then for the URL again ds.set,

there's that nice intuitive method name there ds.setUrl and

again env.getProperty and

then I will call this one giflib.db.url and let's do the same thing for

the username and password ds.setUsername.

That will be env.getProperty.

We'll say giflib.db.username and the same thing for the password,

setPassword env.getProperty

giflib.db.password.

Excellent, now that we've referenced all these property values,

giflib.db.driver .db.url and username and password.

Without actually having placed them in the app.properties file,

we should probably add those now.

Let's switch to app.properties and do that.

So at the end of the file, let me drop a comment about what we're about to do.

So these will be the details for our data source.

Now we'll need four properties here.

That's going to be the driver of the URL, the username, and the password, so

let's get those in here, giflib.db.driver.

And this is going to be org.h2.driver.

When the values are package names of libraries that are already on

the classpath, IntelliJ will nicely suggest those for

you so you don't have to memorize them.

Very handy.

Next is going to be that connection string so gif lib dot db dot URL.

Now this one is going to be a little longer because it is a connection string.

Just like you saw in hibernate basics this is going to leverage JDBC.

Remember that stands for Java Database Connectivity.

This is an H 2 database now here we're going to be using the TCP protocol.

TCP stands for Transmission Control Protocol.

And allows us to leverage network connectivity to a database server.

So, theoretically we could connect to this database from another machine

if we configured our ports to do so.

This is as opposed to using H2's file based mode.

I'm doing this for purposes of demonstration and

to show you that we can connect to a database with our application,

using tcp mode, as well as,

monitor the contents of the database through a web console that h2 offers.

I'll show you more about that in a few minutes.

So let's finish this connection string.

Okay this is going to go to a local host that's our own machine here.

That squiggly stands for the home directory on our machine.

Now you're going to want to make sure that the director you reference here

is a relative to your home directory.

So most likely your path from here to the end is going to be different

from mine unless your directory structure on your computer looks exactly like mine.

So I have a code directory and in there I have a screen cast directory.

And this project is gifLib.hibernate on my machine, and

I'm storing it in a data directory I'll call the database gifLib.

Now, because I just referenced the data directory that's within the root directory

of my project, well I better create that directory.

So, if you don't have a data directory on your local machine here,

you better go ahead and create that.

Let me show you exactly what you'd have to do.

I'll delete mine.

Just so you can see what it looks like, without the directory and

then, it's very simple.

You just right click the project New Directory, and stick data in there.

Now, you do not need to create a file named gif lib,

when our application tried to connect to the h2 database named giflib,

if a file does not exist in this location here, one will be created by h2 for you.

So I'll let h2 take care of that for us.

So again make sure that you have a data directory at the root of your project

in any case you have a data directory at the location specified here.

Okay two more properties to go.

We have a username gifLib.db.username I'm going

to use as a giflib.db.password I will leave blank.

Now, you could leave both of these blank, you could put a specific username and

password in there, you can do whatever you like here.

Just make sure that on the next step

you use the same password when firing up the web consul that you used here.

We'll see that in just a moment.

Now speaking of that H2 database server,

I want to show you how we can use the command line to start this

H2 database server that we'll be using for the rest of the course.

Using this server mode,

we can simultaneously allow our application to use the database, as well

as use a web console that I was referring to to monitor the database separately.

Now in order to do this you want to open a terminal

in the root directory of the project.

Now I'm just gonna use IntelliJ terminal here because when I open it it will come

right up in the root directory of the project.

Now all ready in the root directory of this project is this H2

jar file right there.

This is here not because we need it to integrate h2 into our application, but

rather we need it to quickly access the tools needed to

fire up an h2 database server.

So how do we use this jar file to fire up a database server?

Well, in the terminal here we can use the java command and

specify the jar file as the class path.

So the class path is going to be h2.

Blah blah blah jar, I just use the tab to auto complete that line.

And then the main class that we want to run is or

org.h2.tools .Server and then you'll just hit enter and what should happen

is a browser tab should open up with a console that looks like this.

This is the login screen so to speak of your database.

Now what you want to do here is with the database URL, you want to make sure this

value here matches exactly what you put in your app.properties file.

So that I can ensure that that's the case, I'm going to switch back to IntelliJ and

copy this whole value right here.

And paste it right here.

So with that value in there make sure you've entered the username and

password that you used in your properties file.

This is what I used SA and a blank password and I will click connect.

And now you have a database server running.

And note this database has no tables yet.

We'd see those listed here if we had tables.

It has no tables yet but

that will change soon as we run our job application with JPA annotated entities.

At that point, hibernates HBM to DDL tool will generate our database schema.

Assuming that in hibernate dot CFG dot XML, let me open that,

assuming that in here, we've used either the update create or

create drop property for hbm2ddl.auto