3

13693261870

2022-09-16 63ba114e70e380442fcbed4a5157ee52c9491216

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package com.landtool.lanbase.common.utils;
 
import java.util.HashMap;
import java.util.Map;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.PropertyPreFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;
 
/**
 * @Description: fastjson 针对类型的属性选择过滤器(可以跨层级) <br> {@link PropertyPreFilter}
 * @Author: zimao.guo
 * @Date: 16:33 2018/3/2
 */
public class ComplexPropertyPreFilter implements PropertyPreFilter {
 
    private Map<Class<?>, String[]> includes = new HashMap<>();
    private Map<Class<?>, String[]> excludes = new HashMap<>();
 
    static {
        JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.DisableCircularReferenceDetect.getMask();
    }
 
    public ComplexPropertyPreFilter() {
 
    }
 
    public ComplexPropertyPreFilter(Map<Class<?>, String[]> includes) {
        super();
        this.includes = includes;
    }
 
    public boolean apply(JSONSerializer serializer, Object source, String name) {
 
        //对象为空。直接放行
        if (source == null) {
            return true;
        }
 
        // 获取当前需要序列化的对象的类对象
        Class<?> clazz = source.getClass();
 
        // 无需序列的对象、寻找需要过滤的对象，可以提高查找层级
        // 找到不需要的序列化的类型
        for (Map.Entry<Class<?>, String[]> item : this.excludes.entrySet()) {
            // isAssignableFrom()，用来判断类型间是否有继承关系
            if (item.getKey().isAssignableFrom(clazz)) {
                String[] strs = item.getValue();
 
                // 该类型下 此 name 值无需序列化
                if (isHave(strs, name)) {
                    return false;
                }
            }
        }
 
        // 需要序列的对象集合为空 表示 全部需要序列化
        if (this.includes.isEmpty()) {
            return true;
        }
 
        // 需要序列的对象
        // 找到不需要的序列化的类型
        for (Map.Entry<Class<?>, String[]> item : this.includes.entrySet()) {
            // isAssignableFrom()，用来判断类型间是否有继承关系
            if (item.getKey().isAssignableFrom(clazz)) {
                String[] strs = item.getValue();
                // 该类型下 此 name 值无需序列化
                if (isHave(strs, name)) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    /*
     * 此方法有两个参数，第一个是要查找的字符串数组，第二个是要查找的字符或字符串
     */
    public static boolean isHave(String[] strs, String s) {
 
        for (int i = 0; i < strs.length; i++) {
            // 循环查找字符串数组中的每个字符串中是否包含所有查找的内容
            if (strs[i].equals(s)) {
                // 查找到了就返回真，不在继续查询
                return true;
            }
        }
 
        // 没找到返回false
        return false;
    }
 
    public Map<Class<?>, String[]> getIncludes() {
        return includes;
    }
 
    public void setIncludes(Map<Class<?>, String[]> includes) {
        this.includes = includes;
    }
 
    public Map<Class<?>, String[]> getExcludes() {
        return excludes;
    }
 
    public void setExcludes(Map<Class<?>, String[]> excludes) {
        this.excludes = excludes;
    }
 
}