Let's start by talking about how things look a little different when incorporating

hibernate into spring,

as opposed to using hibernate in a standard command line application.

First, recall that in hibernate basics we created a hibernate session factory

which encapsulates all the mapping data between our entities.

Remember, those are our model classes or pojo's and a database.

In this course, instead of the hibernate SessionFactory,

we'll use the spring framework's LocalSessionFactoryBean.

This is because a spring container, or application context

will be managing the SessionFactory, creating it as a Spring bean at runtime.

Next in Spring, we'll configure the data source separately using a third party

library from Apache called DBCP, which stands for Database Connection Pooling.

In a nutshell, connection pooling allows the application to keep alive a specified

number of database connections, and then reuse them when they're needed.

This gives us a boost in performance,

since database connections take some time to establish.

Also related to the data source, if you recall in Hibernate basics,

we let Hibernate grab the configuration settings for our data source.

In this course, we'll instead configure the data source as a Spring bean,

kind of like the LocalSessionFactoryBean.

And this is where we'll specify things like the connection URL,

the database driver that Hibernate should use, which is H2 in our case.

In addition to these three things,

you'll see plenty more that will add to this application.

We'll explore application design principles as they apply

to separating the components into web components like Spring controllers.

Data access components call data access objects, and

a component that sits between those two called services.

Next, we'll review the application that we're going to be working with

during this course.