Lombok @ToString 动态注入：原理、限制与替代方案

# 假设这是一个Python脚本，作为Maven/Gradle构建的一个前置步骤
import os

def add_lombok_tostring(source_dir, package_prefix):
    for root, _, files in os.walk(source_dir):
        for file_name in files:
            if file_name.endswith(".java"):
                file_path = os.path.join(root, file_name)
                # 检查是否属于目标包
                if f"package {package_prefix.replace('*', '')}" in open(file_path).read():
                    with open(file_path, 'r+') as f:
                        content = f.read()
                        if "@lombok.ToString" not in content:
                            # 寻找类声明并插入注解
                            # 这是一个简化的逻辑，实际需要更健壮的AST解析
                            modified_content = content.replace("public class", "@lombok.ToString\npublic class", 1)
                            f.seek(0)
                            f.write(modified_content)
                            print(f"Added @ToString to {file_name}")

# 在构建脚本中调用
# add_lombok_tostring("src/main/java", "xxx.yyy.dao.")

package com.example.aspects;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * 运行时动态生成或拦截toString方法的Aspect
 * 注意：这是一个概念性示例，实际生产环境需要更健壮的错误处理和性能优化。
 * 此外，AspectJ的配置和集成也需要额外设置。
 */
@Aspect
public class DynamicToStringAspect {

    // 定义切点：匹配xxx.yyy.dao包下所有类的toString()方法调用
    // 排除Lombok生成的toString()，如果Lombok已经生成，我们就不需要动态处理
    // 实际判断Lombok是否生成可能需要更复杂的逻辑，例如检查方法是否有@Generated注解
    @Pointcut("execution(public String xxx.yyy.dao.*.toString()) && !@annotation(lombok.Generated)")
    public void targetToStringCalls() {}

    // 使用Around Advice拦截toString()方法的调用
    @Around("targetToStringCalls()")
    public Object generateToStringDynamically(ProceedingJoinPoint pjp) throws Throwable {
        Object target = pjp.getTarget(); // 获取当前调用的目标对象

        // 检查目标对象是否为空，或者是否已经有Lombok或自定义的toString实现
        // 这里的逻辑可以更复杂，例如通过检查方法体或注解来判断
        try {
            // 尝试调用原始的toString()方法，如果存在且不是默认的Object.toString()
            // 避免无限递归，如果原始方法是Object.toString()，则进行动态生成
            String originalToString = (String) pjp.proceed();
            if (!originalToString.contains(target.getClass().getName() + "@")) { // 简单的启发式判断是否是Object.toString()
                return originalToString; // 如果是自定义或Lombok生成的，则直接返回
            }
        } catch (Throwable e) {
            // 如果原始方法不存在或抛出异常，则继续动态生成
            // 忽略异常，继续执行下面的动态生成逻辑
        }


        if (target == null) {
            return pjp.proceed(); // 如果目标为空，则继续执行原始逻辑
        }

        // 动态构建toString()字符串
        StringBuilder sb = new StringBuilder(target.getClass().getSimpleName()).append("{");
        Field[] fields = target.getClass().getDeclaredFields();

        String fieldStrings = Arrays.stream(fields)
                                    .map(field -> {
                                        field.setAccessible(true); // 允许访问私有字段
                                        try {
                                            return field.getName() + "=" + field.get(target);
                                        } catch (IllegalAccessException e) {
                                            return field.getName() + "=???"; // 访问失败
                                        }
                                    })
                                    .collect(Collectors.joining(", "));

        sb.append(fieldStrings).append("}");
        return sb.toString();
    }

    // 另一种实现思路：如果目标类没有toString()方法，则通过引入(Inter-type Declaration)添加
    // declare parents: xxx.yyy.dao.* implements MyToStringProvider;
    // public interface MyToStringProvider { String dynamicToString(); }
    // public String MyToStringProvider.dynamicToString() { /* reflection logic */ }
    // 然后通过Around advice拦截toString()调用，并转到dynamicToString()
}