Preview

Start a free Courses trial
to watch this video

Sign up for Treehouse

A First Look at Our Todo Project

5:36 with Chris Ramacciotti

This video introduces you to the project we'll be working through during the workshop. It's a simple task management app called TodoToday.

Teacher's Notes
Video Transcript
Downloads

Query Methods with Spring Data JPA

You can add to CRUD functionality in a Spring Data JPA interface by writing intuitive method stubs. For example, if you have a repository for Contact objects that include a persisted email field, you could write a method that queries the datastore for contacts given a certain email address as follows:

public class ContactDao extends CrudRepository<Contact,Long> {
  Contact findByEmail(String email);
}

For more on query method options, check the Spring docs: http://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.query-methods

Git Command to Sync Your Code to the Start of this Video

git checkout -f v2

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/todotoday

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/todotoday.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 Video 4, you'd use the following:

git checkout -f v4

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.

Before we dive into user authentication let's get familiar with 0:00

the project we're working with. 0:03

With the Gradle tool window open I'm going to run my bootRun task 0:05

to fire up my application. 0:09

We'll wait for all of our code to compile, looks good and the spring app, 0:12

as you see spring is the library we're using here, has now successfully started. 0:16

So let's switch to Chrome and navigate to the home page. 0:21

localhost. 0:26

There it is right there. 0:27

Now this project is called ToDo Today, and is a simple task management application. 0:28

Currently tasks are global, so that anyone who visits our app, 0:33

sees the same tasks, and anyone can create a new task, or 0:38

mark existing tasks as complete, or unmark them as complete. 0:42

The application will show the same tasks and status to everyone. 0:48

And notice that when I first pulled up the app, there was no login page. 0:51

We want to change that. 0:55

Our goal in this workshop is to have user specific tasks and 0:56

require each user to fully log in, or authenticate, before proceeding. 1:00

Let's switch back to IntelliJ and check out our starting point for code. 1:06

I'm going to collapse my run panel here. 1:11

So this application is coded using a software stack that you should be 1:15

familiar with. 1:18

I have an H2 database with Hibernate as the ORM. 1:19

Let's take a peek at the data config class. 1:23

So in our main package here, com.teamtreehouse.todotoday, 1:26

we've got a bunch of other subpackages here. 1:30

In the config package, you'll find the DataConfig class. 1:33

You'll notice here that I've used this properties file for 1:37

all hibernate properties, and 1:40

I've loaded those properties into an autowired spring environment variable. 1:42

And I accomplish that handy task using springs property source annotation, 1:47

a handy shortcut for sure. 1:52

And you could just as easily have put hibernate properties into 1:55

a hibernate.cfg.xml file, as we've done in previous hibernate courses in our library. 1:58

There is one annotation here that I definitely want to point out, 2:05

which explains why I'm configuring a LocalContainerEntityManagerFactoryBean 2:08

instead of a LocalSessionFactoryBean, as you've seen on Treehouse previously. 2:14

The reason for this change is because in this app, 2:19

I'm using what are called Spring data JPA repositories. 2:21

Which explains the annotation that I wanted to point out 2:25

EnableJpaRepositories on the class there. 2:28

Now our application uses the service DAO pattern and 2:33

you can see that because I have these DAO and service packages in the project. 2:36

But what we can do is have Spring Data generate our DAO implementations 2:42

by using smart method naming. 2:47

I'll open the task DAO to show you what I mean. 2:50

You'll notice that I've applied a repository annotation to the interface 2:54

which isn't what we've done in previous courses. 2:58

Previously we anticipated the implementation and not the interface. 3:00

But you'll also notice here that I'm extending the CrudRepository interface 3:05

which comes from the Spring Data library. 3:10

When you do these things, and you've enabled JPA repositories like I did in 3:12

the DataConfig class, Spring Data will generate the implementing classes for you. 3:17

And all you have to do is write interface methods that you'd like to be implemented 3:22

that aren't included in the crowd repository interface, and 3:27

Spring Data does the rest for you. 3:31

That is Spring Data, upon application boot, 3:33

will generate a class that implements this task DAO interface. 3:36

Now I mentioned something about smart method naming. 3:43

Now Spring Data would know by the method named, say, 3:46

find by description, that its implementation that it generates needs to 3:49

return a single task object that matches the description passed. 3:53

In Spring Data these are called query methods. 3:58

Check the teacher's notes for 4:01

more information on what your options are with query methods. 4:02

Now the last thing I wanna point out is that I've included a file name import.sql. 4:06

You'll find that in the resources directory. 4:10

So let me open that. 4:13

This file will be the source of our initial data that we're loading into 4:16

the database. 4:19

Currently I've configured hibernate.hbm2ddl tool to destroy and 4:20

recreate our application on boot. 4:23

And you can see that by opening the application.properties file. 4:25

Here the hbm2ddl tool is set to create-drop. 4:29

Cool let me go back to import.sql. 4:35

Now this import.sql file will ensure that initial 4:38

data will be loaded into the database when we boot our application. 4:42

Okay, so that wraps up our first look at to do today. 4:48

And just so our fingers don't get too itchy for coding, let's go ahead and 4:51

add spring security as a dependency in the Gradle build file. 4:54

So let me open build that Gradle. 4:58

And this dependency will be a compile time dependency, so 5:02

let me add it to this group here even though order doesn't really 5:06

matter, org.springframework 5:10

.boot:spring-boot-starter-security. 5:15

Now, I'll use the Gradle tool window to refresh any dependencies, so 5:22

that everything is downloaded and added to the class path. 5:26

Next we'll start coding the entities we'll need to implement authentication. 5:31

You need to sign up for Treehouse in order to download course files.

Sign up