.NET Core返回值处理（手机身份证号码脱敏）的三种方式

在已有业务下面添加脱敏需求，不允许污染源方法，所以只能对返回值进行处理，这里列举两种方法，自定义序列化和过滤器。

自定义序列化应对所有用到该实体类的情况，过滤器应对只需要某一个或几个请求脱敏的情况；

如果仅仅处理脱敏，直接使用通用脱敏工具类即可。

通用脱敏工具类代码如下

public static class DesensitizationUtil
{
    /// <summary>
    /// 将传入的字符串中间部分字符替换成特殊字符
    /// </summary>
    /// <param name="value">需要替换的字符串</param>
    /// <param name="startLen">前保留长度，默认4</param>
    /// <param name="subLen">要替换的长度，默认4</param>
    /// <param name="specialChar">特殊字符，默认为*</param>
    /// <returns>替换后的结果</returns>
    public static string ReplaceWithSpecialChar(this string value, int startLen = 4, int subLen = 4, char specialChar = '*')
    {
        if (value.Length <= startLen + subLen) return value;
      
        string startStr = value.Substring(0, startLen);
        string endStr = value.Substring(startLen + subLen);
        string specialStr = new string(specialChar, subLen);

        return startStr + specialStr + endStr;
    }
}

 

---

方式一：JsonConverter

JsonConverter的方式对实体类进行修饰，所有用到该实体类的地方都会按照指定的格式输出。我们只需要输出时脱敏，所以将CanRead设置为false，关闭反序列化，同时ReadJson不填写逻辑代码；CanWrite设置为true，WriteJson中将返回值value脱敏后写入。

引用：

using Newtonsoft.Json;

具体代码：

public class DesensitizationConvter : JsonConverter
{
    //关闭反序列化
    public override bool CanRead => false;
    //开启自定义序列化
    public override bool CanWrite => true;
    public override bool CanConvert(Type objectType)
    {
        return true;
    }
    private readonly int StartLen;
    private readonly int SubLen;
    private readonly char SpecialChar;
    /// <summary>
    /// 默认前保留长度4，脱敏长度4，特殊字符为*
    /// </summary>
    public DesensitizationConvter()
    {
        StartLen = 4;
        SubLen = 4;
        SpecialChar = '*';
    }
    /// <summary>
    /// 根据传入的长度进行脱敏
    /// </summary>
    /// <param name="startLen">前保留长度</param>
    /// <param name="subLen">脱敏长度</param>
    public DesensitizationConvter(int startLen, int subLen) : this()
    {
        StartLen = startLen;
        SubLen = subLen;
    }
    /// <summary>
    /// 根据传入的长度及特殊字符进行脱敏
    /// </summary>
    /// <param name="startLen">前保留长度</param>
    /// <param name="subLen">脱敏长度</param>
    /// <param name="specialChar">替换的特殊字符</param>
    public DesensitizationConvter(int startLen, int subLen, char specialChar) : this(startLen, subLen)
    {
        SpecialChar = specialChar;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value != null)
        {
            writer.WriteValue(value.ToString().ReplaceWithSpecialChar(StartLen, SubLen, SpecialChar));
        }
    }
}

然后在实体类需要脱敏的属性上面加上修饰：

[JsonConverter(typeof(DesensitizationConvter))]
public string Phone { get; set; }

[JsonConverter(typeof(DesensitizationConvter), 3, 4)]
public string Phone2 { get; set; }

[JsonConverter(typeof(DesensitizationConvter), 4, 10, '*')]
public string IDCard { get; set; }

 WebApi请设置序列化工具类为Newtonsoft.Json，直接序列化方式为JsonConvert.SerializeObject(model)。

---

方式二：过滤器（JObject遍历）

过滤器Filter的方式相比较于Json序列化更加灵活，哪个请求需要脱敏，就加上修饰，不影响其他请求结果。

引用：

using Newtonsoft.Json.Linq;
using System.Linq;

构造函数中为需要脱敏的对象赋值，这里为了更加灵活，使用的是动态传参，然后处理成二维数组，支持多个属性、自定义脱敏位置的传参方式，包含需要脱敏的字段名称、前保留长度、脱敏长度、脱敏的特殊符号。

具体代码：

public class DesensitizationAttribute : Attribute, IActionFilter
{
    public string[][] Desensitizations { get; set; }
    // 动态传参，可以多个字段脱敏
    public DesensitizationAttribute(params string[] desensitizations)
    {
        Desensitizations = new string[desensitizations.Length][];
        for (int i = 0; i < desensitizations.Length; i++)
        {
            //处理中文逗号
            desensitizations[i] = desensitizations[i].Replace("，", ",");
            string[] str = desensitizations[i].Split(',');
            //准备脱敏的参数
            switch (str.Count())
            {
                case 1:
                    Desensitizations[i] = new string[4] { str[0].Trim(), "4", "4", "*" };
                    break;
                case 3:
                    Desensitizations[i] = new string[4] { str[0].Trim(), str[1].Trim(), str[2].Trim(), "*" };
                    break;
                case 4:
                    Desensitizations[i] = new string[4] { str[0].Trim(), str[1].Trim(), str[2].Trim(), str[3].Trim() };
                    break;
                default:
                    break;
            }
        }
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {

    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        if (context.Result != null && context.Result is ObjectResult)
        {
            ObjectResult obj = context.Result as ObjectResult;
            //转换成JObject
            JObject jo = JObject.FromObject(obj.Value);
            //如果已知需要替换的字段层级关系，直接查询脱敏即可，例如传入A.B.Phone
            //foreach (var item in Desensitizations)
            //{
            //    if (jo.SelectToken(item[0]) != null)
            //    {
            //        string newStr = jo.SelectToken(item[0]).ToString().ReplaceWithSpecialChar(Convert.ToInt32(item[1]), Convert.ToInt32(item[2]), Convert.ToChar(item[3]));
            //        jo.SelectToken(item[0]).Replace(newStr);
            //    }
            //}

            // 如果不知道层级，使用下面方法遍历JObject
            foreach (JToken item in jo.Values()){
                CommonReplaceConvter(item);
            }

            context.Result = new ObjectResult(jo);
        }
    }

    /// <summary>
    /// 递归遍历JToken脱敏
    /// </summary>
    /// <param name="jt"></param>
    public void CommonReplaceConvter(JToken jt)
    {
        if (jt == null) return;

        if (jt.HasValues && jt.Values().Count() > 0)
        {
            foreach (JToken item in jt.Values())
            {
                CommonReplaceConvter(item);
            }
        }
        else
        {
            string[] str = Desensitizations.FirstOrDefault(t => t[0] == jt.Path.Split('.').Last());

            if (str != null)
            {
                string result = jt == null ? "" : jt.ToString().ReplaceWithSpecialChar(Convert.ToInt32(str[1]), Convert.ToInt32(str[2]), Convert.ToChar(str[3]));
                jt.Replace(result);
            }
        }
    }
}

  最后在Controller上添加修饰，第一个参数表示Phone字段按照默认格式脱敏；第二个参数表示Phone2字段前面保留3位，脱敏长度为4，特殊字符为默认的*；第三个参数表示IDCard字段前面保留4位，脱敏长度为10，特殊字符为*(也可以改成自定义的字符)：

[Desensitization("Phone", "Phone2,3,4", "IDCard,4,10,*")]

 

---

方式三：过滤器（反射）

引用：

using System.Collections;
using System.Linq;
using System.Reflection;

此方法与第二种方法类似，只是替换的方式不同，这里用的是反射。

构造函数中为需要脱敏的对象赋值，这里用的是二维数组，包含需要脱敏的字段名称、前保留长度、脱敏长度、脱敏的特殊符号。具体传值方法请往下看。

具体代码：

public class DesensitizationAttribute : Attribute, IActionFilter
{
    public string[][] Desensitizations { get; set; }
    public DesensitizationAttribute(params string[] desensitizations)
    {
        Desensitizations = new string[desensitizations.Length][];
        for (int i = 0; i < desensitizations.Length; i++)
        {
            desensitizations[i] = desensitizations[i].Replace("，", ",");
            string[] str = desensitizations[i].Split(',');
            switch (str.Count())
            {
                case 1:
                    Desensitizations[i] = new string[4] { str[0].Trim(), "4", "4", "*" };
                    break;
                case 3:
                    Desensitizations[i] = new string[4] { str[0].Trim(), str[1].Trim(), str[2].Trim(), "*" };
                    break;
                case 4:
                    Desensitizations[i] = new string[4] { str[0].Trim(), str[1].Trim(), str[2].Trim(), str[3].Trim() };
                    break;
                default:
                    break;
            }
        }
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {

    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        if (context.Result != null && context.Result is ObjectResult)
        {
            ObjectResult obj = context.Result as ObjectResult;

            GetInfoPropertys(obj.Value);
            context.Result = obj;
        }
    }

    /// <summary>
    /// 反射的方式递归脱敏
    /// </summary>
    /// <param name="obj">需要脱敏的对象</param>
    public void GetInfoPropertys(object obj)
    {
        if (obj == null) return;
        Type type = obj.GetType();
        if (type.IsGenericType)
        {
            //如果是List，需要遍历
            if (obj is ICollection Ilist)
            {
                foreach (object o in Ilist)
                {
                    GetInfoPropertys(o);
                }
            }
            return;
        }
        foreach (PropertyInfo property in type.GetProperties())
        {
            object value = property.GetValue(obj, null);
            if (property.PropertyType.IsValueType || property.PropertyType.Name.StartsWith("String"))
            {
                string[] str = Desensitizations.FirstOrDefault(t => t[0] == property.Name);
                if (str != null)
                {
                    string result = value == null ? "" : value.ToString().ReplaceWithSpecialChar(Convert.ToInt32(str[1]), Convert.ToInt32(str[2]), Convert.ToChar(str[3]));
                    property.SetValue(obj, result, null);
                }
            }
            else
            {
                GetInfoPropertys(value);
            }
        }
    }
}

 同样在Controller上添加修饰：

[Desensitization("Phone", "Phone2,3,4", "IDCard,4,10,*")]