在Eclipse插件中高效追踪文件修改与保存状态

import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.slf4j.Logger; // 假设使用SLF4J作为日志框架
import org.slf4j.LoggerFactory;

public class DirtyFileManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(DirtyFileManager.class);

    public void initialize() {
        ResourcesPlugin.getWorkspace().addResourceChangeListener(
            new IResourceChangeListener() {
                @Override
                public void resourceChanged(final IResourceChangeEvent event) {
                    // 处理资源变更事件
                    handleResourceChangeEvent(event);
                }
            }, IResourceChangeEvent.POST_CHANGE
        );
        LOGGER.info("IResourceChangeListener registered successfully.");
    }

    private void handleResourceChangeEvent(IResourceChangeEvent event) {
        // 事件处理逻辑将在下一节详细介绍
    }

    // 在插件停止时注销监听器，防止内存泄漏
    public void dispose() {
        ResourcesPlugin.getWorkspace().removeResourceChangeListener(
            // 传入注册时使用的同一个监听器实例
            // ... (需要保存监听器实例引用以便注销)
        );
        LOGGER.info("IResourceChangeListener unregistered.");
    }
}

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.runtime.CoreException;

// ... (DirtyFileManager class, handleResourceChangeEvent method)

private void handleResourceChangeEvent(IResourceChangeEvent event) {
    IResourceDelta delta = event.getDelta();
    if (delta == null) {
        return; // 没有资源变更
    }

    IResourceDeltaVisitor visitor = new IResourceDeltaVisitor() {
        @Override
        public boolean visit(IResourceDelta delta) throws CoreException {
            IResource res = delta.getResource();

            // 检查变更类型
            switch (delta.getKind()) {
                case IResourceDelta.ADDED:
                    // 资源被添加
                    // System.out.println("Resource added: " + res.getFullPath());
                    break;
                case IResourceDelta.REMOVED:
                    // 资源被移除
                    // System.out.println("Resource removed: " + res.getFullPath());
                    break;
                case IResourceDelta.CHANGED:
                    // 资源被修改
                    // 进一步检查具体修改类型
                    if ((delta.getFlags() & IResourceDelta.CONTENT) != 0) {
                        // 文件内容被修改
                        LOGGER.debug("File content changed: {}", res.getFullPath());
                        // 在此处通知你的自定义追踪器，此文件现在是“脏”的
                        notifyFileModified(res);
                    }
                    if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
                        // 资源被移动
                        LOGGER.debug("Resource moved from: {}", delta.getMovedFromPath());
                    }
                    // 其他可能的标志位如 IResourceDelta.MARKERS, IResourceDelta.OPEN, etc.
                    break;
                default:
                    break;
            }
            // 返回 true 以继续访问子资源
            return true;
        }
    };

    try {
        delta.accept(visitor);
    } catch (CoreException e) {
        LOGGER.error("Error checking IResourceDelta visitor", e);
    }
}

private void notifyFileModified(IResource resource) {
    // 这是一个占位符方法，你需要在这里实现你自己的逻辑
    // 例如，将 resource.getFullPath() 添加到一个 Set<IPath> 中
    // 或者更新一个自定义的“脏”文件状态管理器
    LOGGER.info("Custom tracker notified: {} is dirty.", resource.getFullPath());
    // yourCustomDirtyFileTracker.addDirtyFile(resource.getFullPath());
}

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class CustomDirtyFileTracker {
    private final Set<IPath> dirtyFiles = Collections.synchronizedSet(new HashSet<>());

    public void addDirtyFile(IPath filePath) {
        dirtyFiles.add(filePath);
        LOGGER.debug("Added to dirty list: {}", filePath);
    }

    public void removeDirtyFile(IPath filePath) {
        if (dirtyFiles.remove(filePath)) {
            LOGGER.debug("Removed from dirty list: {}", filePath);
        }
    }

    public boolean isDirty(IPath filePath) {
        return dirtyFiles.contains(filePath);
    }

    public Set<IPath> getDirtyFiles() {
        return Collections.unmodifiableSet(dirtyFiles);
    }
}

// ... (在 handleResourceChangeEvent 方法的 visitor.visit 内部)
            case IResourceDelta.CHANGED:
                // ...
                if ((delta.getFlags() & IResourceDelta.CONTENT) != 0) {
                    // 文件内容被修改，标记为脏
                    LOGGER.debug("File content changed: {}", res.getFullPath());
                    yourCustomDirtyFileTracker.addDirtyFile(res.getFullPath());
                } else {
                    // 文件被修改，但不是内容修改 (例如只改变了标记，或者属性)
                    // 更重要的是，如果它之前是脏的，现在可能被保存了
                    if (yourCustomDirtyFileTracker.isDirty(res.getFullPath())) {
                        // 检查文件是否真的不再脏了 (例如，通过检查编辑器状态，如果适用)
                        // 对于简单的判断，可以假设如果不是内容修改事件，且文件之前是脏的，
                        // 那么它可能已经保存或以其他方式不再脏了
                        LOGGER.debug("File {} was dirty, now changed without content modification. Assuming saved/reverted.", res.getFullPath());
                        yourCustomDirtyFileTracker.removeDirtyFile(res.getFullPath());
                    }
                }
                break;
// ...