After getting a decent grasp of how the libraries will be using our bundled as jar

files, let's now turn to how and where we're going to obtain those libraries.

And how we'll get them into the class path.

Now, we could just do a simple web search for a specific jar file we want to use,

download it, then use an IDE option to add it to the class path.

If you search for instructions on how to do this for

a specific library, the Spring Web library, for example, you might be

surprised to find little guidance on where to manually download this .jar file.

Even trickier is that if you were to download a .jar file, and

successfully add it to the class path, you might find that the .jar

file you downloaded depends on yet another .jar file.

Now you have to do it all over again.

And probably not just once, but likely many more times.

And if you ever wanted to share your project with other developers,

it'd have to go through the same process.

If that isn't enough, what happens when you update your application and

some libraries are left behind while new libraries are added?

Because of this, most developers use special tools for

managing what are called dependencies.

Dependencies of a project are libraries that a project depends on

in order to function.

There are a couple big names out there in dependency management tools,

namely Maven and Gradle.

We're going to use Gradle to manage our dependencies in this course.

Fortunately this tool is integrated with IntelliJ, so

you should be able to use it without installing Gradle separately.

Using what's called a Gradle build file, we'll be able to list

the names of the libraries that we want to incorporate into our project.

Then, with a click of a button, Gradle will download all of the .jar files for

the libraries we listed and even the libraries our listed ones depend on.

It's much easier, quicker, and more reliable than the manual download method.

I don't know about you, but I'm itching to code a little bit.

Remember how we plan on building an animated gif library called gif lib?

Let's get that project created in IntelliJ and see Gradle in action.

To get started let's open IntelliJ and create a new project.

I'll choose Create New Project from the screen that pops up here.

From the left hand side, we'll choose Gradle.

And with Java selected, we'll click Next.

The GroupId field should be formatted like a root package name.

I'll use com.teamtreehouse.

The ArtifactId should be an identifier or project name.

I'll use giflib.

And then we shall click Next.

In the next window, we'll accept all the defaults.

Notice that the recommended option here is to use the default Gradle wrapper,

which means Gradle as a program will be included as part of our project.

Click Next and verify the name and location of your project.

When you're ready to create it, click Finish.

Let's expand our project, and take a look at what we have.

Know that within a few moments, you'll see your project directory expand as

the Gradle tool is downloaded and added to our project directory.

The first file we'll look at, is the .iml file.

As you may know, IntelliJ uses .iml files to manage module settings.

Though we're seeing, we won't actually edit this file, so

I will go ahead and close it.

The settings.gradle file simply contains our root project

name which we had entered as giflib.

We also will not edit this file in this course.

So, I'll go ahead and close that one too.

The one file we will concern ourselves with is the build.gradle file,

this is the file I referenced in a previous video where we can list our

projects dependencies and Gradle will download them for us.

Let's check out a couple of things in the build file.

I'll go ahead and hide the tip that's come up in IntelliJ.

At the top, you see the group inversion we specified when creating the project.

For now, suffice it to say, that the group inversion allow repositories such as

the one we'll be using to get our dependencies

to group related libraries together and track versions.

Though I'll leave it alone, you can change this at any time you like.

The apply plug-in line tells Gradle to

add pre-defined functionality when using Gradle to build our project.

This particular functionality has been given the short name Java.

The repository's blog allows us to define one or

more locations where Gradle should look for the libraries we list.

We'll use one of the largest public dependency repositories called

mavenCentral.

Finally, we see now where we'll actually list the libraries that we'll need.

It's called, quite intuitively, the dependencies block.

In the next video we'll replace what's listed and see Gradle in action.