1 package com.example.util.fastjson;
  2       
  3 import java.util.Date;
  4 import java.util.HashMap;
  5 import java.util.Map;
  6       
  7 import com.alibaba.fastjson.JSON;
  8 import com.alibaba.fastjson.serializer.JSONSerializer;
  9 import com.alibaba.fastjson.serializer.PropertyPreFilter;
 
 10 import com.alibaba.fastjson.serializer.SerializerFeature;
 11 import com.suncompass.example.auth.entity.AuthEmployee;
 12 import com.suncompass.example.auth.entity.AuthMenu;
 13 import com.suncompass.framework.base.entity.BaseEntity;
 14       
 15 /**
 16  * @author ：晨風²º¹³ <br>
 17  * @Comment ： fastjson 針對型別的屬性選擇過濾器(可以跨層級) <br>
 
 18  */
 19 public class ComplexPropertyPreFilter implements PropertyPreFilter {
 20           
 21     private Map<Class<?>, String[]> includes = new HashMap<>();
 22     private Map<Class<?>, String[]> excludes = new HashMap<>();
 23           
 24     static
 
 {
 25         JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.DisableCircularReferenceDetect.getMask();
 26     }
 27           
 28     public ComplexPropertyPreFilter() {
 29               
 30     }
 31           
 32     public ComplexPropertyPreFilter(Map<Class<?>, String[]> includes) {
 33         super();
 34         this.includes = includes;
 35     }
 36           
 37     public boolean apply(JSONSerializer serializer, Object source, String name) {
 38               
 39         //物件為空。直接放行
 40         if (source == null) {
 41             return true;
 42         }
 43               
 44         // 獲取當前需要序列化的物件的類物件
 45         Class<?> clazz = source.getClass();
 46               
 47         // 無需序列的物件、尋找需要過濾的物件，可以提高查詢層級
 48         // 找到不需要的序列化的型別
 49         for (Map.Entry<Class<?>, String[]> item : this.excludes.entrySet()) {
 50             // isAssignableFrom()，用來判斷型別間是否有繼承關係
 51             if (item.getKey().isAssignableFrom(clazz)) {
 52                 String[] strs = item.getValue();
 53                       
 54                 // 該型別下 此 name 值無需序列化
 55                 if (isHave(strs, name)) {
 56                     return false;
 57                 }
 58             }
 59         }
 60               
 61         // 需要序列的物件集合為空 表示 全部需要序列化
 62         if (this.includes.isEmpty()) {
 63             return true;
 64         }
 65               
 66         // 需要序列的物件
 67         // 找到不需要的序列化的型別
 68         for (Map.Entry<Class<?>, String[]> item : this.includes.entrySet()) {
 69             // isAssignableFrom()，用來判斷型別間是否有繼承關係
 70             if (item.getKey().isAssignableFrom(clazz)) {
 71                 String[] strs = item.getValue();
 72                 // 該型別下 此 name 值無需序列化
 73                 if (isHave(strs, name)) {
 74                     return true;
 75                 }
 76             }
 77         }
 78               
 79         return false;
 80     }
 81           
 82     /*
 83      * 此方法有兩個引數，第一個是要查詢的字串陣列，第二個是要查詢的字元或字串
 84      */
 85     public static boolean isHave(String[] strs, String s) {
 86               
 87         for (int i = 0; i < strs.length; i++) {
 88             // 迴圈查詢字串陣列中的每個字串中是否包含所有查詢的內容
 89             if (strs[i].equals(s)) {
 90                 // 查詢到了就返回真，不在繼續查詢
 91                 return true;
 92             }
 93         }
 94               
 95         // 沒找到返回false
 96         return false;
 97     }
 98           
 99     public Map<Class<?>, String[]> getIncludes() {
100         return includes;
101     }
102           
103     public void setIncludes(Map<Class<?>, String[]> includes) {
104         this.includes = includes;
105     }
106           
107     public Map<Class<?>, String[]> getExcludes() {
108         return excludes;
109     }
110           
111     public void setExcludes(Map<Class<?>, String[]> excludes) {
112         this.excludes = excludes;
113     }
114           
115     public static void main(String[] args) {
116         // use instanceOf，用來判斷物件是否是類的例項
117         // use isAssignableFrom()，用來判斷型別間是否有繼承關係
118         // use isInstance()，用來判斷物件是否是類的例項
119               
120         Class<?> intClass = Integer.class;
121               
122         // Create various objects.
123         String str = "Hello";
124         Date date = new Date();
125         Integer i = new Integer(10);
126               
127         // Is str an instance of class Integer?
128         boolean check1 = intClass.isInstance(str);
129         System.out.println("str is an Integer? " + check1);
130               
131         // Is date an instance of class Integer?
132         boolean check2 = intClass.isInstance(date);
133         System.out.println("date is an Integer? " + check2);
134               
135         // Is i an instance of class Integer?
136         boolean check3 = intClass.isInstance(i);
137         System.out.println("i is an Integer? " + check3);
138               
139         System.out.println(BaseEntity.class.isInstance(new AuthEmployee()));
140         System.out.println(AuthEmployee.class.isInstance(new AuthMenu()));
141               
142         System.out.println(BaseEntity.class.isAssignableFrom(AuthEmployee.class));
143     }
144 }