java监控服务器文件在哪里？java监控服务器文件在JAVA_HOME\bin\目录下的jvisualvm.exe，双击这个文件就能看到一个比较直观的界面的。关于java监控服务器文件在哪里以及java监控服务器文件在哪里，java监控服务器文件在哪个文件夹，java 监控文件夹，Java服务器监控，java监控服务器状态等问题，农商网将为你整理以下的生活知识：

java监控服务器可以用吗

　　java监控服务器是可以用的。

　　般来说,利用Java进行Linux服务器监控,主要采用的是Java的网络编程。

　　由于Java拥有对多种操作系统的良好支持,可以使用网络编程技术来实现Linux服务器间的无缝数据通信,并实现远程服务器检测与管理。

　　Java的网络编程技术在此基础上,可以利用Socket技术,实现Linux服务器之间的数据传输,监控系统资源使用情况,如系统CPU使用情况,内存使用情况等等。

java监控服务器文件在哪里

　　java监控服务器文件在JAVA_HOME\bin\目录下的jvisualvm.exe，双击这个文件就能看到一个比较直观的界面。

　　要进行远程监控，本机的VisualVM就必须和远程的JVM要进行通信，Visualvm支持两种remote connection方式，分别是jstatd和JMX方式。

　　Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

　　Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java 如何监控文件目录的变化

　　JavaSE 1.7提供了相关的API，去监视文件或者文件夹的变动，主要的API都在java.nio.file下面，其大概流程如下：

package org.xdemo.superutil.j2se.filewatch;

 

　　import static java.nio.file.LinkOption.NOFOLLOW_LINKS;

　　import java.io.File;

　　import java.io.IOException;

　　import java.nio.file.FileSystems;

　　import java.nio.file.FileVisitResult;

　　import java.nio.file.Files;

　　import java.nio.file.Path;

　　import java.nio.file.Paths;

　　import java.nio.file.SimpleFileVisitor;

　　import java.nio.file.StandardWatchEventKinds;

　　import java.nio.file.WatchEvent;

　　import java.nio.file.WatchEvent.Kind;

　　import java.nio.file.WatchKey;

　　import java.nio.file.WatchService;

　　import java.nio.file.attribute.BasicFileAttributes;

　　import java.util.HashMap;

　　import java.util.Map;

　　/**

　　 * 文件夹监控

　　 * 

　　 * @author Goofy <a href="http://www.xdemo.org/">http://www.xdemo.org/</a>

　　 * @Date 2015年7月3日 上午9:21:33

　　 */

　　public class WatchDir {

　　    private final WatchService watcher;

　　    private final Map<WatchKey, Path> keys;

　　    private final boolean subDir;

　　    /**

　　     * 构造方法

　　     * 

　　     * @param file

　　     *            文件目录，不可以是文件

　　     * @param subDir

　　     * @throws Exception

　　     */

　　    public WatchDir(File file, boolean subDir, FileActionCallback callback) throws Exception {

　　        if (!file.isDirectory())

　　            throw new Exception(file.getAbsolutePath() + "is not a directory!");

　　        this.watcher = FileSystems.getDefault().newWatchService();

　　        this.keys = new HashMap<WatchKey, Path>();

　　        this.subDir = subDir;

　　        Path dir = Paths.get(file.getAbsolutePath());

　　        if (subDir) {

　　            registerAll(dir);

　　        } else {

　　            register(dir);

　　        }

　　        processEvents(callback);

　　    }

　　    @SuppressWarnings("unchecked")

　　    static <T> WatchEvent<T> cast(WatchEvent<?> event) {

　　        return (WatchEvent<T>) event;

　　    }

　　    /**

　　     * 观察指定的目录

　　     * 

　　     * @param dir

　　     * @throws IOException

　　     */

　　    private void register(Path dir) throws IOException {

　　        WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);

　　        keys.put(key, dir);

　　    }

　　    /**

　　     * 观察指定的目录，并且包括子目录

　　     */

　　    private void registerAll(final Path start) throws IOException {

　　        Files.walkFileTree(start, new SimpleFileVisitor<Path>() {

　　            @Override

　　            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {

　　                register(dir);

　　                return FileVisitResult.CONTINUE;

　　            }

　　        });

　　    }

　　    /**

　　     * 发生文件变化的回调函数

　　     */

　　    @SuppressWarnings("rawtypes")

　　    void processEvents(FileActionCallback callback) {

　　        for (;;) {

　　            WatchKey key;

　　            try {

　　                key = watcher.take();

　　            } catch (InterruptedException x) {

　　                return;

　　            }

　　            Path dir = keys.get(key);

　　            if (dir == null) {

　　                System.err.println("操作未识别");

　　                continue;

　　            }

　　            for (WatchEvent<?> event : key.pollEvents()) {

　　                Kind kind = event.kind();

　　                // 事件可能丢失或遗弃

　　                if (kind == StandardWatchEventKinds.OVERFLOW) {

　　                    continue;

　　                }

　　                // 目录内的变化可能是文件或者目录

　　                WatchEvent<Path> ev = cast(event);

　　                Path name = ev.context();

　　                Path child = dir.resolve(name);

　　                File file = child.toFile();

　　                if (kind.name().equals(FileAction.DELETE.getValue())) {

　　                    callback.delete(file);

　　                } else if (kind.name().equals(FileAction.CREATE.getValue())) {

　　                    callback.create(file);

　　                } else if (kind.name().equals(FileAction.MODIFY.getValue())) {

　　                    callback.modify(file);

　　                } else {

　　                    continue;

　　                }

　　                // if directory is created, and watching recursively, then

　　                // register it and its sub-directories

　　                if (subDir && (kind == StandardWatchEventKinds.ENTRY_CREATE)) {

　　                    try {

　　                        if (Files.isDirectory(child, NOFOLLOW_LINKS)) {

　　                            registerAll(child);

　　                        }

　　                    } catch (IOException x) {

　　                        // ignore to keep sample readbale

　　                    }

　　                }

　　            }

　　            boolean valid = key.reset();

　　            if (!valid) {

　　                // 移除不可访问的目录

　　                // 因为有可能目录被移除，就会无法访问

　　                keys.remove(key);

　　                // 如果待监控的目录都不存在了，就中断执行

　　                if (keys.isEmpty()) {

　　                    break;

　　                }

　　            }

　　        }

　　    }

　　}