java spring使用Jackson过滤

最新推荐文章于 2025-11-26 14:09:52 发布
转载 最新推荐文章于 2025-11-26 14:09:52 发布 · 1.4k 阅读 · 0

一、问题的提出。 

项目使用Spring MVC框架，并用jackson库处理JSON和POJO的转换。在POJO转化成JSON时，希望动态的过滤掉对象的某些属性。所谓动态，是指的运行时，不同的controler方法可以针对同一POJO过滤掉不同的属性。 

以下是一个Controler方法的定义，使用@ResponseBody把获得的对象列表写入响应的输出流（当然，必须配置jackson的MappingJacksonHttpMessageConverter，来完成对象的序列化）

1
2
3
4
5
6
7
8
@RequestMapping(params = "method=getAllBmForList")
@ResponseBody
public List<DepartGenInfo> getAllBmForList(HttpServletRequest request,
        HttpServletResponse response) throws Exception {
     
    BmDto dto = bmglService.getAllBm();
    return dto.getBmList();
}

POJO定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class DepartGenInfo implements java.io.Serializable {
 
     private String depid;
     private String name;
     private Company company;
 
     //getter...
     //setter...
}
 
public class Company  {
 
     private String comid;
     private String name;
<pre name="code" class="java">      //getter...
     //setter...
}

我希望在getAllBmForList返回时，过滤掉DepartGenInfo的name属性，以及company的comid属性。 

jackson支持@JsonIgnore和@JsonIgnoreProperties注解，但是无法实现动态过滤。jackson给出了几种动态过滤的办法，我选择使用annotation mixin 


•JSON View 
•JSON Filter 
•Annotation Mixin 
二、使用annotation mixin动态过滤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RequestMapping(params = "method=getAllBmForList")
public void getAllBmForList(HttpServletRequest request,
        HttpServletResponse response) throws Exception {
     
    BmDto dto = bmglService.getAllBm();
    
    ObjectMapper mapper = new ObjectMapper();
    SerializationConfig serializationConfig = mapper.getSerializationConfig();
    serializationConfig.addMixInAnnotations(DepartGenInfo.class,
      DepartGenInfoFilter.class);
 
    serializationConfig.addMixInAnnotations(Company.class,
      CompanyFilter.class);
     
    mapper.writeValue(response.getOutputStream(),dto.getBmList());
    return;
}

DepartGenInfoFilter的定义如下：

@JsonIgnoreProperties(value={"name"}) //希望动态过滤掉的属性
public interface DepartGenInfoFilter {
}//CompanyFilter的定义如下： 

这个实现方法看起来非常不简洁，需要在动态过滤的时候写不少代码，而且也改变了@ResponseBody的运行方式，失去了REST风格，因此考虑到使用AOP来进行处理。 

二、最终解决方案 

先看下我想达到的目标，通过自定义注解的方式来控制动态过滤。

@XunerJsonFilters(value={@XunerJsonFilter(mixin=DepartGenInfoFilter.class, target=DepartGenInfo.class)
            ,@XunerJsonFilter(mixin=CompanyFilter.class, target=Company.class)})
    @RequestMapping(params = "method=getAllBmForList")
    @ResponseBody
    public List getAllBmForList(HttpServletRequest request,
            HttpServletResponse response) throws Exception {
         
        BmDto dto = bmglService.getAllBm();
return dto.getBmList();
    }

@XunerJsonFilters和@XunerJsonFilter是我定义的注解。@XunerJsonFilters是@XunerJsonFilter的集合，@XunerJsonFilter定义了混合的模板以及目标类。

1
2
3
4
5
6
7
8
9
@Retention(RetentionPolicy.RUNTIME)
public @interface XunerJsonFilters {
    XunerJsonFilter[] value();
}
@Retention(RetentionPolicy.RUNTIME)
public @interface XunerJsonFilter {
  Class<?> mixin() default Object.class;
  Class<?> target() default Object.class;
}

当然，只是定义注解并没有什么意义。重要的是如何根据自定义的注解进行处理。我定义了一个AOP Advice如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class XunerJsonFilterAdvice {
 
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature msig = (MethodSignature) pjp.getSignature();
        XunerJsonFilter annotation = msig.getMethod().getAnnotation(
                XunerJsonFilter.class);
        XunerJsonFilters annotations = msig.getMethod().getAnnotation(
                XunerJsonFilters.class);
 
        if (annotation == null && annotations == null) {
            return pjp.proceed();
        }
 
        ObjectMapper mapper = new ObjectMapper();
        if (annotation != null) {
            Class<?> mixin = annotation.mixin();
            Class<?> target = annotation.target();
             
            if (target != null) {
                mapper.getSerializationConfig().addMixInAnnotations(target,
                        mixin);
            } else {
                mapper.getSerializationConfig().addMixInAnnotations(
                        msig.getMethod().getReturnType(), mixin);
            }
        }
         
        if (annotations != null) {
            XunerJsonFilter[] filters= annotations.value();
            for(XunerJsonFilter filter :filters){
                Class<?> mixin = filter.mixin();
                Class<?> target = filter.target();
                 
                if (target != null) {
                    mapper.getSerializationConfig().addMixInAnnotations(target,
                            mixin);
                } else {
                    mapper.getSerializationConfig().addMixInAnnotations(
                            msig.getMethod().getReturnType(), mixin);
                }
            }
             
        }
         
 
        try {
            mapper.writeValue(WebContext.getInstance().getResponse()
                    .getOutputStream(), pjp.proceed());
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
        return null;
    }
 
}

其中pointcut的expression能够匹配到目标类的方法。 

在doAround方法中，需要获得当前引用的HttpResponse对象，因此使用以下方法解决： 

创建一个WebContext工具类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class WebContext {
 
    private static ThreadLocal<WebContext> tlv = new ThreadLocal<WebContext>();
    private HttpServletRequest request;
    private HttpServletResponse response;
    private ServletContext servletContext;
 
    protected WebContext() {
    }
 
    public HttpServletRequest getRequest() {
        return request;
    }
 
    public void setRequest(HttpServletRequest request) {
        this.request = request;
    }
 
    public HttpServletResponse getResponse() {
        return response;
    }
 
    public void setResponse(HttpServletResponse response) {
        this.response = response;
    }
 
    public ServletContext getServletContext() {
        return servletContext;
    }
 
    public void setServletContext(ServletContext servletContext) {
        this.servletContext = servletContext;
    }
 
    private WebContext(HttpServletRequest request,
            HttpServletResponse response, ServletContext servletContext) {
        this.request = request;
        this.response = response;
        this.servletContext = servletContext;
    }
 
    public static WebContext getInstance() {
        return tlv.get();
    }
 
    public static void create(HttpServletRequest request,
            HttpServletResponse response, ServletContext servletContext) {
        WebContext wc = new WebContext(request, response, servletContext);
        tlv.set(wc);
    }
 
    public static void clear() {
        tlv.set(null);
    }
}

别忘了在web.xml中增加这个filter。 




OK，It is all。 




四、总结 

设计的一些要点： 

1、要便于程序员使用。程序员根据业务逻辑需要过滤字段时，只需要定义个"Filter“，然后使用注解引入该Filter。 

2、引入AOP来保持原来的REST风格。对于项目遗留的代码，不需要进行大幅度的修改，只需要增加注解来增加对过滤字段的支持。 

仍需解决的问题： 

按照目前的设计，定义的Filter不支持继承，每一种动态字段的业务需求就会产生一个Filter类，当类数量很多时，不便于管理。 




五、参考资料 

http://www.cowtowncoder.com/blog/archives/cat_json.html 

http://www.jroller.com/RickHigh/entry/filtering_json_feeds_from_spring

spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
JAVA 序列化 Jackson_SpringBoot系列——Jackson序列化
weixin_36256978的博客
02-24 734
前言Spring Boot提供了与三个JSON映射库的集成：GsonJacksonJSON-BJackson是首选的默认库。官网介绍：通常，我们将Java对象转成Json时称之为序列化，反之将Json转成Java对象时称之为反序列化，本文简单介绍一下Jackson，以及在SpringBoot项目开发中常用的Jackson方法如何引入SpringBoot提供了JSON依赖，我们可以按下面方式引入1、...
利用Jackson的JsonFilter来实现动态过滤数据列（数据列权限控制）
adsadadaddadasda的博客
08-13 4627
利用Jackson的JsonFilter来实现动态过滤数据列。 也就是说，同一个实体，你配置了不同的@JsonFilter,通过Jackson展现的结果可以是不一样的。 举个栗子： @lombok.Data public class User{ String username; String password; Integer age; String gender; ...
jackson-dynamic-filter:一种使用Jackson来动态确定过滤器的简便方法
04-27
杰克逊动态属性过滤器 基本上，当您使用Gson时，需要从目标对象上的序列化WITHOUT批注中排除特定字段，您将使用ExclusionStrategy 。 但是我在杰克逊没有找到类似的方法来做到这一点。 因此，此存储库提供了一种动态确定过滤器的简便方法，并且可以与Spring MVC / Spring Boot很好地集成。 对于Spring Boot： 要求 Java 8 支持的Spring IO平台： 下载 要使用Maven添加依赖项，请使用以下命令： < dependency> < groupId>com.github.shihyuho</ groupId> < artifactId>jackson-dynamic-filter</ artifactId> < version>1.0.1</ version> </ dependency> 要使用Gr
Jackson Mixin 详解
最新发布
若鱼的专栏
11-26 389
Mixin 是 Jackson 提供的一种机制，允许你在不修改原始类源码的情况下，为其添加或覆盖 Jackson 注解。它通过"混入"的方式，将注解逻辑与实体类定义分离。核心概念分离关注点：序列化规则与领域模型分离无侵入式：不需要修改原始类，适用于第三方库的类运行时绑定：在 ObjectMapper 级别配置，不影响类本身。
spring使用jackson实现json
07-02
spring使用jackson实现json
Jackson使用JsonFilter注解过滤字段
二进制之路
10-06 6619
通过《Jackson忽略字段不序列化字段的3种方法》一讲我们知道，JsonIgnore和JsonIgnoreProperties都可以用来忽略掉指定的字段。 这两个注解有个共同点，就是都在添加注解后就指明了需要过滤的字段。如果想要在序列化的时候，才指定需要过滤的字段，那么可以使用JsonFilter注解来实现。 本篇内容基于Jackson 2.11.2版本，马上开始学习吧。 过滤类的字段 为需要过滤字段的类添加JsonFilter注解。 @JsonFilter("myFilter") public clas
Jackson实现动态过滤
kelvin_hwk的博客
09-29 2860
Jackson实现属性过滤的几种方式 @JsonIgnore、@JsonIgnoreProperties 等注解，此注解需要配置在Model类的Class或Field上， 优点：简单、原生。 缺点：静态配置，不灵活，需要对Model类进行修改。 通过Jackson的Mixin功能（混入）,可将model类动态混入一些其他注解，相当于把Model类需要过滤的属性配置在其他类或接口上。当然，这种方案...
jackson-dynamic-filter-spring-boot-starter:使用Jackson轻松动态确定过滤器的简便方法
04-27
Jackson动态属性过滤器-Spring Boot Starter 用于Spring Boot Starter，它提供了一种简便的方法，可以通过动态确定过滤，而无需直接在Java对象上编写注释，并且还可以与Spring MVC / Spring Boot很好地集成。 先决...
Spring boot中Jackson的操作指南
08-26
Jackson 是一个功能强大且灵活的 JSON 处理器，在 Spring Boot 项目中，我们可以方便地使用 Jackson 来对 Java 对象进行 JSON 序列化和反序列化。但是，我们需要了解 Jackson 的基本使用和配置，以便更好地使用 ...
SpringBoot使用Jackson
weixin_71454352的博客
07-05 4021
SpringBoot使用Jackson
spring mvc 所需json jar包，jackson以及配置文件
12-18
在springmvc中需要用到json的地方要用到，以及一些配置。在springmvc中需要用到json的地方要用到，以及一些配置在springmvc中需要用到json的地方要用到，以及一些配置在springmvc中需要用到json的地方要用到，以及一些配置
Jackson包（适合spring4.X版本的使用）
04-27
对于Spring4.X版本的适合，因为Spring3.0和Spring4.0有使用差距
jackson工具类有动态属性过虑功能
01-31
jackson工具类有动态属性过虑功能.在业务应用中经常会有指定属性序列化json的需求,
jackson dynamic filter
rjgcx2的专栏
03-25 4393
import java.io.IOException; import java.util.HashSet; import java.util.Set; import org.codehaus.jackson.map.ObjectMapper; import org.codehaus.jackson.map.annotate.JsonFilter; import org.codehaus.jacks
Jackson API指南
ToBeMaybe_的博客
05-19 1166
Jackson 概述 与 依赖 市面上用于在 Java 中解析 Json 的第三方库，随便一搜不下几十种，其中的佼佼者有 Google 的 Gson， Alibaba 的 Fastjson 以及本文的 jackson。 我们在学习一门技术之前，首选要了解这门技术的优劣性，以及它和同等技术的对比。fastjson这么快老外为啥还是热衷 jackson? 使用 Jackson 导入 jackson-databind、 jackson-annotations、jackson-core 3 个主要模块
springboot集成jackson详解
qq_28754027的博客
04-04 6267
Spring Boot 默认使用 Jackson 作为 JSON 解析器Jackson 是一个流行的 Java 序列化和反序列化库，它能够将 Java 对象转换为 JSON 数据，也可以将 JSON 数据转换为 Java 对象。
springboot：Jackson的使用
拒绝熬夜啊的博客
06-02 1638
springboot：Jackson的使用
Jackson配置大全
小伍的程序之路
03-30 6770
jackson支持以下格式 Avro, BSON, CBOR, CSV, Smile, (Java) Properties, Protobuf, TOML, XML or YAML; 1.基础注解 注解 用法 @JsonProperty 用于属性，把属性的名称序列化时转换为另外一个名称。示例：@JsonProperty("birth_date") private Date birthDate @JsonIgnore 可用于字段、getter/setter、构造函数参数上，作用相同，都会对
轻松实现动态属性过滤：Jackson与Spring Boot集成
对于Jackson动态属性过滤器而言，Spring Boot Starter的作用在于自动配置相关的依赖项，使得开发者只需在项目中添加一个依赖声明，即可使用该过滤器提供的功能。 ### 知识点四：Jackson动态属性过滤器的集成与设置 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值