自定义注解实现Json字段过滤

红太狼 2022-02-17 09:37 668阅读 0赞

### 自定义注解： JSON过滤字段 ###

1、使用**@JsonInclude(JsonInclude.Include.NON\_NULL)** 进行null值不给前台返回

2、使用自定义注解讲有结果集的字段设置为null，这样就通过1 不给前台返回了

#### 1、自定义注解 ####

/**
     * @Desc: 自定义注解
     * @Author HealerJean
     * @Date 2018/9/20  上午11:20.
     */
    
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface JSON {
        Class<?> type();
        String include() default "";
        String filter() default "";
    }

#### 4、自定义flterOrInclude ####

package com.hlj.springboot.dome.anno;
    
    import com.fasterxml.jackson.annotation.JsonFilter;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
    import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
    
    /**
     * @Desc: HealerJean
     * @Date:  2018/9/20 下午2:07.
     */
    
    public class JsonAnnoSerializer {
    
        static final String DYNC_INCLUDE = "DYNC_INCLUDE";
        static final String DYNC_FILTER = "DYNC_FILTER";
        ObjectMapper mapper = new ObjectMapper();
    
        @JsonFilter(DYNC_FILTER)
        interface DynamicFilter {
        }
    
        @JsonFilter(DYNC_INCLUDE)
        interface DynamicInclude {
        }
    
        /**
         * @param clazz 需要设置规则的Class
         * @param include 转换时包含哪些字段
         * @param filter 转换时过滤哪些字段
         */
        public void filter(Class<?> clazz, String include, String filter) {
            if (clazz == null) return;
            if (include != null && include.length() > 0) {
                mapper.setFilterProvider(new SimpleFilterProvider().addFilter(DYNC_INCLUDE,
                        SimpleBeanPropertyFilter.filterOutAllExcept(include.split(","))));
                mapper.addMixIn(clazz, DynamicInclude.class);
            } else if (filter !=null && filter.length() > 0) {
                mapper.setFilterProvider(new SimpleFilterProvider().addFilter(DYNC_FILTER,
                        SimpleBeanPropertyFilter.serializeAllExcept(filter.split(","))));
                mapper.addMixIn(clazz, DynamicFilter.class);
            }
        }
    
        public String toJson(Object object) throws JsonProcessingException {
            return mapper.writeValueAsString(object);
        }
    }

#### 3、自定义Aop拦截 ####

package com.hlj.springboot.dome.anno.aop;
    
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.hlj.springboot.dome.anno.JsonAnnoSerializer;
    import com.hlj.springboot.dome.anno.JSON;
    import com.hlj.springboot.dome.common.data.ResponseBean;
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    import net.sf.json.util.JSONTokener;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.List;
    
    /**
     * @Desc:
     * @Author HealerJean
     * @Date 2018/9/20  上午11:21.
     */
    @Aspect
    @Component
    public class JsonInterceptor {
    
        /**
         * ObjectMapper
         */
        private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
        static {
            OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        }
    
    
        /**
         *
         * @param point
         * @return
         * @throws Throwable
         */
        @Around("@annotation(com.hlj.springboot.dome.anno.JSON) || @within(com.hlj.springboot.dome.anno.JSON)")
        protected Object invoke(ProceedingJoinPoint point) throws Throwable {
            JSON json = null;
            Signature signature = point.getSignature();
            if (signature instanceof MethodSignature) {
                Method method = ((MethodSignature) signature).getMethod();
                json = method.getAnnotation(JSON.class);
            }
            if (json == null) {
                return point.proceed();
            }
    
            try {
                Object object = point.proceed();
                JsonAnnoSerializer jsonSerializer = new JsonAnnoSerializer();
                jsonSerializer.filter(json.type(), json.include(), json.filter());
    
                //如果包装类是ResponBean
                if(ResponseBean.class.getName().equals(  object.getClass().getName())){ //如果返回类型是ResponseBean
                    ResponseBean responseBean = (ResponseBean)object;
                     String innerJsonStr = jsonSerializer.toJson(responseBean.getResult());
                     Object jsonT = new JSONTokener(innerJsonStr).nextValue();
    
                    if(jsonT instanceof JSONObject){
                           responseBean.setResult (OBJECT_MAPPER.readValue(innerJsonStr, json.type()));
                    }else if (jsonT instanceof JSONArray) {
                           responseBean.setResult (OBJECT_MAPPER.readValue(innerJsonStr, new TypeReference<List>() { } ));
                    }
                    return  responseBean ;
                }
    
                //没有包装类
                String resultJson = jsonSerializer.toJson(object);
                Object jsonT = new JSONTokener(resultJson).nextValue();
                if(jsonT instanceof JSONObject){
                    return OBJECT_MAPPER.readValue(resultJson, json.type());
                }else if (jsonT instanceof JSONArray) {
                    return OBJECT_MAPPER.readValue(resultJson, new TypeReference<List>() { } );
                }
                return   object;
            } catch (Exception e) {
                throw e;
            }
        }
    
    
    
    }

#### 4、进行测试 ####

/** * 测试实体类，这个随便; */
    @Data
    @Accessors(chain = true)
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class DemoEntity { 
    
    	private Long id;
    
    	private String name;
    
    	private Long balance;
    
    }

package com.hlj.springboot.dome.common.moudle.controller;
    
    
    import com.hlj.springboot.dome.anno.JSON;
    import com.hlj.springboot.dome.common.data.ResponseBean;
    import com.hlj.springboot.dome.common.entity.DemoEntity;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/22  上午10:22.
     */
    @Controller
    public class HomeController {
    
    
    
        @GetMapping("responBean")
        @ResponseBody
        @JSON(type =DemoEntity.class, include = "name")
        public ResponseBean jsonIgnore(){
            try {
                DemoEntity demoEntity = new DemoEntity().setId(1L).setName("healerjean").setBalance(24L);
                return  ResponseBean.buildSuccess(demoEntity);
            }catch (Exception e){
                return  ResponseBean.buildFailure(e.getMessage());
            }
        }
    
        @GetMapping("responBean/list")
        @ResponseBody
        @JSON(type =DemoEntity.class, filter = "id")
        public ResponseBean list(){
            try {
                List<DemoEntity> demoEntityList  = new ArrayList<>();
                DemoEntity demoEntity = new DemoEntity().setId(1L).setName("healerjean").setBalance(24L);
                DemoEntity demoEntity2 = new DemoEntity().setId(1L).setName("healerjean").setBalance(24L);
                demoEntityList.add(demoEntity);
                demoEntityList.add(demoEntity2);
                return  ResponseBean.buildSuccess(demoEntityList);
            }catch (Exception e){
                return  ResponseBean.buildFailure(e.getMessage());
            }
        }
    
        @GetMapping("jsonFilter")
        @ResponseBody
        @JSON(type =DemoEntity.class, filter = "id")
        public DemoEntity jsonFilter(){
            try {
                DemoEntity demoEntity = new DemoEntity().setId(1L).setName("healerjean").setBalance(24L);
                return  demoEntity;
            }catch (Exception e){
                return  null;
            }
        }
    
        @GetMapping("jsonInclude/list")
        @ResponseBody
        @JSON(type =DemoEntity.class, include = "id")
        public List<DemoEntity> jsonIncludeList(){
            try {
                List<DemoEntity> demoEntityList  = new ArrayList<>();
                DemoEntity demoEntity = new DemoEntity().setId(1L).setName("healerjean").setBalance(24L);
                DemoEntity demoEntity2 = new DemoEntity().setId(1L).setName("healerjean").setBalance(24L);
                demoEntityList.add(demoEntity);
                demoEntityList.add(demoEntity2);
                return  demoEntityList;
            }catch (Exception e){
                return  null;
            }
        }
    
    
    
    }

#### 5、浏览器访问 ####

http://localhost:8080/jsonFilter

{
      "name": "healerjean",
      "balance": 24
    }

http://localhost:8080/jsonInclude/list

[
      {
        "id": 1
      },
      {
        "id": 1
      }
    ]

http://localhost:8080/responBean

{
      "success": true,
      "result": {
        "name": "healerjean"
      },
      "message": "",
      "code": "200",
      "date": "1555644132805"
    }

http://localhost:8080/responBean/list

{
      "success": true,
      "result": [
        {
          "name": "healerjean",
          "balance": 24
        },
        {
          "name": "healerjean",
          "balance": 24
        }
      ],
      "message": "",
      "code": "200",
      "date": "1555644151816"
    }

## [ 代码下载][Link 1] ##

![ContactAuthor][]

[Link 1]: https://github.com/HealerJean/anno-json-filter-or-include.git
[ContactAuthor]: /images/20220217/7702f12de51c40739e57db4ed2618d8a.png