CODEWITHSUNDEEP
javaspring-bootspring-integration
amkz
amkz

Reputation: 588

How to monitor folder/directory in spring?

I wan't to write Spring Boot Application in spring which will be monitoring directory in windows, and when I change sub folder or add new one or delete existing one I wanna get information about that.

How can i do that? I have read this one: http://docs.spring.io/spring-integration/reference/html/files.html and each result under 'spring file watcher' in google, but I can't find solution...

Do you have a good article or example with something like this? I wan't it to like like this:

@SpringBootApplication
@EnableIntegration
public class SpringApp{

    public static void main(String[] args) {
        SpringApplication.run(SpringApp.class, args);
    }

    @Bean
    public WatchService watcherService() {
        ...//define WatchService here
    }
}

Regards

Upvotes: 19

Views: 49322

Answers (8)

catch32
catch32

Reputation: 18612

From Java 7 there is WatchService - it will be the best solution.

Spring configuration could be like the following:

@Slf4j
@Configuration
public class MonitoringConfig {

    @Value("${monitoring-folder}")
    private String folderPath;

    @Bean
    public WatchService watchService() {
        log.debug("MONITORING_FOLDER: {}", folderPath);
        WatchService watchService = null;
        try {
            watchService = FileSystems.getDefault().newWatchService();
            Path path = Paths.get(folderPath);

            if (!Files.isDirectory(path)) {
                throw new RuntimeException("incorrect monitoring folder: " + path);
            }

            path.register(
                    watchService,
                    StandardWatchEventKinds.ENTRY_DELETE,
                    StandardWatchEventKinds.ENTRY_MODIFY,
                    StandardWatchEventKinds.ENTRY_CREATE
            );
        } catch (IOException e) {
            log.error("exception for watch service creation:", e);
        }
        return watchService;
    }
}

And Bean for launching monitoring itself:

@Slf4j
@Service
@AllArgsConstructor
public class MonitoringServiceImpl {

    private final WatchService watchService;

    @Async
    @PostConstruct
    public void launchMonitoring() {
        log.info("START_MONITORING");
        try {
            WatchKey key;
            while ((key = watchService.take()) != null) {
                for (WatchEvent<?> event : key.pollEvents()) {
                    log.debug("Event kind: {}; File affected: {}", event.kind(), event.context());
                }
                key.reset();
            }
        } catch (InterruptedException e) {
            log.warn("interrupted exception for monitoring service");
        }
    }

    @PreDestroy
    public void stopMonitoring() {
        log.info("STOP_MONITORING");

        if (watchService != null) {
            try {
                watchService.close();
            } catch (IOException e) {
                log.error("exception while closing the monitoring service");
            }
        }
    }
}

Also, you have to set @EnableAsync for your application class (it configuration).

and snipped from application.yml:

monitoring-folder: C:\Users\user_name

Tested with Spring Boot 2.3.1.

Also used configuration for Async pool:

@Slf4j
@EnableAsync
@Configuration
@AllArgsConstructor
@EnableConfigurationProperties(AsyncProperties.class)
public class AsyncConfiguration implements AsyncConfigurer {

    private final AsyncProperties properties;

    @Override
    @Bean(name = "taskExecutor")
    public Executor getAsyncExecutor() {
        log.debug("Creating Async Task Executor");
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(properties.getCorePoolSize());
        taskExecutor.setMaxPoolSize(properties.getMaxPoolSize());
        taskExecutor.setQueueCapacity(properties.getQueueCapacity());
        taskExecutor.setThreadNamePrefix(properties.getThreadName());
        taskExecutor.initialize();
        return taskExecutor;
    }

    @Bean
    public TaskScheduler taskScheduler() {
        return new ConcurrentTaskScheduler();
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new CustomAsyncExceptionHandler();
    }
}

Where the custom async exception handler is:

@Slf4j
public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
        log.error("Exception for Async execution: ", throwable);
        log.error("Method name - {}", method.getName());
        for (Object param : objects) {
            log.error("Parameter value - {}", param);
        }
    }
}

Configuration at properties file:

async-monitoring:
  core-pool-size: 10
  max-pool-size: 20
  queue-capacity: 1024
  thread-name: 'async-ex-'

Where AsyncProperties:

@Getter
@Setter
@ConfigurationProperties("async-monitoring")
public class AsyncProperties {
    @NonNull
    private Integer corePoolSize;
    @NonNull
    private Integer maxPoolSize;
    @NonNull
    private Integer queueCapacity;
    @NonNull
    private String threadName;
}

For using asynchronous execution I am processing an event like the following:

validatorService.processRecord(recordANPR, zipFullPath);

Where validator service has a look like:

@Async
public void processRecord(EvidentialRecordANPR record, String fullFileName) {

The main idea is that you configure async configuration -> call it from MonitoringService -> put @Async annotation above method at another service which you called (it should be a method of another bean - initialisation goes through a proxy).

Upvotes: 17

Ponangi Sriram
Ponangi Sriram

Reputation: 1

Apache commons-io is another good alternative to watch changes to files/directories.

You can see the overview of pros and cons of using it in this answer: https://stackoverflow.com/a/41013350/16470819

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.11.0</version>
</dependency>

Upvotes: 0

Rayon
Rayon

Reputation: 902

found a workaround you can annotate your task by @Scheduled(fixedDelay = Long.MAX_VALUE)

you could check code:

@Scheduled(fixedDelay = Long.MAX_VALUE)
public void watchTask() {
                this.loadOnStartup();
                try {
                    WatchService watcher = FileSystems.getDefault().newWatchService();
                    Path file = Paths.get(propertyFile);
                    Path dir = Paths.get(file.getParent().toUri());
                    dir.register(watcher, ENTRY_MODIFY);
                    logger.info("Watch Service registered for dir: " + dir.getFileName());
    
                    while (true) {
                        WatchKey key;
                        try {
                            key = watcher.take();
                        } catch (InterruptedException ex) {
                            return;
                        }
    
                        for (WatchEvent<?> event : key.pollEvents()) {
                            WatchEvent.Kind<?> kind = event.kind();
    
                            @SuppressWarnings("unchecked")
                            WatchEvent<Path> ev = (WatchEvent<Path>) event;
                            Path fileName = ev.context();
                            logger.debug(kind.name() + ": " + fileName);
                            if (kind == ENTRY_MODIFY &&
                                    fileName.toString().equals(file.getFileName().toString())) {
                                    //publish event here
                            }
                        }
                        boolean valid = key.reset();
                        if (!valid) {
                            break;
                        }
                    }
                } catch (Exception ex) {
                    logger.error(ex.getMessage(), ex);
                }
            }
        }

Upvotes: 1

Sully
Sully

Reputation: 14943

spring-boot-devtools has FileSystemWatcher

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

FileWatcherConfig

@Configuration
public class FileWatcherConfig {
    @Bean
    public FileSystemWatcher fileSystemWatcher() {
        FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(true, Duration.ofMillis(5000L), Duration.ofMillis(3000L));
        fileSystemWatcher.addSourceFolder(new File("/path/to/folder"));
        fileSystemWatcher.addListener(new MyFileChangeListener());
        fileSystemWatcher.start();
        System.out.println("started fileSystemWatcher");
        return fileSystemWatcher;
    }

    @PreDestroy
    public void onDestroy() throws Exception {
        fileSystemWatcher().stop();
    }
}

MyFileChangeListener

@Component
public class MyFileChangeListener implements FileChangeListener {

    @Override
    public void onChange(Set<ChangedFiles> changeSet) {
        for(ChangedFiles cfiles : changeSet) {
            for(ChangedFile cfile: cfiles.getFiles()) {
                if( /* (cfile.getType().equals(Type.MODIFY) 
                     || cfile.getType().equals(Type.ADD)  
                     || cfile.getType().equals(Type.DELETE) ) && */ !isLocked(cfile.getFile().toPath())) {
                    System.out.println("Operation: " + cfile.getType() 
                      + " On file: "+ cfile.getFile().getName() + " is done");
                }
            }
        }
    }
    
    private boolean isLocked(Path path) {
        try (FileChannel ch = FileChannel.open(path, StandardOpenOption.WRITE); FileLock lock = ch.tryLock()) {
            return lock == null;
        } catch (IOException e) {
            return true;
        }
    }

}

Upvotes: 19

Sanket Mehta
Sanket Mehta

Reputation: 622

Just in case, if somebody is looking for recursive sub-folder watcher, this link may help: How to watch a folder and subfolders for changes

Upvotes: -1

s.ijpma
s.ijpma

Reputation: 940

Without giving the details here a few pointers which might help you out.

You can take the directory WatchService code from Sławomir Czaja's answer:

You can use pure java for this no need for spring https://docs.oracle.com/javase/tutorial/essential/io/notification.html

and wrap that code into a runnable task. This task can notify your clients of directory change using the SimpMessagingTemplate as described here: Websocket STOMP handle send

Then you can create a scheduler like described here: Scheduling which handles the start and reaccurance of your task.

Don't forget to configure scheduling and websocket support in your mvc-config as well as STOMP support on the client side (further reading here: STOMP over Websocket)

Upvotes: 0

Gary Russell
Gary Russell

Reputation: 174769

See the Spring Integration Samples Repo there's a file sample under 'basic'.

There's a more recent and more sophisticated sample under applications file-split-ftp - it uses Spring Boot and Java configuration Vs. the xml used in the older sample.

Upvotes: 2

Sławomir Czaja
Sławomir Czaja

Reputation: 383

You can use pure java for this no need for spring https://docs.oracle.com/javase/tutorial/essential/io/notification.html

Upvotes: 5

Related Questions