「java如何监控数据变动」java监控对象变化

博主：adminadmin 2023-01-25 04:24:09 316

今天给各位分享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="";/a

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

 */

public class WatchDir {

 

    private final WatchService watcher;

    private final MapWatchKey, 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 HashMapWatchKey, Path();

        this.subDir = subDir;

 

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

 

        if (subDir) {

            registerAll(dir);

        } else {

            register(dir);

        }

        processEvents(callback);

    }

 

    @SuppressWarnings("unchecked")

    static T WatchEventT cast(WatchEvent? event) {

        return (WatchEventT) 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 SimpleFileVisitorPath() {

            @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;

                }

 

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

                WatchEventPath 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;

                }

            }

        }

    }

 

}

java怎样监听一个值是否发生了变化，具体代码

java 自定义监听器监听属性变化

import java.util.EventObject;

public class MyEvent extends EventObject

{

private Object obj;

private String sName;

public MyEvent(Object source,String sName)

{

super(source);

this.obj=source;

this.sName=sName;

}

public Object getObj()

{

return obj;

}

public String getsName()

{

return sName;

}

}

import java.util.EventListener;

public interface MyEventListener extends EventListener

{

public void handleEvent (MyEvent me);

}

import java.util.Iterator;

import java.util.Vector;

import demo.DemoEvent;

public class MyEventSource

{

private Vector list=new Vector();

private String sName = "";

public MyEventSource()

{

super();

}

public void addMyEventListener(MyEventListener me)

{

list.add(me);

}

public void deleteMyEventListener(MyEventListener me)

{

list.remove(me);

}

public void notifyMyEvent(MyEvent me)

{

Iterator it=list.iterator();

while(it.hasNext())

{

((MyEventListener) it.next()).handleEvent(me);

}

}

public void setName(String str)

{

boolean bool = false;

if (str == null sName != null)

bool = true;

else if (str != null sName == null)

bool = true;

else if (!sName.equals(str))

bool = true;

this.sName = str;

// 如果改变则执行事件

if (bool)

notifyMyEvent(new MyEvent(this, sName));

}

public String getsName()

{

return sName;

}

}

public class Test implements MyEventListener

{

public Test()

{

MyEventSource mes = new MyEventSource();

mes.addMyEventListener(this);

mes.setName("niu");

}

public static void main(String args[])

{

new Test();

}

public void handleEvent(MyEvent me)

{

System.out.println(me.getSource());

System.out.println(me.getsName());

}

}

java求高手，怎样随时监测数据库中数据的增删改查?

这个要看你监控的切面在那里

想项目系统中监控，那里你就要监控所有的增删改查方法

要么你使用动态代理，要么你使用spring的AOP

想在数据库中监控，可以考虑触发器

mysql也有触发器，可以考虑下

java后台怎样监控sql server数据库数据的变化

看来你是做日志记录，在SQL server 2005中建立一个触发器（delete,update\insert），针对table1,在触发器的代码中加上数据拷贝的SQL语句就可以了。

JAVA实现业务数据监控解决方案

用mysql就可以吧，以每五分钟统计一次来看：每年的记录数60/5*24*365=105120条，10年才100w，再在开始时间、结束时间字段建个联合索引，不用担心数据库性能。

如何用java监听 数据库某张表的变化

ajax 轮训，HTML5 websocket 触发器是在数据库端的，实现不了你的要求。

ajax轮训每隔几秒就查询一次，保存上次的总条数，然后下次只要不一样了就弹窗。

你这个对服务器压力很大（如果用户很多的话）

java如何监控数据变动的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java监控对象变化、java如何监控数据变动的信息别忘了在本站进行查找喔。

标签：