如何检测Model/POJO类内变量变更并自动同步至磁盘？

嘿，手动给几百个字段写setter还挨个加同步代码？这绝对是反人类的重复劳动！下面给你几个实用的方案，不用重复造轮子，轻松实现字段变更后自动同步到磁盘：

利用JDK自带的Observable/Observer机制，配合Lombok自动生成带通知逻辑的setter，完全不用手动写每个set方法：

步骤1：改造你的POJO #

import java.util.Observable;
import lombok.Getter;
import lombok.Setter;

@Getter
// 让Lombok生成的setter自动添加Observable的通知逻辑
@Setter(onMethod_ = {
    @Override
})
public class MyPOJO extends Observable {
    private String username;
    private int age;
    private Address subField; // 子字段也可以用同样的方式处理
    // 几百个字段...
}

步骤2：实现持久化观察者 #

import java.util.Observer;
import java.util.Observable;

public class DiskPersistenceObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        // 调用你的自定义磁盘存储逻辑
        savePOJOToDisk(o);
    }

    private void savePOJOToDisk(Object pojo) {
        // 这里写你已经实现的存储代码，比如序列化到文件
        System.out.println("自动同步POJO到磁盘：" + pojo);
    }
}

步骤3：使用时绑定观察者 #

public class Main {
    public static void main(String[] args) {
        MyPOJO pojo = new MyPOJO();
        pojo.addObserver(new DiskPersistenceObserver());
        
        // 任意修改字段，自动触发同步
        pojo.setUsername("testUser");
        pojo.setAge(25);
    }
}

如果不想让POJO继承Observable，可以用CGLIB动态生成代理类，拦截所有set方法的调用，自动触发同步：

步骤1：引入CGLIB依赖（Maven示例） #

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

步骤2：编写代理生成工具 #

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class PersistenceProxyFactory {
    public static <T> T createPersistentProxy(T target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
            // 先执行原set方法
            Object result = proxy.invokeSuper(obj, args);
            // 判断是否是set方法（简单规则：以set开头，且有一个参数）
            if (method.getName().startsWith("set") && method.getParameterCount() == 1) {
                // 触发磁盘同步
                savePOJOToDisk(target);
            }
            return result;
        });
        return (T) enhancer.create();
    }

    private static void savePOJOToDisk(Object pojo) {
        // 你的存储逻辑
        System.out.println("代理模式下自动同步POJO到磁盘：" + pojo);
    }
}

步骤3：使用代理对象 #

public class Main {
    public static void main(String[] args) {
        MyPOJO original = new MyPOJO();
        MyPOJO proxy = PersistenceProxyFactory.createPersistentProxy(original);
        
        // 修改字段自动触发同步
        proxy.setUsername("proxyUser");
    }
}

如果你的项目是Spring栈，用AOP切面拦截所有set方法是最优雅的方式：

步骤1：定义自定义注解标记需要自动持久化的POJO #

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoPersist {
}

步骤2：给POJO添加注解 #

@AutoPersist
public class MyPOJO {
    private String username;
    private int age;
    // getter/setter（Lombok或手动生成均可）
}

步骤3：编写切面类 #

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class PersistenceAspect {
    // 拦截所有带@AutoPersist注解的类的set方法
    @After("execution(* com.yourpackage..*(set*(*))) && @target(com.yourpackage.AutoPersist)")
    public void afterSetMethodCall(JoinPoint joinPoint) {
        Object targetPOJO = joinPoint.getTarget();
        // 触发磁盘同步
        savePOJOToDisk(targetPOJO);
    }

    private void savePOJOToDisk(Object pojo) {
        // 你的存储逻辑
        System.out.println("Spring AOP自动同步POJO到磁盘：" + pojo);
    }
}

注意事项 #

• 针对子字段（嵌套POJO）：如果子字段也需要自动同步，可以给子POJO也应用同样的方案（比如加注解、继承Observable等），或者在同步逻辑里递归处理嵌套对象。
• 性能考量：如果字段变更非常频繁，可以考虑加防抖逻辑（比如延迟1秒再同步，避免短时间内多次写入磁盘）。

内容的提问来源于stack exchange，提问作者Ravinder Payal