`
coocaobo
  • 浏览: 9258 次
社区版块
存档分类
最新评论

spring MVC 对 ResponseBody返回json数据进行脱敏处理

阅读更多

为了对springmvc框架中的json请求数据进行可控制的脱敏处理,研究了配置message-converters里面的内容,并通过重写部分方法进行脱敏修改

 

 

  • 配置message-converters 

 

  <mvc:annotation-driven>
        <!-- 处理responseBody 返回结果 -->
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <!--<bean class="com.fasterxml.jackson.databind.ObjectMapper">-->
                    <bean class="com.ez.core.servlet.SensitiveObjectMapper">
                        <property name="dateFormat">
                            <bean class="java.text.SimpleDateFormat">
                                <constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" />
                            </bean>
                        </property>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

 

  • 需要重写的类有 “com.fasterxml.jackson.databind.ObjectMapper”, “com.fasterxml.jackson.databind.MappingJsonFactory”,“com.fasterxml.jackson.core.json.UTF8JsonGenerator”;

 

package com.ez.core.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.DefaultDeserializationContext;
import com.fasterxml.jackson.databind.ser.DefaultSerializerProvider;

/**
 * Created by Administrator on 2018/2/8.
 */
public class SensitiveObjectMapper extends ObjectMapper {

    /**
     * 对弗雷的jsonfactory使用自定义工厂
     */
    public SensitiveObjectMapper() {
        super(new SensitiveJsonFactory(), (DefaultSerializerProvider) null, (DefaultDeserializationContext) null);
    }
}

 

 

 

package com.ez.core.servlet;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.SerializableString;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.json.UTF8JsonGenerator;
import com.fasterxml.jackson.databind.MappingJsonFactory;

import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;

/**
 * Created by Administrator on 2018/2/8.
 */
public class SensitiveJsonFactory extends MappingJsonFactory {
    public SensitiveJsonFactory() {
        super();
    }

    public JsonGenerator createGenerator(OutputStream out, JsonEncoding enc) throws IOException {
        IOContext ctxt = this._createContext(out, false);
        ctxt.setEncoding(enc);
        if (enc == JsonEncoding.UTF8) {
            return this._createUTF8Generator(this._decorate(out, ctxt), ctxt);
        } else {
            Writer w = this._createWriter(out, enc, ctxt);
            return this._createGenerator(this._decorate(w, ctxt), ctxt);
        }
    }

    /**
     * 主要是重写该方法,对需要进行脱敏处理的数据,使用 SensitiveUTF8JsonGenerator 处理,
     * 不需要脱敏的数据,还是按照原来的路径进行处理
     * @param out
     * @param ctxt
     * @return
     * @throws IOException
     */
    protected JsonGenerator _createUTF8Generator(OutputStream out, IOContext ctxt) throws IOException {
        UTF8JsonGenerator gen = null;
        boolean needSensitive = !true;

        if (needSensitive) {
            gen = new SensitiveUTF8JsonGenerator(ctxt, this._generatorFeatures, this._objectCodec, out);
        } else {
            gen = new UTF8JsonGenerator(ctxt, this._generatorFeatures, this._objectCodec, out);
        }

        if (this._characterEscapes != null) {
            gen.setCharacterEscapes(this._characterEscapes);
        }

        SerializableString rootSep = this._rootValueSeparator;
//        if (rootSep != _rootValueSeparator) {
//        if(rootSep != DEFAULT_ROOT_VALUE_SEPARATOR) {
        gen.setRootValueSeparator(rootSep);
//        }

        return gen;
    }


}

 

 最后需要对真正写入流的方法进行重写,通过判断是否需要进行脱敏处理,然后根据具体的脱敏规则进行处理,判断时可能需要通过当前数据的路径进行判断,所以增加了basePath存储先关路径,一般脱敏规则,是将相关数据替换为***

package com.ez.core.servlet;

import com.fasterxml.jackson.core.Base64Variant;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.core.SerializableString;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.json.UTF8JsonGenerator;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.math.BigInteger;

/**
 * Created by Administrator on 2018/2/8.
 */
public class SensitiveUTF8JsonGenerator extends UTF8JsonGenerator {

    private StringBuffer basePath = new StringBuffer();

    //    private String[] path = new String[];
    public SensitiveUTF8JsonGenerator(IOContext ctxt, int features, ObjectCodec codec, OutputStream out) {
        super(ctxt, features, codec, out);
    }

    public SensitiveUTF8JsonGenerator(IOContext ctxt, int features, ObjectCodec codec, OutputStream out, byte[] outputBuffer, int outputOffset, boolean bufferRecyclable) {
        super(ctxt, features, codec, out, outputBuffer, outputOffset, bufferRecyclable);
    }


    private void addPath(SerializableString name) {
        this.basePath.append(".").append(name);
    }

    private void addPath(String name) {
        this.basePath.append(".").append(name);
    }

    private void deleteOnePath() {
        int index = basePath.lastIndexOf(".");
        if (index != -1) {
            basePath.delete(index, basePath.length());
        }

    }

    private void dealRemovePath() {
        deleteOnePath();
    }

    public void writeFieldName(SerializableString name) throws IOException {
        addPath(name);
        super.writeFieldName(name);
    }

    public void writeFieldName(String name) throws IOException {
        addPath(name);
        super.writeFieldName(name);
    }

    public void writeString(String text) throws IOException {
        text = sensitiveTransfer(text);
        super.writeString(text);
    }


    public void writeString(Reader reader, int len) throws IOException {
        super.writeString(reader, len);
        dealRemovePath();
    }

    public void writeString(char[] text, int offset, int len) throws IOException {
        super.writeString(text, offset, len);
        dealRemovePath();
    }

    public void writeRawUTF8String(byte[] text, int offset, int length) throws IOException {
        super.writeRawUTF8String(text, offset, length);
        dealRemovePath();
    }

    public void writeUTF8String(byte[] text, int offset, int len) throws IOException {
        super.writeUTF8String(text, offset, len);
        dealRemovePath();
    }

    public void writeBinary(Base64Variant a, byte[] b, int c, int d) throws IOException, JsonGenerationException {
        super.writeBinary(a, b, c, d);
        dealRemovePath();
    }

    public int writeBinary(Base64Variant a, InputStream b, int c) throws IOException, JsonGenerationException {
        int ret = super.writeBinary(a, b, c);
        dealRemovePath();
        return ret;
    }


    public void writeNumber(short s) throws IOException {
        super.writeNumber(s);
        sensitiveTransfer(s);
    }

    private void sensitiveTransfer(short s) {
        sensitiveTransfer(s);
    }


    public void writeNumber(int i) throws IOException {
        super.writeNumber(i);
        sensitiveTransfer(i);
    }

    private void sensitiveTransfer(int i) {
        dealRemovePath();
    }

    public void writeNumber(long l) throws IOException {
        super.writeNumber(l);
        sensitiveTransfer(l);
    }

    private void sensitiveTransfer(long l) {
        dealRemovePath();
    }


    public void writeNumber(BigInteger value) throws IOException {
        super.writeNumber(value);
        sensitiveTransfer(value);
    }

    private void sensitiveTransfer(BigInteger value) {
        dealRemovePath();
    }

    public void writeNumber(double d) throws IOException {
        super.writeNumber(d);
        sensitiveTransfer(d);
    }

    private void sensitiveTransfer(double d) {
        dealRemovePath();
    }


    public void writeNumber(float f) throws IOException {
        super.writeNumber(f);
        sensitiveTransfer(f);
    }

    private void sensitiveTransfer(float f) {
        dealRemovePath();
    }

    public void writeNumber(BigDecimal value) throws IOException {
        super.writeNumber(value);
        sensitiveTransfer(value);
    }

    private void sensitiveTransfer(BigDecimal value) {
        dealRemovePath();
    }

    public void writeNumber(String encodedValue) throws IOException {
        encodedValue = sensitiveTransfer(encodedValue);
        super.writeNumber(encodedValue);
    }

    private String sensitiveTransfer(String encodedValue) {
        /**
         * 判断是否需要进行脱敏
         * 根据 basePath 和脱敏规则;
         */

//        String ret = encodedValue ;
        String ret = encodedValue + "脱敏";

//        System.out.println("basePath: " + basePath);
//        try {
//            System.out.println(new String(this._outputBuffer, "UTF-8"));
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//        }
        dealRemovePath();
        return ret;
    }


    public void writeBoolean(boolean state) throws IOException {
        super.writeBoolean(state);
        sensitiveTransfer(state);
    }

    private void sensitiveTransfer(boolean state) {
        /**
         * 判断是否需要进行脱敏
         * 根据 basePath 和脱敏规则;
         */
        dealRemovePath();
    }

    public void writeNull() throws IOException {
        super.writeNull();
        dealRemovePath();
    }


}

 

分享到:
评论

相关推荐

    spring mvc(整合了json)

    4. **控制器方法的编写**:在 Spring MVC 的控制器类中,我们可以定义处理 HTTP 请求的方法,并使用 `@RequestBody` 和 `@ResponseBody` 注解来接收和返回 JSON 数据。例如: ```java @RequestMapping(value = "/...

    spring Mvc配置xml使ResponseBody返回Json的方法示例

    在Spring MVC框架中,使用`@ResponseBody`注解可以方便地将控制器方法的返回值转换为JSON格式,然后发送到客户端。本篇文章将详细介绍如何在Spring MVC的XML配置中设置,以便让`@ResponseBody`自动将Java对象转换为...

    spring mvc json&&jackson jquery js

    1. **创建Controller**:定义Spring MVC的控制器类,使用`@RequestMapping`注解映射URL,并使用`@ResponseBody`返回JSON数据。 2. **配置Jackson**:在Spring配置文件中启用Jackson并配置其属性,如日期格式化。 3. ...

    spring mvc生成xml或json

    在Spring MVC框架中,开发人员经常需要处理不同的数据交换格式,如XML和JSON,以便与客户端进行交互。这两种格式在Web应用中广泛用于传输数据,因为它们轻量级且易于解析。下面我们将深入探讨如何在Spring MVC中生成...

    Spring MVC返回JSON数据 用到的jar包

    在开发Web应用时,Spring MVC框架是Java领域中广泛使用的MVC模式实现,它提供了强大的数据绑定、模型视图分离以及请求处理等功能。在现代Web应用中,常常需要与前端进行异步通信,这就涉及到了JSON数据的交换。JSON...

    springmvc操作json数据所需的jar包

    在Spring MVC框架中,处理JSON数据是Web应用开发中的常见任务。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,它使得前后端数据交互变得更加简单和直观。本篇文章将详细讲解在Spring MVC中如何...

    第三章 Spring MVC Servlet API与Json的支持

    Spring MVC提供了对JSON的支持,主要通过`org.springframework.web.bind.annotation.RequestMapping`和`@ResponseBody`注解实现。当一个控制器方法返回一个对象时,如果添加了`@ResponseBody`注解,Spring MVC会自动...

    Spring3 MVC Ajax with JSON

    这个项目提供的示例工程应该包含了一个工作流程的完整实例,从Ajax请求到Spring MVC的处理,再到JSON响应的返回,帮助开发者理解并掌握这一技术栈的使用。通过深入研究和实践,你将能够熟练地在自己的项目中应用这些...

    Spring mvc Json处理实现流程代码实例

    总结,Spring MVC处理JSON数据的关键在于`@RequestBody`和`@ResponseBody`注解以及HttpMessageConverter。`@RequestBody`用于将JSON请求体映射到方法参数,`@ResponseBody`用于将方法返回值转换为JSON响应。通过集成...

    用Spring MVC 搭建JSON 数据服务器(二)

    在本教程中,我们将深入探讨如何使用Spring MVC框架构建一个返回JSON格式数据的服务器。首先,这个项目涉及的技术栈包括Spring MVC、JDBC、JSON以及Gson。Spring MVC是Spring框架的一部分,它允许我们构建RESTful ...

    Spring MVC – Easy REST-Based JSON Services with @ResponseBody

    `@ResponseBody`是Spring MVC中的一个关键注解,它允许我们将方法返回的对象直接转换为HTTP响应体的内容,通常用于处理JSON或XML格式的数据。 Spring MVC是Spring框架的一部分,专门用于构建Web应用。它提供了模型-...

    spring boot @ResponseBody转换JSON 时 Date 类型处理方法【两种方法】

    在Spring Boot应用中,当你使用`@ResponseBody`注解将对象转换为JSON并发送到客户端时,日期(Date)类型的字段通常需要特殊处理,因为它们默认可能会被转换为Unix时间戳或者不友好的格式。本篇文章主要介绍了两种...

    用Spring MVC 搭建JSON 数据服务器

    在这个过程中,我们将学习如何使用 Spring MVC 来创建一个返回 JSON 格式数据的服务器,以及如何在 Android 应用中消费这些数据。 ### 第一部分:环境准备 1. **Eclipse Neon**:这是一个集成开发环境,用于编写 ...

    四. Spring MVC 3 支持json及 常见错误解决

    4. **JSON与Ajax**:Spring MVC 3与jQuery或其他JavaScript库配合,可以方便地实现Ajax请求和响应,以JSON形式进行数据交换。 **二、常见错误解决** 1. **406 Not Acceptable**:这个错误通常是因为客户端没有在...

    spring-mvc-jsonview源代码

    当返回类型为@RequestBody或@ResponseBody时,Spring MVC会自动将返回的对象转换为JSON,发送到客户端。 三、源代码分析 1. pom.xml:项目依赖管理文件,包含了Spring MVC、Jackson库和其他相关依赖。例如,添加...

    SpringMVC返回JSON数据相关Jar包

    在这个“SpringMVC返回JSON数据相关Jar包”中,包含了支持SpringMVC处理JSON数据所需的关键组件。 首先,我们需要理解SpringMVC如何处理JSON数据。在SpringMVC中,我们使用`@ResponseBody`注解标记在Controller方法...

    spring mvc json学习

    在本文中,我们将深入探讨“Spring MVC JSON学习”这一主题,重点关注如何在Spring MVC应用中处理JSON数据。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,因其简洁性和易读性而被广泛应用。 ...

    Springmvc 4.x利用@ResponseBody返回Json数据的方法

    在Spring MVC 4.x版本中,开发者可以使用@ResponseBody注解来简化控制器层向客户端返回JSON格式数据的过程。 ### @ResponseBody注解使用方法 @ResponseBody注解可以作用于方法上,它会指示Spring MVC框架将该方法...

    springmvc对json支持

    总结起来,Spring MVC对JSON的支持主要依赖于Jackson库,通过`@ResponseBody`和`@RequestBody`注解实现数据交换,配合注解进行类型转换控制,同时允许开发者自定义序列化和反序列化行为,以及配置错误处理机制。...

Global site tag (gtag.js) - Google Analytics