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
Spark is a Micro-Framework that’s sole purpose is to get you up and running and rapidly developing web applications. After we discuss the project for the course, let’s go get it installed. It’s a breeze!
IntelliJ Update
At 3:10, Craig selects a 'Create directories for empty content roots automatically' option. This is no longer available or necessary in newer versions of IntelliJ IDEA because the IDE now handles content root directories dynamically. It automatically creates and manages them when needed, streamlining the project setup process without requiring manual configuration.
Gradle Dependency Fix
Due to changes with Gradle, you will need to use this:
implementation 'com.sparkjava:spark-core:2.3'
Instead of this:
compile 'com.sparkjava:spark-core:2.9.3'
Links:
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
I'm super excited to
introduce you to the web
0:00
application framework that we're gonna be
using for the rest of this course, Spark.
0:03
Now Spark is unfortunately in a bit of
name space collision in the Java world.
0:07
The Spark framework is not to be confused
with the database called Apache Spark.
0:12
It's unfortunate that they
share the same name and
0:18
it makes searching around
a little confusing at times.
0:20
So, keep this in mind as you
start navigating these parts.
0:23
The idea behind a microframework is
to keep things small, simple, and
0:27
clear and Spark does just that.
0:31
It is built for productivity and
design to get you up and running and
0:33
ready for
rapid application development in no time.
0:37
Part of the complaint of
Web frameworks in general,
0:42
is that the more sophisticated they get,
the more they bloat and swell.
0:44
There's usually tons of configuration, and
0:48
you have to learn a whole new environment
before you can even write a simple page.
0:50
Well microframeworks are not like that.
0:54
In the Ruby programming world,
0:56
a super tiny and
easy to use framework was created.
0:58
It's called Sinatra.
1:00
Now Spark and many other microframeworks
got its inspiration from Sinatra so
1:02
you might hear it being
called Sinatra based.
1:06
So get ready to start spreading
the news because this is awesome.
1:09
Okay, so
before we get this framework installed,
1:14
let's talk a bit about the project for
this course.
1:17
So the actual idea for
1:20
the creation of this course came
from one of your fellow classmates.
1:21
As you probably know, we always ask you
for feedback and ideas for future courses.
1:24
I usually get a direct message on Twitter,
something over email, and
1:29
we put these suggestions out for
you to vote on.
1:32
So one of your classmates shot me an email
saying, I'd love to learn Spark so
1:35
I can get a site up and running quickly.
1:38
And I thought that
sounded like a good idea.
1:40
And I turned that into a request, and
into something you could vote on.
1:42
So, check the teacher's notes for
more on the current voting system.
1:45
And you all voted it up and
1:49
we agreed that it made great sense to
have in our library, so here it is.
1:50
Well that got me thinking, why don't
we remove me, as the middle man and
1:54
just have a place where you
students can submit ideas yourself.
1:59
Why don't we just build an app?
2:02
And I thought,
that's a pretty simple web app.
2:03
And then I was like, why not just
use one of those microframeworks.
2:05
And then I was like, I'm writing a course
on Spark and I need a project and then.
2:09
I was like, wow sparkception.
2:15
So the project for this course, let's make
a site that takes ideas from students and
2:18
then allows voting.
2:23
Sound good?
2:24
Let's go get Spark installed.
2:25
Alright, so
2:27
let's create a new project in IntelliJ
IDEA and we'll make a great old project.
2:28
So do create new project and we'll
choose Gradle over here on the left, and
2:33
if Gradle's new to you, check the
teacher's notes for a quick intro to it.
2:38
Now we're going to use it because we're
going to use Spark as a dependency.
2:41
So if we were going to publish this, we'd
want something like this for the Groupid.
2:46
We'd want com Team Treehouse the reverse,
and we'll just call this Courses.
2:52
And for the artifact ID we want
something like Course Ideas.
3:00
Remember, this is what
the published jar would be named.
3:05
Let's go ahead and choose Next.
3:08
And let's choose create directories for
3:11
the empty content roots automatically
that way it gonna be there.
3:13
Awesome.
3:18
Okay.
3:23
So now the file, directories all there,
let's open up the source.
3:24
Main, Java and let's add a new class here.
3:28
New java class, and the class name is,
3:33
let's do com.team
treehouse.courses and for
3:37
simplicity's sake let's just call it Main.
3:43
Okay.
3:47
And in this file we'll make
our standard main call.
3:48
I want you to see how
simple Spark actually is
3:53
to get the prototype up and running.
3:56
So we'll do the public static void main
and press tab, it builds it out for us.
3:57
Okay, so now we're ready.
4:02
So first let's add our dependency.
4:04
So the site's called sparkjava.com,
I have it open over here.
4:06
So sparkjava.com, and
up here there's this Download tab.
4:10
So over here it tells us how to get it.
4:14
So the group ID is com.sparkjava,
and then it's spark-core and 2.3.
4:16
So let's go to build.gradle and
in the dependencies section here,
4:22
we'll say compile.
4:27
And we'll use the shorthand, we'll say,
4:28
com.sparkjava, and
then spark-core, and then 2.3.
4:32
Let's go ahead and click apply
the suggestion there that way when we ship
4:43
this project, if we ever do,
Gradle will be shipped with it.
4:48
Okay, so let's flip over to
the Gradle tool window, and
4:53
in here we'll press this
refresh all Gradle projects.
4:56
And bam, just like that, we have Spark and
all of its dependencies.
5:04
So here's Spark and here's Jetty.
5:09
And Jetty is the embedded
web server that's used.
5:12
So, what do you say we flip
back to the documentation and
5:15
take a quick look at the demo
under the documentation?
5:18
So let's switch back.
5:20
Let's go over here to documentation.
5:22
And it says right here
this is what we wanna do.
5:25
Let's just grab this line because
basically we have that same thing in our
5:27
file, right.
5:30
So I'm just gonna grab this and
I'm gonna flip back over and
5:31
in our main Java we'll add that line.
5:35
And let's see what happens.
5:37
Let's close this Gradle project,
get it out of the way.
5:40
Okay.
5:46
So what does it say here?
5:50
It says, we need to do
the static import of Spark.get.
5:52
See it saw that.
5:56
So again it's statically importing,
5:58
there is a get method here and
it's off of the spark class.
5:59
Cool, if it doesn't like your
lambda syntax, by default,
6:05
some of the IDEs are set to 6 by default.
6:10
But go ahead and set it to 8.
6:13
Spark really shines when we're
using the lambda syntax.
6:15
And if lambda syntax is new to you,
check the teacher's notes.
6:18
But basically what it's saying here is
6:21
called the static method get
with the path name /hello.
6:26
Anything that's matching /hello,
and then it takes a lambda.
6:29
In the lambda here,
there's two parameters that are taken.
6:34
It's the req which is request and
res which is response.
6:37
And then it returns,
6:42
remember the [INAUDIBLE] the first
thing here returns hello world.
6:44
So, this is a function that
will return hello world and
6:49
it's passed a request and a response.
6:51
This is,
what this lambda here is know as a route.
6:54
It's actually a functional interface for
the route object.
6:57
So what this means is that when an http
get request is made to our web server
7:01
that is looking for the uri or the uniform
resource identifier of slash hello.
7:07
Our function will be called and
hello world will be returned.
7:14
Now we'll touch a bit more
on these requests and
7:17
response variables in upcoming videos,
but for now let's just return that text.
7:20
Could that really be all it took
to get things up and running?
7:24
Well, let's give it a go, what do you say?
7:28
So, let's choose run and we'll choose Run
for the menu here, we will choose Main.
7:30
Okay, so
it says that Spark has ignited and
7:40
it says that it's listening
on port 0.0.0:4567,
7:43
so 0.0.0 is a code name for
all IP addresses on your current machine.
7:48
So you can access that URL in
the URL bar of your browser,
7:55
or you could just use another nickname,
which is localhost.
8:00
So let's do that.
8:02
So let's switch over to a new window here,
and we'll say localhost.
8:03
Well, actually, first let's say that
we're gonna talk HTTP to localhost
8:09
and I'm going to do a colon and
that's for the port which was port 4567.
8:16
Now by default it listens on a different
port but we're specifically saying this.
8:22
By default,
you don't need to specify the port.
8:25
The port is 80 but we're specifying here
4567 and that's how you specify the port.
8:28
Okay.
So then, let's look for /hello.
8:33
Sound good, right?
8:37
Whoa, look at that.
8:40
A website.
8:41
So, wait a second.
8:43
All I need to do if I want another
page is just add a new route, right?
8:45
So I know that we want a page when
someone just comes to our site.
8:49
So that path is just /, right?
8:51
So let's do that.
8:54
Let's add Over here we'll just come in and
say get.
8:55
If anybody comes to
just slash then we add,
8:58
again, we'll add a request and a response.
9:04
And let's make it say welcome students.
9:10
Cool, awesome.
9:17
And I save it, and if I come back over
here and I just do the slash, that should.
9:18
What?
9:25
You know what?
9:27
I forgot to restart the server.
9:29
The server is running.
9:33
So there's this button here.
9:34
This restarts.
9:35
This will stop and re-run main.
9:35
So notice that main is still running.
9:37
So let's stop it and re-run it and
now let's go see if the slash is there.
9:39
Welcome students.
9:47
There it is.
9:48
Woah.
9:48
Bam.
9:50
You just built a web application.
9:50
It's for
sure gonna get more challenging, but
9:52
you just tackled that in like
five minutes or something.
9:54
That's pretty amazing right?
9:57
Micro-frameworks for the win.
9:58
Also, did you see how
clear that syntax was?
10:00
Doesn't get much more clearer than that,
does it?
10:03
But forgetting to restart the server is
going to bite you, I promise it will.
10:06
You'll make a change and you won't see
it and you change it some more and
10:10
you'll still not see it and
then do a facepalm like this.
10:13
And you'll realize that it's because
you forgot to reset the server.
10:16
It's actually a good thing to remember
that the server's constantly running,
10:19
just waiting for any number of
requests to come in from wherever.
10:23
Even though our request response loop for
that one request was finished,
10:26
the server's still just sitting there
waiting to respond to the next request.
10:29
Well, let's see if we can make
this app a little more dynamic.
10:33
Why don't we make a site
that's more personal.
10:36
Welcome, students isn't exactly
as personable as we can make it.
10:39
Why don't we prompt for the user's name?
10:43
Actually I think we have a little work on
making things look a little bit prettier.
10:45
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