在hibernate 中比 SimplePropertyPreFilter 還要好用的過濾類

比官方自帶的過濾類(SimplePropertyPreFilter )還好用，那肯定是自定義的啦！

先講下結果吧,看是不是諸位要的:

• 能過濾類中的屬性類，無論是Set集合，List集合,還是EJB都能過濾
• 能解決多對多,或者是一對多，一對一等關係對映死迴圈，資料返回資料多，雜，亂等特點
• 做json的主宰，想要返回的資料是哪些欄位就返回哪些欄位
• 簡單上手

好吧上程式碼:

package intercepter;

import com.alibaba.fastjson.JSON;
import
 
 com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.PropertyPreFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import model.wudun.Articles;
import model.wudun.Comment;
import model.wudun.Member;

import java.util.*;

/**
 * @Author：wj
 * @Date：Created in 15:16 2018/1/5
 * @Description
 
：用 fasjson 對 hibernate 級聯關係進行過濾
 */
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;
    }

    public static void main(String[] args) {
        // use instanceOf，用來判斷物件是否是類的例項
        // use isAssignableFrom()，用來判斷型別間是否有繼承關係
        // use isInstance()，用來判斷物件是否是類的例項
        //setExcludes()，進行過濾的類！！！！

        Class<?> intClass = Integer.class;

        // Create various objects.
        String str = "Hello";
        Date date = new Date();
        Integer i = new Integer(10);

        // Is str an instance of class Integer?
        boolean check1 = intClass.isInstance(str);
        System.out.println("str is an Integer? " + check1);

        // Is date an instance of class Integer?
        boolean check2 = intClass.isInstance(date);
        System.out.println("date is an Integer? " + check2);

        // Is i an instance of class Integer?
        boolean check3 = intClass.isInstance(i);
        System.out.println("i is an Integer? " + check3);

        System.out.println(Articles.class.isInstance(new Comment()));
        System.out.println(Comment.class.isInstance(new Articles()));

        System.out.println(Articles.class.isAssignableFrom(Member.class));

//這裡是測試程式碼！！ 博主一些EJB類  不要糾結導不出來！！！！  不要糾結導不出來！！！！  不要糾結導不出來！！！！ 
       List<Articles> articlesList = new ArrayList<>(0);
        Articles articles = new Articles();
        articles.setId("articles_1");

        Comment comment = new Comment();
        comment.setCommentId("comment_1");

        Member member = new Member();

        member.setId("member_1");

        articles.setMember(member);

        Set<Articles> articlesSet = new LinkedHashSet<>(0);
        articlesSet.add(articles);
        member.setArticlesCollect(articlesSet);


        Set<Member> memberSet = new LinkedHashSet<>(0);
        memberSet.add(member);
        articles.setMemberSet(memberSet);


        Set<Comment> commentSet = new LinkedHashSet<>(0);
        commentSet.add(comment);
        articles.setComments(commentSet);


        member.setCommentSet(commentSet);

        comment.setMember(member);

        articlesList.add(articles);
        ComplexPropertyPreFilter filter = new ComplexPropertyPreFilter();

        filter.setExcludes(new HashMap<Class<?>, String[]>() {

            private static final long serialVersionUID = -8411128674046835592L;//我也不知道這是幹嘛的   刪除或者不寫不會影響其功能和效果

            {   //物件 Articles中  : 多對多屬性：giveRewardSet(Set集合)  memberSet(Set集合)
                put(Articles.class, new String[] { "giveRewardSet","memberSet"});//放入過濾的物件，然後是需要過濾的物件裡的屬性
                //物件Comment :commentId(Comment物件中普通的屬性),  member(Comment物件中物件屬性)
                put(Comment.class, new String[] { "commentId", "member" });
                //物件Member :nickname(Member物件中普通的屬性) 多對多屬性: articlesCollect(Set集合)
                put(Member.class, new String[] { "nickname", "articlesCollect" });
                //當然  多對一  一對一也是可以過濾的啦！！！   如果還有不清楚的歡迎詢問
            }
        });
        System.out.println(JSON.toJSONString(articlesList, filter));
    }
}

謝謝！若有問題歡迎踩………
由於被博主遇到這個問題深感頭疼 然後機緣巧合的狀況下刷到部落格，覺得該博主部落格不是很詳細沒有很好的說明這個實體類的強大效能，然後博主覺得這篇部落格埋沒於碼海中是在可以故此轉發 , 脫茂!!:
https://www.cnblogs.com/sandyfog/articles/3679804.html
                                                                                                                        向老前輩致敬