- Getting Started 5:55
- Introducing Spring Data REST 6:03
- Entities and Repositories Review 9:28
- Abstract Classes 6:48
- Populating and Relationships 15:39
- Paging 7:12
- Exploring Your API With New Tools - Postman 7:55
- Exploring Your API With New Tools - HAL Browser 3:58
- Versioning 8:52
- Validation 8:31
- Adding Users 11:51
- Adding Authentication 10:35
- Authorizing Deletions 6:56
- Events 7:57
- Wrapping Up 1:18
Preview
Video Player
00:00
00:00
Getting Started
5:55Let's talk about the project we are going to build in this workshop.
[MUSIC]
0:00
Hello and welcome.
0:04
I'm Craig, and I'm a developer.
0:06
In this course, we're going to
build a RESTful API using Spring.
0:07
It's going to support HATEOAS,
0:11
or Hypermedia as the Engine
of Application State.
0:13
It's gonna integrate with Spring data and
Spring security, and
0:16
provide self-documenting schema
generation, almost seamlessly.
0:19
Now, word of warning.
0:24
You're probably going to get your mind
blown by how much you can do with such
0:25
little code, and
that's the beauty of Spring Boot at work.
0:28
But, before we take off,
0:32
please take a moment to check out the
teacher's notes and make sure that you've
0:33
completed the prerequisites, just to make
sure we're talking the same language.
0:36
Don't forget to check
the notes on each video.
0:40
I usually drop helpful hints, tricks,
and knowledge nuggets down there for
0:42
your consumption.
0:46
And, always remember the speed controls.
0:47
Feel free to speed me up or
slow me way down.
0:49
I don't mind at all.
0:53
So let's talk about the project
that we're gonna build together.
0:54
Now first off, imagine, if you will,
that we work on an international team
0:57
that produces applications as requested
by clients, you know, like an agency.
1:01
So we have a very well established
client who has come to us and
1:05
asked us to build a course review system.
1:09
They want a single-page application
website, an iPhone and Android app, and
1:11
of course, they want it yesterday, and our
sales team told them it'd be no problem.
1:15
So, here we go.
1:20
So first off, a course review system
is reviewing online courses, you know,
1:22
like this one you're watching here.
1:25
It'll be used to gather public
opinion on those courses, so
1:27
people can make an educated
decision on what they should watch.
1:30
Our team huddled together and
1:33
decided that we should tackle building
out all the prototypes at the same time.
1:34
The approach that we came up with to
do this joint team rapid development
1:38
is to produce a REST API,
that all clients, you know,
1:42
the site and the different phone and
tablet apps can consume.
1:44
So you've landed on the API creation team,
arguably,
1:47
the most important team on getting
this project launched, so good job.
1:50
So together,
1:54
we're going to build an API that allows
anyone to submit courses to it, then we'll
1:55
also allow anyone to add reviews about
the courses that have been submitted.
1:59
So, for instance,
if someone wanted to add a review
2:03
to this workshop that you're watching
right now, they'd do something like this.
2:06
So we have the client let us
know the title and the URL.
2:09
Our project manager, her name's Hannah,
2:11
has assured us that that should
be enough to get us started.
2:14
And now that this course that you
are currently watching exists already,
2:17
we could have people submit reviews to it.
2:20
Now I know you haven't seen this yet, so
these probably won't make too much sense,
2:22
but here are some reviews it's gotten.
2:25
So this has a rating of four
out of a possible five and
2:27
a more detailed description, and
someone else submitted this one.
2:29
That's not how you pronounce HATEOAS!
2:33
Well, hatters gonna hat, I guess.
2:35
So side note, if you feel like
you're having deja vu, don't worry,
2:37
you might have seen this project used
in another one of our courses here on
2:40
Treehouse, on a different web framework.
2:43
We're producing several workshops and
courses in various other frameworks so you
2:45
can compare and contrast their approaches
to building the same end product.
2:49
So the relationship is one
course to many reviews.
2:53
One to many.
2:57
We'll also add the ability to walk
from the review back to the course.
2:59
So that's many to one, right,
from the perspective of the review.
3:03
It's many reviews to one course.
3:06
Now not only will our resource
endpoints support all the HTTP verbs,
3:09
it will also be hypermedia driven.
3:14
It will be HATEOAS compliant.
3:16
Again, that's the Hypermedia as
the Engine of Application State.
3:18
It's gonna be discoverable.
3:21
Someone can make a request, and our API
will produce a list of all of its defined
3:22
relationships so that it can see
what other actions are possible and
3:27
make a new request to
other related resources.
3:31
For instance,
when looking at a specific review,
3:34
it would have a relation link
back to the course resource.
3:36
Now with the skills that you've picked
up thus far, you could definitely build
3:40
a Spring MVC application that
took care of all of this, right?
3:43
For example, we could build out our
CourseController, and then we'd write some
3:46
handlers, and we could have some code
that respond to an HTTP getRequest
3:50
to the courses endpoint, which would
return a list of all available courses.
3:56
Yeah, we'd also need to convert
those Java objects to JSON,
3:59
or JavaScript Object Notation,
you know, the standard, so
4:03
that our clients can consume them.
4:05
And we'd also add one that creates a new
course when the courses collection
4:07
is posted to.
4:11
We'll have to parse the JSON that was sent
in and there's plenty of great tools for
4:12
that, many embedded in
the Spring framework.
4:16
Now, as you've probably experienced
from working with Spring,
4:18
it's the framework that keeps on giving.
4:21
Since this is a pretty repetitive task,
4:23
there are a lot of tools in Spring
that help ease these monotonous tasks.
4:25
For instance,
4:30
there's an annotation that allows you to
mark a controller as a REST controller.
4:30
It is, as you might expect.
4:34
So now, by default, you can return domain
objects and they will be converted to
4:36
JSON, using a tool included in your
Spring installation called Jackson.
4:41
We'll take a look at that here in a bit.
4:45
So that's great, but still, those
controllers are probably going to end up
4:47
looking a lot like each other, right?
4:50
I mean, just about every application
you can think of would work
4:53
pretty much like this, wouldn't it?
4:55
List of stuff,
get the details of the stuff,
4:57
add more stuff, add some stuff that's
related to that stuff, delete some stuff.
4:59
Sure, why not.
5:03
That's pretty repetitive, and believe me,
code like this actually exists, and
5:05
you'll encounter it all over
the place in all sorts of frameworks.
5:09
REST API Creation is usually
a repetitive error prone task, and
5:12
when you introduce the concept
of resource linking,
5:15
it quickly starts to become
overwhelming in complexity.
5:18
There's so much to remember!
5:22
What standard should I adhere to?
5:24
There's got to be a better way, right?
5:26
I mean,
if it's all doing the same process,
5:28
which is basically just exposing your data
model to a client in the same format,
5:30
why should we developers have to
write that over and over again?
5:34
I mean, we have better stuff to do.
5:38
We've got to change the world
with our awesome app.
5:39
Now, what if I told you that
Spring developers agreed with that
5:41
thought process and
created a way to make sure that you
5:44
actually don't even have to write
the controller piece at all.
5:47
Wouldn't that be awesome?
5:50
Well you've come to the right workshop,
my friend.
5:51
Sit tight, here it comes.
5:53