Maven, like other build tools such as Gradle,

has opinions on what a Java project should look like.

And though this can be configured to your heart's desire,

let's take a look at the standard directory structure of a Maven project.

Actually, I think the best way to go about this would be to use Maven

to create a project.

Now I realize that if you're a Java developer you likely have your favorite

IDE, be it IntelliJ, Eclipse, NetBeans, or what have you.

However, in this workshop, in order to maintain our focus on Maven, even though

I'll do some coding in IntelliJ, I'll use the terminal to run all Maven commands.

But rest assured that all major IDEs have nice plugins and support for Maven.

So there are convenient menu options for everything we'll do on the command line.

Creating Maven projects is based on the concept of an archetype.

Think of an archetype as a predefined template,

like a blueprint from which we can generate projects.

So let's use our terminal here and get started.

The first thing I'll do is change directories to the parent of where I want

my project to be.

For me, that's in Code/screencasts, excellent.

Next, to generate the project we'll use the Maven command.

That's abbreviated mvn followed by the archetype plugins, archetype.

The archetype plugins generate goal and the -B option.

More about plugins and goals later on.

That -B option is for batch mode.

It tells the plugin not to ask questions along the way.

We'll specify all our config options in this command.

And what are those config options?

Well, they're system properties set for the running of Maven,

using the -D option to define system properties.

So we'll specify the groupId

as com.teamtreehouse and

the artifactId as file-spy.

I'll tell you more about the project in a moment.

The group and artifact IDs help categorize and identify your project,

which is the main form of organization of repositories like the ever popular

Maven Central.

Now this project will be creating in this workshop will be a console application

that spies on a directory,

displaying messages in the console when files of a certain type are added.

We'll get to the code much later on.

Okay, after pressing enter to run the command, Maven will generate a Java Maven

project with the standard directory structure and relevant assets.

On my machine, I have installed a command line tool called tree

that's super useful for displaying directory trees in the terminal.

I've put some info in the teacher's notes for

installing tree in case you're interested.

So if I change directories to file-spy and run the tree command,

you'll see the directory structure of the generated project right here.

If you've done work in Gradle, you are familiar with this structure.

In any case, inside our project's root directory,

we have a source directory containing main and test directories.

Each of those contains a java directory, which serves as the root directory for

any source code in the main directory or test code in the test directory.

Inside those java directories we have directories for our root package that was

created when we specified the group ID as com.teamtreehouse.

If you have any resources like properties files, they'll be in the main/resources

directory and the test/resources directory, like this.

So let's make those directories.

Src/test/resources.

And with resources, your directory structure will look like this.

You'll have a resources directory under main and a resources directory under test.

If you haven't used properties files in the past,

then don't worry about this resources directory.

Now, once code is compiled, you'll find the .class

files in a directory name target located in the projects root directory.

So right under the root with pom.xml and source directory,

you'll see another directory called target after you compile your code.

And that's all there is to a Maven project.

Well, just kidding.

Not even close.

See this measly little file that I skipped over in the project, the pom.xml?

Turns out that this is everything in Maven.

Why don't you take a quick breather before we dive into the all-important pom,

which is a one-stop configuration file for your entire Maven project.