I'm super excited to introduce you to the web

application framework that we're gonna be using for the rest of this course, Spark.

Now Spark is unfortunately in a bit of name space collision in the Java world.

The Spark framework is not to be confused with the database called Apache Spark.

It's unfortunate that they share the same name and

it makes searching around a little confusing at times.

So, keep this in mind as you start navigating these parts.

The idea behind a microframework is to keep things small, simple, and

clear and Spark does just that.

It is built for productivity and design to get you up and running and

ready for rapid application development in no time.

Part of the complaint of Web frameworks in general,

is that the more sophisticated they get, the more they bloat and swell.

There's usually tons of configuration, and

you have to learn a whole new environment before you can even write a simple page.

Well microframeworks are not like that.

In the Ruby programming world,

a super tiny and easy to use framework was created.

It's called Sinatra.

Now Spark and many other microframeworks got it's inspiration from Sinatra so

you might hear it being called Sinatra based.

So get ready to start spreading the news because this is awesome.

Okay, so before we get this framework installed,

let's talk a bit about the project for this course.

So the actual idea for

the creation of this course came from one of your fellow classmates.

As you probably know, we always ask you for feedback and ideas for future courses.

I usually get a direct message on Twitter, something over email, and

we put these suggestions out for you to vote on.

So one of your classmates shot me an email saying, I'd love to learn Spark so

I can get a site up and running quickly.

And I thought that sounded like a good idea.

And I turned that into a request, and into something you could vote on.

So, check the teacher's notes for more on the current voting system.

And you all voted it up and

we agreed that it made great sense to have in our library, so here it is.

Well that got me thinking, why don't we remove me, as the middle man and

just have a place where you students can submit ideas yourself.

Why don't we just build an app?

And I thought, that's a pretty simple web app.

And then I was like, why not just use one of those microframeworks.

And then I was like, I'm writing a course on Spark and I need a project and then.

I was like, wow sparkception.

So the project for this course, let's make a site that takes ideas from students and

then allows voting.

Sound good?

Let's go get Spark installed.

Alright, so

let's create a new project in IntelliJ IDEA and we'll make a great old project.

So do create new project And we'll choose Gradle over here on the left, and

if Gradle's new to you, check the teacher's notes for a quick intro to it.

Now we're going to use it because we're going to use Spark as a dependency.

So if we were going to publish this, we'd want something like this for the Groupid.

We'd want com Team Treehouse the reverse, and we'll just call this Courses.

And for the artifact ID we want something like Course Ideas.

Remember, this is what the published jar would be named.

Let's go ahead and choose Next.

And let's choose create directories for

the empty content roots automatically that way it gonna be there.

Awesome.

Okay.

So now the file, directories all there, let's open up the source.

Main, Java And let's add a new class here.

New java class, and the class name is,

let's do come dot team treehouse .courses and for

simplicity's sake let's just call it me.

Okay.

And in this file we'll make our standard main call.

I want you to see how simple Spark actually is

to get the prototype up and running.

So we'll do the public static void main and press tab, it builds it out for us.

Okay, so now we're ready.

So first let's add our dependency.

So the site's called sparkjava.com, I have it open over here.

So sparkjava.com, and up here there's this Download tab.

So over here it tells us how to get it.

So the group ID is com.sparkjava, and then it's spark-core and 2.3.

So let's go to build.gradle And in the dependencies section here,

we'll say compile.

And we'll use the shorthand, we'll say,

com.sparkjava, and then spark-core, and then 2.3.

Let's go ahead and click apply the suggestion there that way when we ship

this project, if we ever do, Gradle will be shipped with it.

Okay, so let's flip over to the Gradle tool window, and

in here we'll press this refresh all Gradle projects.

And bam, just like that, we have Spark and all of its dependencies.

So here's Spark and here's Jetty.

And Jetty is the embedded web server that's used.

So, what do you say we flip back to the documentation and

take a quick look at the demo under the documentation?

So let's switch back.

Let's go over here to documentation.

And it says right here this is what we wanna do.

Let's just grab this line because basically we have that same thing in our

file, right.

So I'm just gonna grab this and I'm gonna flip back over and

in our main Java we'll add that line.

And let's see what happens.

Let's close this Gradle project, get it out of the way.

Okay.

So what does it say here?

It says, we need to do the static import of Spark.get.

See it saw that.

So again it's statically importing,

there is a get method here and it's off of the spark class.

Cool, if it doesn't like your lambda syntax, by default,

some of the ides are set to 6 by default.

But go ahead and set it to 8.

Spark really shines when we're using the lambda syntax.

And if lambda syntax is new to you, check the teacher's notes.

But basically what it's saying here is

called the static method get with the path name /hello.

Anything that's matching /hello, and then it takes a lambda.

In the lambda here, there's two parameters that are taken.

It's the Rec which is request and res which is response.

And then it returns,

remember the [INAUDIBLE] the first thing here returns hello world.

So, this is a function that will return hello world and

its passed a request and a response.

This is, what this lambda here is know as a route.

It's actually a functional interface for the route object.

So what this means is that when an http get request is made to our web server

that is looking for the uri or the uniform resource identifier of slash hello.

Our function will be called and hello world will be returned.

Now we'll touch a bit more on these requests and

response variables in upcoming videos, but for now let's just return that text.

Could that really be all it took to get things up and running?

Well, let's give it a go, what do you say?

So, let's choose run and we'll choose Run for the menu here, we will choose Main.

Okay, so it says that Spark has ignited and

it says that it's listening on port 0.0.0:4567,

so 0.0.0 is a code name for all IP addresses on your current machine.

So you can access that URL in the URL bar of your browser,

or you could just use another nickname, which is localhost.

So let's do that.

So let's switch over to a new window here, and we'll say localhost.

Well, actually, first let's say that we're gonna talk HTTP to localhost

and I'm going to do a colon and that's for the port which was port 4567.

Now by default it listens on a different port but we're specifically saying this.

By default, you don't need to specify the port.

The port is 80 but we're specifying here 4567 and that's how you specify the port.

Okay. So then, let's look for /hello.

Sound good, right?

Whoa, look at that.

A website.

So, wait a second.

All I need to do if I want another page is just add a new route, right?

So I know that we want a page when someone just comes to our site.

So that path is just /, right?

So let's do that.

Let's add Over here we'll just come in and say get.

If anybody comes to just slash then we add,

again, we'll add a request and a response.

And let's make it say welcome students.

Cool, awesome.

And I save it, and if I come back over here and I just do the slash, that should.

What?

You know what?

I forgot to restart the server.

The server is running.

So there's this button here.

This restarts.

This will stop and re-run main.

So notice that main is still running.

So let's stop it and re-run it and now let's go see if the slash is there.

Welcome students.

There it is.

Woah.

Bam.

You just built a web application.

It's for sure gonna get more challenging, but

you just tackled that in like five minutes or something.

That's pretty amazing right?

Micro-frameworks for the win.

Also, did you see how clear that syntax was?

Doesn't get much more clearer than that, does it?

But forgetting to restart the server is going to bite you, I promise it will.

You'll make a change and you won't see it and you change it some more and

you'll still not see it and then do a facepalm like this.

And you'll realize that it's because you forgot to reset the server.

It's actually a good thing to remember that the server's constantly running,

just waiting for any number of requests to come in from wherever.

Even though our request response loop for that one request was finished,

the server's still just sitting there waiting to respond to the next request.

Well, let's see if we can make this app a little more dynamic.

Why don't we make a site that's more personal.

Welcome, students isn't exactly as personable as we can make it.

Why don't we prompt for the user's name?

Actually I think we have a little work on making things look a little bit prettier.