使用getter / setter实现嵌套的抽象类

Question

I have the following abstract class structure:

public abstract class A {
    ...
    private List<B> b;

    public List<B> getB() {
        return b;
    }
    public void setB(List<B> b) {
        this.b = b;
    }
    public static abstract class B {

    }
}

and implement it like this:

public class AA extends A {
    public static class BB extends B {
        ...
    }

When I now use the jackson to map Json on AA, I get an error, that it could not create an instance of A$B. I think this is, because the getter/setter in A still references on B and not on BB, which causes the error. Is there any way I can do it like that, without also putting the getter/setter in the subclass?

Answer 1

You could add type capture to make sure b is always correctly typed like this:

public abstract class A<T extends A.B> {
    ...
    private List<T> b;

    public List<T> getB() {
        return b;
    }
    public void setB(List<T> b) {
        this.b = b;
    }
    public static abstract class B {
        ...
    }
}

and then

public class AA extends A<AA.BB> {
    ...
    public static class BB extends B {
        ...
    }

Answer 2

There are several options how to de-serialize. If you have no annotations, Jackson probably falls back to using a constructor of nearest superclass that has a public constructor with no parameters. After creating an empty object, it then sets the fields using reflections.

• Reflections WILL bypass any validations in constructor like Objects.requireNotNull .

A more refined way how to use Jackson is to use @JsonCreator and @JsonProperty in constructor, naming all the parameters.

• This enables you to force Jackson to use a constructor you made and validate the object.

I am quite unsure about this rather unusual structure. After all, you have an abstract class nested in an abstract class, I have seen a lot of things, but I haven't seen anything like this. Is there a good reason? Or is it not a problem to just move the inner class to a file of its own? (it is public static after all)

Answer 3

If you create an instance of AA you need an instance of the abstract class B and you define nowwhere, which instance to use. Just providing some implementation ( BB ) isn't enough.