A dependency is a Java library that this project depends on.

While developing Java applications, you'll almost always be using other developers

libraries, in addition to your own.

So if you want to use code that isn't a part of the Java core library,

you'll need to add that library as a dependency.

Dependencies and Maven are declared inside this dependencies element.

With each dependency represented by its own dependency element.

Naming follows the GAV convention which stands for Group Artifact and Version.

Remember, this application is going to spy on a directory in our file system.

And alert us when files of a certain type are added to the directory.

Detecting the file's type can be a cumbersome process.

And at the very least, it's a problem that other developers have already tackled, so

let's use their code.

Hey, remember that Apache Tika library we found on Maven central in this last video?

Guess what?

We're gonna use it.

So let me click on this version, I'll copy this dependency element here.

And I'm going to paste it into my palm, under the dependencies element, great.

Now, when we write our code and compile with Maven,

we'll be able to reference the classes provided by Apache Tika.

Let's write our code now in app.java.

I'm gonna wipe out most of this class and start from scratch.

Okay, let's start with a couple import statements.

First, we're gonna import java.nio.file and

I'm gonna import all classes in that file package.

And this java.nio package stands for

Java's non-blocking input/output API, more on that in just a bit.

The next thing I wanna import is org.apache.tika.Tika; class.

Now, you'll notice that Intellige can't find this Apache package.

Though this won't be a problem for Maven when we compile,

my IDE will keep complaining.

To fix this and more fully utilize my IDE for coding,

I'll pop open the Maven Projects window here.

And then, I'll click that refresh icon.

After that, my IDE is happy as you can see.

Be sure to check out the options in your own IDE's Maven

tool window to see what's available.

But for this workshop, we'll stick with the command line for all Maven commands.

Okay, let's continue coding our class.

This class is called, public class App.

And I'm gonna drop two constants at the top of the class here for

the file type and the directory we want to watch.

So private static final String and I'll call it FILE_TYPE,

and I'll say text/csv files, cool.

And then, I'll do the same for the directory to watch

private static file String and all say DIR_TO_WATCH.

And also a /Users/Chris/Downloads and I made a tmp directory there.

You can change this to any empty folder on your own system, cool.

And then, I wanna public static void main method here, awesome.

Now ,the code we're gonna write here using the Java NIO, might look a little cryptic.

I'm certainly not asking you to have a complete understanding of how to use this

non-blocking input/output API provided by the Java core library.

Our work here is more about understanding how to package the project

into a distributable jar using Maven.

In any case, it's a nice opportunity for

us to look at Java features you may not have seen.

So we'll start by defining a path object that contains the directory to watch,

as well as a Tika object for detecting files.

So I say, path dir = Paths.get and then,

I'll say, (DIR_TO_WATCH), cool.

And I'll define a Tika object and call its default constructor.

Next, lets add our watch service which will allow us to spy on the directory, so

WatchService.

I'll just say watchService = FileSystems.getDefault.

It gets the current file system, newWatchService, cool.

And then, I'm going to register this watch service with a directory.

So dir.register(watchService,) and

I want to register it for events, for creating new files.

So I only wanna detect events for when new files are added to this directory.

So I'll say, ENTRY_CREATE.

Now, this is a constant that comes from a certain class.

So let's import that,

.StandardWatchEventKinds.ENTRY_CREATE;, cool.

Now, what you're probably going to see at this point are a bunch of warnings saying,

that you have on caught exceptions.

So I'm gonna do something here which I would normally do on a distributed Java

application.

But I'll do it here for purposes of brevity.

I'm just going to say throws Exception and that will silence the compiler, cool.

Now, we can move on.

Okay, let's start our event loop which will continually run until we receive

an invalid watch key.

So I'll define a WatchKey called key, and then, I'll define as do while loop.

while(key.reset());, this will loop as long as the key is valid.

Now, you'll see this little red squiggly here, until we assign key a value.

But we're gonna do that inside the loop.

Let's go ahead and do that.

So now, this watch key is an object that

represents the registration of our path object with the watch service.

When an event occurs, a key will be available through the watch service,

through a call to its take method.

So that's what I will assign this key variable, watchService.take().

Now, at this point in our code, we need to loop through any events that come through.

And instead of using a for loop here which we could do.

We'll use streams to access the events, we'll call the poll of events method and

examine the stream there.

So I'll say, key.pollEvents().stream().

And since, we only care about the create events for a certain file type.

Let's filter our stream().filter and that will accept an event object.

And it will return true, if we want the item to be included in our stream or

false, if we don't.

So in general, what we need to do here is return true when

the file type equals our constant FILE_TYPE, up here.

Looks like a misspelled it, FILE, there we go.

So we wanna return true, when the file associated with

this event is of this file type and false, otherwise.

So let's start with that code and work backwards.

So I will say, return FILE_TYPE.equals, and I'll say, (type).

Well, this must mean, we need a variable declared as type before this line of code,

let's do that.

How are we going to get that, well, String type = tika.,

this is where that library comes in handy.

(filename.toString()) but I don't have a filename yet,

so how am I gonna get the file name of the file associated with this event e?

Well, here's how you can do that.

We'll say, Path filename =, I'm gonna cast to

a path object to e.context();, just like that.

All right, now, you might get a warning like I am,

that Lambda Expressions are not supported it's language level.

Well, let's change the language level to eight in our IDE.

Okay, now that error is gone.

That's not needed for Maven but just needed for our IDE.

So now, we have a filtered stream, cool.

Now, what do we wanna do with each one of these events?

Let's use the forEach method to perform an action on each one of these events.

So we'll say, forEach and then an event will be the parameter.

And what do I wanna do, I'll do a single line here.

That way, I don't have to enclose it in curly braces.

I'll do System.out.println, now, I'll say printf.

And I'll save file found, and I'll drop the name of the file.

And then, I'll drop a new line there, cool.

And e.context()), will give me that filename.

Oops, don't need a semicolon because I haven't used the curly braces here,

Eexcellent.

Now, with our code in place,

we're ready to start running Maven commands from the terminal.

So next, we'll learn about Maven build life cycles.

And we'll begin to build our app through Maven commands.