gson/src/java/org/apache/fulcrum/json/gson/GSONBuilderService.java - turbine-fulcrum-json - Git at Google

     package org.apache.fulcrum.json.gson;

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 import java.lang.reflect.Type;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.EnumSet;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Set;
 import java.util.concurrent.Callable;

 import org.apache.avalon.framework.activity.Initializable;
 import org.apache.avalon.framework.configuration.Configurable;
 import org.apache.avalon.framework.configuration.Configuration;
 import org.apache.avalon.framework.configuration.ConfigurationException;
 import org.apache.avalon.framework.logger.AbstractLogEnabled;
 import org.apache.fulcrum.json.JsonService;

 import com.google.gson.ExclusionStrategy;
 import com.google.gson.FieldAttributes;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.reflect.TypeToken;
 import com.jayway.jsonpath.Option;
 import com.jayway.jsonpath.spi.json.GsonJsonProvider;
 import com.jayway.jsonpath.spi.json.JsonProvider;
 import com.jayway.jsonpath.spi.mapper.GsonMappingProvider;
 import com.jayway.jsonpath.spi.mapper.MappingProvider;

 /**
  *
  * By default multiple serialization of the same object in a single thread is
  * not support (e.g adapter + default for the same bean / object).
  *
  *
  * @author gk
  * @version $Id$
  *
  */
 public class GSONBuilderService extends AbstractLogEnabled implements
         JsonService, Initializable, Configurable {

     private static final String GLOBAL_ADAPTERS = "globalAdapters";

     private static final String DATE_FORMAT = "dateFormat";

     private static final String USEJSONPATH = "useJsonPath";

     private String dateFormat;

     private Hashtable<String, String> adapters = null;

     private boolean useJsonPath = false;

     GsonBuilder gson;

     @Override
     public String ser(Object src) throws Exception {
         getLogger().debug("ser" + src);
         return gson.create().toJson(src);
     }

     @Override
     public <T> String ser(Object src, Class<T> type) throws Exception {
         getLogger().debug("ser::" + src + " with type" + type);

         Type collectionType = new TypeToken<T>() {
         }.getType();
         return gson.create().toJson(src, collectionType);
     }

     @Override
     public <T> T deSer(String json, Class<T> type) throws Exception {
         // TODO Auto-generated method stub
         getLogger().debug("deser:" + json);
         return gson.create().fromJson(json, type);
     }

     @Override
     public <T> Collection<T> deSerCollection(String json, Object collectionType,
             Class<T> elementType) throws Exception {
         getLogger().debug("deser:" + json);
         getLogger().debug("collectionType:" + collectionType);
         return  gson.create().fromJson(json, (Type)collectionType);
     }

     @Override
     public String serializeOnlyFilter(Object src, String... filterAttr)
             throws Exception {
         return  gson
                 .addSerializationExclusionStrategy(
                         include(null,filterAttr)).create().toJson(src);
     }

     @Override
     public String serializeOnlyFilter(Object src, Boolean notused,
             String... filterAttr) throws Exception {
         return  gson
                 .addSerializationExclusionStrategy(
                         include(null,filterAttr)).create().toJson(src);
     }

     @Override
     public <T> String serializeOnlyFilter(Object src, Class<T> filterClass,
             String... filterAttr) throws Exception {
         return  gson
         .addSerializationExclusionStrategy(
                 include(filterClass, filterAttr)).create().toJson(src);
     }

     @Override
     public <T> String serializeOnlyFilter(Object arg0, Class<T> arg1,
             Boolean arg2, String... arg3) throws Exception {
         throw new Exception("Not yet implemented!");
     }

     /**
      * registering an adapter
      *
      * @see GsonBuilder#registerTypeAdapter(Type, Object)
      */
     @Override
     public JsonService addAdapter(String name, Class target, Object adapter)
             throws Exception {
         gson.registerTypeAdapter(target, adapter);
         return this;
     }

     /**
      * registering an adapter. Unregistering could be only done by reinitialize {@link GsonBuilder}
      * using @link {@link GSONBuilderService#initialize()}, although a new Adapter with the same target overwrites the previously defined.
      *
      * @see GsonBuilder#registerTypeAdapter(Type, Object)
      */
     @Override
     public JsonService addAdapter(String name, Class target, Class adapter)
             throws Exception {
         gson.registerTypeAdapter(target, adapter.getConstructor().newInstance());
         return null;
     }

     @Override
     public <T> String serializeAllExceptFilter(Object src,
             Class<T> filterClass, String... filterAttr) throws Exception {
         return gson
                 .addSerializationExclusionStrategy(
                         exclude(filterClass, filterAttr)).create().toJson(src);
     }

     @Override
     public <T> String serializeAllExceptFilter(Object src, Class<T> filterClass,
             Boolean clearCache, String... filterAttr) throws Exception {
         throw new Exception("Not yet implemented!");
     }

     @Override
     public String serializeAllExceptFilter(Object src, String... filterAttr)
             throws Exception {
         return gson
                 .addSerializationExclusionStrategy(
                         exclude(null, filterAttr)).create().toJson(src);
     }

     @Override
     public String serializeAllExceptFilter(Object src, Boolean notused,
             String... filterAttr) throws Exception {
         return gson
                 .addSerializationExclusionStrategy(
                         exclude(null, filterAttr)).create().toJson(src);
     }

     @Override
     public String ser(Object src, Boolean refreshCache) throws Exception {
         throw new Exception("Not implemented!");
     }

     @Override
     public <T> String ser(Object src, Class<T> type, Boolean refreshCache)
             throws Exception {
         throw new Exception("Not implemented!");
     }

     public JsonService registerTypeAdapter(Object serdeser, Type type) {
         gson.registerTypeAdapter(type, serdeser);
         return this;
     }

     /**
      * Alternative method to calling {@link #registerTypeAdapter(Object, Type)}
      * Note: Always use either this direct format call or the other adapter register call,
      * otherwise inconsistencies may occur!
      *
      * @param dfStr date format string
      */
     public void setDateFormat(final String dfStr) {
         gson.setDateFormat(dfStr);
     }

     /* (non-Javadoc)
      * @see org.apache.fulcrum.json.JsonService#setDateFormat(java.text.DateFormat)
      */
     @Override
     public void setDateFormat(final DateFormat df) {
         DateTypeAdapter dateTypeAdapter = new DateTypeAdapter();
         dateTypeAdapter.setCustomDateFormat(df);
         gson.registerTypeAdapter(Date.class,dateTypeAdapter);
     }

     public void getJsonService() throws InstantiationException {
         // gson.registerTypeAdapter(Date.class, ser).
         // addSerializationExclusionStrategy( exclude(ObjectKey.class) ).
         // addSerializationExclusionStrategy( exclude(ComboKey.class) );
         // return gson.create().toJson( src );
     }

     /* (non-Javadoc)
      * @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration)
      */
     @Override
     public void configure(Configuration conf) throws ConfigurationException {

         getLogger().debug("conf.getName()" + conf.getName());
         final Configuration configuredDateFormat = conf.getChild(DATE_FORMAT,
                 false);
         if (configuredDateFormat != null) {
             this.dateFormat = configuredDateFormat.getValue();// DEFAULTDATEFORMAT);
         }
         final Configuration configuredAdapters = conf.getChild(GLOBAL_ADAPTERS,
                 true);
         if (configuredAdapters != null) {
             Configuration[] nameVal = configuredAdapters.getChildren();
             for (int i = 0; i < nameVal.length; i++) {
                 String key = nameVal[i].getName();
                 getLogger().debug("configured key: " + key);
                 if (key.equals("adapter")) {
                     String forClass = nameVal[i].getAttribute("forClass");
                     this.adapters = new Hashtable<String, String>();
                     this.adapters.put(forClass, nameVal[i].getValue());
                 }
             }
         }
         // TODO provide configurable Type Adapters
         final Configuration configuredjsonPath = conf.getChild(
                 USEJSONPATH, false);
         if (configuredjsonPath != null) {
             this.useJsonPath  = configuredjsonPath.getValueAsBoolean();
         }
     }

     /* (non-Javadoc)
      * @see org.apache.avalon.framework.activity.Initializable#initialize()
      */
     @Override
     public void initialize() throws Exception {
         gson = new GsonBuilder();
         getLogger().debug("initialized: gson:" + gson);
         if (dateFormat != null) {
             getLogger().info("setting date format to: " + dateFormat);
             setDateFormat(new SimpleDateFormat(dateFormat));
             //setDateFormat(dateFormat);
         }

         if (adapters != null) {
             Enumeration<String> enumKey = adapters.keys();
             while (enumKey.hasMoreElements()) {
                 String forClass = enumKey.nextElement();
                 String avClass = adapters.get(forClass);
                 if (avClass != null) {
                     try {
                         getLogger().debug(
                                 "initializing: adapters " + avClass
                                         + " forClass:" + forClass);
                         Class adapterForClass = Class.forName(forClass);
                         Class adapterClass = Class.forName(avClass);
                         addAdapter("Test Adapter", adapterForClass,
                                 adapterClass);

                     } catch (Exception e) {
                         throw new InstantiationException(
                                 "JsonMapperService: Error instantiating one of the adapters: "
                                         + avClass + " for " + forClass);
                     }
                 }
             }
         }

         if (useJsonPath) {
             // set it before runtime
             com.jayway.jsonpath.Configuration.setDefaults(new com.jayway.jsonpath.Configuration.Defaults() {

                 private Callable<Gson> gsonFuture = new Callable<Gson>() {
                     @Override
                     public Gson call() {
                         return GSONBuilderService.this.gson.create();
                     }
                 };

                 private final JsonProvider jsonProvider = new GsonJsonProvider(GSONBuilderService.this.gson.create());
                 private final MappingProvider mappingProvider = new GsonMappingProvider(gsonFuture);

                 @Override
                 public JsonProvider jsonProvider() {
                     return jsonProvider;
                 }

                 @Override
                 public MappingProvider mappingProvider() {
                     return mappingProvider;
                 }

                 @Override
                 public Set<Option> options() {
                     return EnumSet.noneOf(Option.class);
                 }
             });
         }
     }

     /**
      * Simple Exclusion strategy to filter class or fields used by this service
      * for serialization (not yet deserialization).
      *
      * @param clazz
      *            The class to be filtered out.
      * @param filterAttrs
      *            The fieldnames to be filtered as string
      * @return the strategy applied by GSON
      */
     private ExclusionStrategy exclude(Class clazz, String... filterAttrs) {
         return new ExclusionStrategy() {

             public Class<?> excludedThisClass;
             public HashSet<String> excludedAttributes;

             private ExclusionStrategy init(Class<?> excludedThisClass,
                     String... filterAttrs) {
                 this.excludedThisClass = excludedThisClass;
                 if (filterAttrs != null) {
                     this.excludedAttributes = new HashSet<String>(
                             filterAttrs.length);
                     Collections.addAll(this.excludedAttributes, filterAttrs);
                 } else
                     this.excludedAttributes = new HashSet<String>();

                 return this;
             }

             @Override
             public boolean shouldSkipClass(Class<?> clazz) {
                 return (excludedThisClass != null) ? excludedThisClass
                         .equals(clazz) : false;
             }

             @Override
             public boolean shouldSkipField(FieldAttributes paramFieldAttributes) {
                 // return paramFieldAttributes.getDeclaringClass() ==
                 // excludedThisClass &&
                 // excludesAttributes.contains(paramFieldAttributes.getName());
                 return !excludedAttributes.isEmpty() ? this.excludedAttributes
                         .contains(paramFieldAttributes.getName()) : false;
             }
         }.init(clazz, filterAttrs);
     }

     /**
      * @param clazz the class to exclude
      * @param filterAttrs bean elements not to be serialized
      * @return
      */
     private ExclusionStrategy include(Class clazz, String... filterAttrs) {
         return new ExclusionStrategy() {

             private Class<?> includeThisClass;
             private HashSet<String> includedAttributes;

             private ExclusionStrategy init(Class<?> includeThisClass,
                     String... filterAttrs) {
                 this.includeThisClass = includeThisClass;
                 if (filterAttrs != null) {
                     this.includedAttributes = new HashSet<String>(
                             filterAttrs.length);
                     getLogger().debug(" ... adding includedAttributes:" + filterAttrs.length);
                     Collections.addAll(this.includedAttributes, filterAttrs);
                     for (String includedAttribute : includedAttributes) {
                         getLogger().debug("includedAttribute:" +includedAttribute);
                     }
                 } else
                     this.includedAttributes = new HashSet<String>();

                 return this;
             }

             /**
              * skip is current class is not equal provided class
              */
             @Override
             public boolean shouldSkipClass(Class<?> clazz) {
                 getLogger().debug(includeThisClass+ ": comparing include class:" + clazz);
                 return includeThisClass != null ? !includeThisClass
                         .equals(clazz) : false;
             }

             /**
              * skip if current field attribute is not included are skip else
              */
             @Override
             public boolean shouldSkipField(FieldAttributes paramFieldAttributes) {
                 return !includedAttributes.isEmpty() ? !this.includedAttributes
                         .contains(paramFieldAttributes.getName()) : true;

             }
         }.init(clazz, filterAttrs);
     }

 }
	package org.apache.fulcrum.json.gson;

	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	import java.lang.reflect.Type;
	import java.text.DateFormat;
	import java.text.SimpleDateFormat;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Date;
	import java.util.EnumSet;
	import java.util.Enumeration;
	import java.util.HashSet;
	import java.util.Hashtable;
	import java.util.Set;
	import java.util.concurrent.Callable;

	import org.apache.avalon.framework.activity.Initializable;
	import org.apache.avalon.framework.configuration.Configurable;
	import org.apache.avalon.framework.configuration.Configuration;
	import org.apache.avalon.framework.configuration.ConfigurationException;
	import org.apache.avalon.framework.logger.AbstractLogEnabled;
	import org.apache.fulcrum.json.JsonService;

	import com.google.gson.ExclusionStrategy;
	import com.google.gson.FieldAttributes;
	import com.google.gson.Gson;
	import com.google.gson.GsonBuilder;
	import com.google.gson.reflect.TypeToken;
	import com.jayway.jsonpath.Option;
	import com.jayway.jsonpath.spi.json.GsonJsonProvider;
	import com.jayway.jsonpath.spi.json.JsonProvider;
	import com.jayway.jsonpath.spi.mapper.GsonMappingProvider;
	import com.jayway.jsonpath.spi.mapper.MappingProvider;

	/**
	*
	* By default multiple serialization of the same object in a single thread is
	* not support (e.g adapter + default for the same bean / object).
	*
	*
	* @author gk
	* @version $Id$
	*
	*/
	public class GSONBuilderService extends AbstractLogEnabled implements
	JsonService, Initializable, Configurable {

	private static final String GLOBAL_ADAPTERS = "globalAdapters";

	private static final String DATE_FORMAT = "dateFormat";

	private static final String USEJSONPATH = "useJsonPath";

	private String dateFormat;

	private Hashtable<String, String> adapters = null;

	private boolean useJsonPath = false;

	GsonBuilder gson;

	@Override
	public String ser(Object src) throws Exception {
	getLogger().debug("ser" + src);
	return gson.create().toJson(src);
	}

	@Override
	public <T> String ser(Object src, Class<T> type) throws Exception {
	getLogger().debug("ser::" + src + " with type" + type);

	Type collectionType = new TypeToken<T>() {
	}.getType();
	return gson.create().toJson(src, collectionType);
	}

	@Override
	public <T> T deSer(String json, Class<T> type) throws Exception {
	// TODO Auto-generated method stub
	getLogger().debug("deser:" + json);
	return gson.create().fromJson(json, type);
	}

	@Override
	public <T> Collection<T> deSerCollection(String json, Object collectionType,
	Class<T> elementType) throws Exception {
	getLogger().debug("deser:" + json);
	getLogger().debug("collectionType:" + collectionType);
	return gson.create().fromJson(json, (Type)collectionType);
	}

	@Override
	public String serializeOnlyFilter(Object src, String... filterAttr)
	throws Exception {
	return gson
	.addSerializationExclusionStrategy(
	include(null,filterAttr)).create().toJson(src);
	}

	@Override
	public String serializeOnlyFilter(Object src, Boolean notused,
	String... filterAttr) throws Exception {
	return gson
	.addSerializationExclusionStrategy(
	include(null,filterAttr)).create().toJson(src);
	}

	@Override
	public <T> String serializeOnlyFilter(Object src, Class<T> filterClass,
	String... filterAttr) throws Exception {
	return gson
	.addSerializationExclusionStrategy(
	include(filterClass, filterAttr)).create().toJson(src);
	}

	@Override
	public <T> String serializeOnlyFilter(Object arg0, Class<T> arg1,
	Boolean arg2, String... arg3) throws Exception {
	throw new Exception("Not yet implemented!");
	}

	/**
	* registering an adapter
	*
	* @see GsonBuilder#registerTypeAdapter(Type, Object)
	*/
	@Override
	public JsonService addAdapter(String name, Class target, Object adapter)
	throws Exception {
	gson.registerTypeAdapter(target, adapter);
	return this;
	}

	/**
	* registering an adapter. Unregistering could be only done by reinitialize {@link GsonBuilder}
	* using @link {@link GSONBuilderService#initialize()}, although a new Adapter with the same target overwrites the previously defined.
	*
	* @see GsonBuilder#registerTypeAdapter(Type, Object)
	*/
	@Override
	public JsonService addAdapter(String name, Class target, Class adapter)
	throws Exception {
	gson.registerTypeAdapter(target, adapter.getConstructor().newInstance());
	return null;
	}

	@Override
	public <T> String serializeAllExceptFilter(Object src,
	Class<T> filterClass, String... filterAttr) throws Exception {
	return gson
	.addSerializationExclusionStrategy(
	exclude(filterClass, filterAttr)).create().toJson(src);
	}

	@Override
	public <T> String serializeAllExceptFilter(Object src, Class<T> filterClass,
	Boolean clearCache, String... filterAttr) throws Exception {
	throw new Exception("Not yet implemented!");
	}

	@Override
	public String serializeAllExceptFilter(Object src, String... filterAttr)
	throws Exception {
	return gson
	.addSerializationExclusionStrategy(
	exclude(null, filterAttr)).create().toJson(src);
	}

	@Override
	public String serializeAllExceptFilter(Object src, Boolean notused,
	String... filterAttr) throws Exception {
	return gson
	.addSerializationExclusionStrategy(
	exclude(null, filterAttr)).create().toJson(src);
	}

	@Override
	public String ser(Object src, Boolean refreshCache) throws Exception {
	throw new Exception("Not implemented!");
	}

	@Override
	public <T> String ser(Object src, Class<T> type, Boolean refreshCache)
	throws Exception {
	throw new Exception("Not implemented!");
	}

	public JsonService registerTypeAdapter(Object serdeser, Type type) {
	gson.registerTypeAdapter(type, serdeser);
	return this;
	}

	/**
	* Alternative method to calling {@link #registerTypeAdapter(Object, Type)}
	* Note: Always use either this direct format call or the other adapter register call,
	* otherwise inconsistencies may occur!
	*
	* @param dfStr date format string
	*/
	public void setDateFormat(final String dfStr) {
	gson.setDateFormat(dfStr);
	}

	/* (non-Javadoc)
	* @see org.apache.fulcrum.json.JsonService#setDateFormat(java.text.DateFormat)
	*/
	@Override
	public void setDateFormat(final DateFormat df) {
	DateTypeAdapter dateTypeAdapter = new DateTypeAdapter();
	dateTypeAdapter.setCustomDateFormat(df);
	gson.registerTypeAdapter(Date.class,dateTypeAdapter);
	}

	public void getJsonService() throws InstantiationException {
	// gson.registerTypeAdapter(Date.class, ser).
	// addSerializationExclusionStrategy( exclude(ObjectKey.class) ).
	// addSerializationExclusionStrategy( exclude(ComboKey.class) );
	// return gson.create().toJson( src );
	}

	/* (non-Javadoc)
	* @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration)
	*/
	@Override
	public void configure(Configuration conf) throws ConfigurationException {

	getLogger().debug("conf.getName()" + conf.getName());
	final Configuration configuredDateFormat = conf.getChild(DATE_FORMAT,
	false);
	if (configuredDateFormat != null) {
	this.dateFormat = configuredDateFormat.getValue();// DEFAULTDATEFORMAT);
	}
	final Configuration configuredAdapters = conf.getChild(GLOBAL_ADAPTERS,
	true);
	if (configuredAdapters != null) {
	Configuration[] nameVal = configuredAdapters.getChildren();
	for (int i = 0; i < nameVal.length; i++) {
	String key = nameVal[i].getName();
	getLogger().debug("configured key: " + key);
	if (key.equals("adapter")) {
	String forClass = nameVal[i].getAttribute("forClass");
	this.adapters = new Hashtable<String, String>();
	this.adapters.put(forClass, nameVal[i].getValue());
	}
	}
	}
	// TODO provide configurable Type Adapters
	final Configuration configuredjsonPath = conf.getChild(
	USEJSONPATH, false);
	if (configuredjsonPath != null) {
	this.useJsonPath = configuredjsonPath.getValueAsBoolean();
	}
	}

	/* (non-Javadoc)
	* @see org.apache.avalon.framework.activity.Initializable#initialize()
	*/
	@Override
	public void initialize() throws Exception {
	gson = new GsonBuilder();
	getLogger().debug("initialized: gson:" + gson);
	if (dateFormat != null) {
	getLogger().info("setting date format to: " + dateFormat);
	setDateFormat(new SimpleDateFormat(dateFormat));
	//setDateFormat(dateFormat);
	}

	if (adapters != null) {
	Enumeration<String> enumKey = adapters.keys();
	while (enumKey.hasMoreElements()) {
	String forClass = enumKey.nextElement();
	String avClass = adapters.get(forClass);
	if (avClass != null) {
	try {
	getLogger().debug(
	"initializing: adapters " + avClass
	+ " forClass:" + forClass);
	Class adapterForClass = Class.forName(forClass);
	Class adapterClass = Class.forName(avClass);
	addAdapter("Test Adapter", adapterForClass,
	adapterClass);

	} catch (Exception e) {
	throw new InstantiationException(
	"JsonMapperService: Error instantiating one of the adapters: "
	+ avClass + " for " + forClass);
	}
	}
	}
	}

	if (useJsonPath) {
	// set it before runtime
	com.jayway.jsonpath.Configuration.setDefaults(new com.jayway.jsonpath.Configuration.Defaults() {

	private Callable<Gson> gsonFuture = new Callable<Gson>() {
	@Override
	public Gson call() {
	return GSONBuilderService.this.gson.create();
	}
	};

	private final JsonProvider jsonProvider = new GsonJsonProvider(GSONBuilderService.this.gson.create());
	private final MappingProvider mappingProvider = new GsonMappingProvider(gsonFuture);

	@Override
	public JsonProvider jsonProvider() {
	return jsonProvider;
	}

	@Override
	public MappingProvider mappingProvider() {
	return mappingProvider;
	}

	@Override
	public Set<Option> options() {
	return EnumSet.noneOf(Option.class);
	}
	});
	}
	}

	/**
	* Simple Exclusion strategy to filter class or fields used by this service
	* for serialization (not yet deserialization).
	*
	* @param clazz
	* The class to be filtered out.
	* @param filterAttrs
	* The fieldnames to be filtered as string
	* @return the strategy applied by GSON
	*/
	private ExclusionStrategy exclude(Class clazz, String... filterAttrs) {
	return new ExclusionStrategy() {

	public Class<?> excludedThisClass;
	public HashSet<String> excludedAttributes;

	private ExclusionStrategy init(Class<?> excludedThisClass,
	String... filterAttrs) {
	this.excludedThisClass = excludedThisClass;
	if (filterAttrs != null) {
	this.excludedAttributes = new HashSet<String>(
	filterAttrs.length);
	Collections.addAll(this.excludedAttributes, filterAttrs);
	} else
	this.excludedAttributes = new HashSet<String>();

	return this;
	}

	@Override
	public boolean shouldSkipClass(Class<?> clazz) {
	return (excludedThisClass != null) ? excludedThisClass
	.equals(clazz) : false;
	}

	@Override
	public boolean shouldSkipField(FieldAttributes paramFieldAttributes) {
	// return paramFieldAttributes.getDeclaringClass() ==
	// excludedThisClass &&
	// excludesAttributes.contains(paramFieldAttributes.getName());
	return !excludedAttributes.isEmpty() ? this.excludedAttributes
	.contains(paramFieldAttributes.getName()) : false;
	}
	}.init(clazz, filterAttrs);
	}

	/**
	* @param clazz the class to exclude
	* @param filterAttrs bean elements not to be serialized
	* @return
	*/
	private ExclusionStrategy include(Class clazz, String... filterAttrs) {
	return new ExclusionStrategy() {

	private Class<?> includeThisClass;
	private HashSet<String> includedAttributes;

	private ExclusionStrategy init(Class<?> includeThisClass,
	String... filterAttrs) {
	this.includeThisClass = includeThisClass;
	if (filterAttrs != null) {
	this.includedAttributes = new HashSet<String>(
	filterAttrs.length);
	getLogger().debug(" ... adding includedAttributes:" + filterAttrs.length);
	Collections.addAll(this.includedAttributes, filterAttrs);
	for (String includedAttribute : includedAttributes) {
	getLogger().debug("includedAttribute:" +includedAttribute);
	}
	} else
	this.includedAttributes = new HashSet<String>();

	return this;
	}

	/**
	* skip is current class is not equal provided class
	*/
	@Override
	public boolean shouldSkipClass(Class<?> clazz) {
	getLogger().debug(includeThisClass+ ": comparing include class:" + clazz);
	return includeThisClass != null ? !includeThisClass
	.equals(clazz) : false;
	}

	/**
	* skip if current field attribute is not included are skip else
	*/
	@Override
	public boolean shouldSkipField(FieldAttributes paramFieldAttributes) {
	return !includedAttributes.isEmpty() ? !this.includedAttributes
	.contains(paramFieldAttributes.getName()) : true;

	}
	}.init(clazz, filterAttrs);
	}

	}