如果缺少getter或setter（或不可见），则忽略Jackson中的属性

Question

class FooBar
{
 public FooBar(int foo, int bar)
 {
    this.foo = foo;
    this.bar = bar;
 }

 public int getFoo()
 {
 }

 public void setBar(int b)
 {
  this.bar = bar;
 }

 protected int getBar()
 {
return bar;
}

 private int foo;
 private int bar;
}

Answer 1

Jackson有两种过滤不需要的属性的机制。最常用的是通过注释(@JsonIgnore、@JsonIgnoreProperties)进行筛选。在解释用法方面有很多示例（例如https：//springframework.guru/jackson-annotations-json/）。

但是，如果您真的希望使用基于自定义条件的属性自定义筛选，那么您可以使用筛选（参见本文的参考https://www.logicbig.com/tutorials/misc/jackson/json-filter-annotation.html）。通过这种方式，您可以构建自己的序列化规则。

下面的示例代码说明了这种技术：

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.*;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Objects;
import java.util.stream.Stream;

public class M4 {

    private static final String MY_FILTER_NAME = "myFilter";

    @JsonFilter(MY_FILTER_NAME)
    public static class MyPojo {

        private int a;
        private int b;
        private int c;

        public MyPojo(int a, int b, int c) {

            this.a = a;
            this.b = b;
            this.c = c;
        }

        public int getA() {

            return a;
        }

        public void setA(int a) {

            this.a = a;
        }

        public void setB(int b) {

            this.b = b;
        }

        public int getC() {

            return c;
        }

        private void setC(int c) {

            this.c = c;
        }
    }


    private static class MySimpleBeanPropertyFilter extends SimpleBeanPropertyFilter {

        @Override protected boolean include(BeanPropertyWriter writer) {

            return super.include(writer);
        }

        @Override
        protected boolean include(PropertyWriter writer) {

            String setter = "set" + StringUtils.capitalize(writer.getName());
            String getter = "get" + StringUtils.capitalize(writer.getName());
            Class<?> declaringClass = writer.getMember().getDeclaringClass();
            Method[] methods = declaringClass.getMethods();
            return hasPublicMethod(setter, methods) && hasPublicMethod(getter, methods);
        }

        private boolean hasPublicMethod(String methodName, Method[] methods) {

            return Stream.of(methods)
                .filter(m -> Objects.equals(m.getName(), methodName))
                .anyMatch(m -> Modifier.isPublic(m.getModifiers()));
        }
    }


    private static class MyFilterProvider extends FilterProvider {

        @Override public BeanPropertyFilter findFilter(Object filterId) {

            return null;
        }

        @Override public PropertyFilter findPropertyFilter(Object filterId, Object valueToFilter) {

            if (Objects.equals(filterId, MY_FILTER_NAME)) {

                return new MySimpleBeanPropertyFilter();
            }
            return super.findPropertyFilter(filterId, valueToFilter);
        }
    }

    public static void main(String args[]) throws IOException {

        ObjectMapper mapper = new ObjectMapper();
        mapper.writer().with(new MyFilterProvider()).writeValue(System.out, new MyPojo(0, 1, 3));
    }

}