Json-lib的處理機制（3）--Filter接口

概述

Json-lib中的Filter都實現了這個接口net.sf.json.util.PropertyFilter
這個接口只有一個核心的方法：

public interface PropertyFilter {
   /**
    * @param source the owner of the property
    * @param name the name of the property
    * @param value the value of the property
    * @return true if the property will be filtered out, false otherwise
    */
   boolean apply( Object source, String name, Object value );
}

如果返回ture，則這個屬性被忽略，否則就會顯示這個屬性。這個功能就是當Java對象屬性過多，需要過濾一些屬性的時候，可以擴展這個Filter進行處理！

一個Filter的列子

public class MyPropertyFilter implements PropertyFilter {

    /**
     * 過濾掉birthday屬性
     */
    @Override
    public boolean apply(Object arg0, String arg1, Object arg2) {
        if(arg1.equals("birthday"))
        {
            return true;
        }
        else
        {
            return false;   
        }       
    }

    public static void main(String[] args) {
        // 萬能的MyObject
        MyObject obj = new MyObject();
        obj.name = "name11";
        obj.num = 100L;
        System.out.println(JSONObject.fromObject(obj));

        JsonConfig config = new JsonConfig();
        config.setJsonPropertyFilter(new MyPropertyFilter());

        JSONObject fromObject = JSONObject.fromObject(obj, config);
        System.out.println(fromObject.toString());
    }

}

控制檯輸出

{"birthday":null,"firstDay":null,"name":"name11","num":100,"son":null}
{"firstDay":null,"name":"name11","num":100,"son":null}

“brithday”沒有顯示，這個功能很好理解。可以根據我們實際情況進行適當的擴展！

默認實現

當然這個Filter也有很多默認的實現！都在filters這個目錄下：

類名	描述
AndPropertyFilter	兩個Filter都要忽略這個屬性的時候纔會忽略
CompositePropertyFilter	多個Filter，有一個忽略，就忽略
FalsePropertyFilter	是默認的Filter，全都不會略
MappingPropertyFilter	存儲多個Filter，可以自己實現關注的Filter處理邏輯
NotPropertyFilter	與另一個Filter互爲相反的效果
OrPropertyFilter	兩個Filter，滿足一個條件就忽略
TruePropertyFilter	被這個Filter匹配的屬性，直接忽略

AndPropertyFilter.java

/**
 * @author Andres Almiray <[email protected]>
 */
public class AndPropertyFilter implements PropertyFilter {
   private PropertyFilter filter1;
   private PropertyFilter filter2;

   public AndPropertyFilter( PropertyFilter filter1, PropertyFilter filter2 ) {
      this.filter1 = filter1;
      this.filter2 = filter2;
   }

   public boolean apply( Object source, String name, Object value ) {
      if( filter1 != null && filter1.apply( source, name, value ) && filter2 != null
            && filter2.apply( source, name, value ) ){
         return true;
      }
      return false;
   }
}

CompositePropertyFilter.java

/**
 * @author Andres Almiray <[email protected]>
 */
public class CompositePropertyFilter implements PropertyFilter {
   private List filters = new ArrayList();

   public CompositePropertyFilter() {
      this( null );
   }

   public CompositePropertyFilter( List filters ) {
      if( filters != null ){
         for( Iterator i = filters.iterator(); i.hasNext(); ){
            Object filter = i.next();
            if( filter instanceof PropertyFilter ){
               this.filters.add( filter );
            }
         }
      }
   }

   public void addPropertyFilter( PropertyFilter filter ) {
      if( filter != null ){
         filters.add( filter );
      }
   }

   public boolean apply( Object source, String name, Object value ) {
      for( Iterator i = filters.iterator(); i.hasNext(); ){
         PropertyFilter filter = (PropertyFilter) i.next();
         if( filter.apply( source, name, value ) ){
            return true;
         }
      }
      return false;
   }

   public void removePropertyFilter( PropertyFilter filter ) {
      if( filter != null ){
         filters.remove( filter );
      }
   }
}

FalsePropertyFilter.java

/**
 * @author Andres Almiray <[email protected]>
 */
public class FalsePropertyFilter implements PropertyFilter {
   public boolean apply( Object source, String name, Object value ) {
      return false;
   }
}

MappingPropertyFilter.java

抽象類

/**
 * @author Andres Almiray <[email protected]>
 */
public abstract class MappingPropertyFilter implements PropertyFilter {
   private Map filters = new HashMap();

   public MappingPropertyFilter() {
      this( null );
   }

   public MappingPropertyFilter( Map filters ) {
      if( filters != null ){
         for( Iterator i = filters.entrySet()
               .iterator(); i.hasNext(); ){
            Map.Entry entry = (Map.Entry) i.next();
            Object key = entry.getKey();
            Object filter = entry.getValue();
            if( filter instanceof PropertyFilter ){
               this.filters.put( key, filter );
            }
         }
      }
   }

   public void addPropertyFilter( Object target, PropertyFilter filter ) {
      if( filter != null ){
         filters.put( target, filter );
      }
   }

   public boolean apply( Object source, String name, Object value ) {
      for( Iterator i = filters.entrySet()
            .iterator(); i.hasNext(); ){
         Map.Entry entry = (Map.Entry) i.next();
         Object key = entry.getKey();
         if( keyMatches( key, source, name, value ) ){
            PropertyFilter filter = (PropertyFilter) entry.getValue();
            return filter.apply( source, name, value );
         }
      }
      return false;
   }

   public void removePropertyFilter( Object target ) {
      if( target != null ){
         filters.remove( target );
      }
   }

   protected abstract boolean keyMatches( Object key, Object source, String name, Object value );
}

NotPropertyFilter.java

/**
 * @author Andres Almiray <[email protected]>
 */
public class NotPropertyFilter implements PropertyFilter {
   private PropertyFilter filter;

   public NotPropertyFilter( PropertyFilter filter ) {
      this.filter = filter;
   }

   public boolean apply( Object source, String name, Object value ) {
      if( filter != null ){
         return !filter.apply( source, name, value );
      }
      return false;
   }
}

OrPropertyFilter.java

/**
 * @author Andres Almiray <[email protected]>
 */
public class OrPropertyFilter implements PropertyFilter {
   private PropertyFilter filter1;
   private PropertyFilter filter2;

   public OrPropertyFilter( PropertyFilter filter1, PropertyFilter filter2 ) {
      this.filter1 = filter1;
      this.filter2 = filter2;
   }

   public boolean apply( Object source, String name, Object value ) {
      if( (filter1 != null && filter1.apply( source, name, value ))
            || (filter2 != null && filter2.apply( source, name, value )) ){
         return true;
      }
      return false;
   }
}

TruePropertyFilter.java

/**
 * @author Andres Almiray <[email protected]>
 */
public class TruePropertyFilter implements PropertyFilter {
   public boolean apply( Object source, String name, Object value ) {
      return true;
   }
}