解决lombok 父类和子类builder不兼容的问题

当使用Lombok框架时，有时会遇到使用父类的Builder创建子类实例时出现兼容性问题的情况。这是因为父类和子类在使用Lombok注解生成的Builder时，使用的是不同的构造器和setter方法。

要解决这个问题，我们可以使用下面的步骤来解决：

1. 使用 @SuperBuilder 注解

在父类和子类中都添加 @SuperBuilder 注解，这个注解会同时生成父类和子类的Builder。例如：

@SuperBuilder
@Data
public class Parent {
    private String name;
    private int age;
}

@SuperBuilder
@Data
public class Child extends Parent {
    private int grade;
}

这样，在子类中就可以使用父类的Builder来创建子类的实例了。例如：

Child child = Child.builder()
        .name("John")
        .age(10)
        .grade(5)
        .build();

2. 在子类中手动覆盖 Builder 方法

在子类中手动覆盖 Builder 方法，并使用父类的Builder方法来创建父类的实例。例如：

@Data
public class Parent {
    private String name;
    private int age;

    public static abstract class ParentBuilder<C extends Parent, B extends ParentBuilder<C, B>> {
        private String name;
        private int age;

        public B name(String name) {
            this.name = name;
            return self();
        }

        public B age(int age) {
            this.age = age;
            return self();
        }

        protected abstract B self();

        public abstract C build();

        public B from(Parent parent) {
            return this.name(parent.getName())
                    .age(parent.getAge());
        }
    }

    protected Parent(ParentBuilder<?, ?> builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    public static ParentBuilder<?, ?> builder() {
        return new ParentBuilderImpl();
    }

    private static class ParentBuilderImpl extends ParentBuilder<Parent, ParentBuilderImpl> {
        @Override
        protected ParentBuilderImpl self() {
            return this;
        }

        @Override
        public Parent build() {
            return new Parent(this);
        }
    }
}

@Data
public class Child extends Parent {
    private int grade;

    public static class ChildBuilder extends ParentBuilder<Child, ChildBuilder> {
        private int grade;

        public ChildBuilder grade(int grade) {
            this.grade = grade;
            return this;
        }

        @Override
        public Child build() {
            return new Child(this);
        }

        @Override
        protected ChildBuilder self() {
            return this;
        }

        @Override
        public ChildBuilder from(Parent parent) {
            return parent instanceof ChildBuilder ? (ChildBuilder) parent : super.from(parent).grade(3);
        }
    }

    public static ChildBuilder builder() {
        return new ChildBuilder();
    }

    protected Child(ChildBuilder builder) {
        super(builder);
        this.grade = builder.grade;
    }
}

我们在子类Child中创建了一个新的ChildBuilder类。这个类继承了ParentBuilder，并增加了一个成员变量grade，覆盖了build()和self()方法，用于创建子类实例。

这样我们就可以使用子类的Builder来创建父类和子类的实例了。例如：

Child child = Child.builder()
        .name("John")
        .age(10)
        .grade(5)
        .build();

Parent parent = Child.builder()
        .name("John")
        .age(10)
        .build();

以上是解决Lombok父类和子类Builder兼容性问题的两种方法，可以根据个人喜好和项目需求选择使用。