import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
public JsonBoon() {
	JsonParserFactory jsonParserFactory = new JsonParserFactory();
	jsonParserFactory.lax();

	// Include nulls and empty fields
	JsonSerializerFactory serializerFactory = new JsonSerializerFactory();
	serializerFactory.setIncludeNulls(true);
	serializerFactory.setIncludeEmpty(true);

	// Install MongoDB / BSON serializers
	tryToAddSerializers("io.datatree.dom.adapters.JsonBoonBsonSerializers", serializerFactory);

	// Format dates
	serializerFactory.setJsonFormatForDates(Config.USE_TIMESTAMPS);

	mapper = JsonFactory.create(jsonParserFactory, serializerFactory);
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
public static final <T> void addSerializer(JsonSerializerFactory factory, Class<T> type,
		CheckedBiConsumer<T, CharBuf> consumer) {
	factory.addTypeSerializer(type, new CustomObjectSerializer<T>() {

		@Override
		public Class<T> type() {
			return type;
		}

		@Override
		public void serializeObject(JsonSerializerInternal serializer, T instance, CharBuf builder) {
			try {
				consumer.accept(instance, builder);
			} catch (IOException cause) {
				throw new IllegalArgumentException(cause);
			}
		}

	});
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
public static <T> String toJsonString(T document) {

        JsonSerializerFactory serializer = new JsonSerializerFactory().addFilter(new FieldFilter() {
            @Override
            public boolean include(Object o, FieldAccess fieldAccess) {
                if ( fieldAccess.hasAnnotation(DocumentRef.class.getName())) {
                    return false;
                }
                return true;
            }
        });

        ObjectMapper mapper = JsonFactory.create(null, serializer);

        return mapper.toJson(document);


    }
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
public static JsonSerializerFactory createJsonSerializerFactory(final boolean outputType, final String fieldAccessType,
        final boolean includeNulls, final boolean useAnnotations, final boolean includeEmpty, final boolean jsonFormatForDates,
        final boolean handleComplexBackReference, final boolean handleSimpleBackReference, final boolean includeDefault,
        final boolean cacheInstances, final String view) {
    final JsonSerializerFactory jsonSerializerFactory = new JsonSerializerFactory();
    if (FieldAccessMode.FIELD.name().equals(fieldAccessType)) {
        jsonSerializerFactory.useFieldsOnly();
    } else if (FieldAccessMode.PROPERTY.name().equals(fieldAccessType)) {
        jsonSerializerFactory.usePropertyOnly();
    } else if (FieldAccessMode.FIELD_THEN_PROPERTY.name().equals(fieldAccessType)) {
        jsonSerializerFactory.isUseFieldsFirst();
    } else if (FieldAccessMode.PROPERTY_THEN_FIELD.name().equals(fieldAccessType)) {
        jsonSerializerFactory.usePropertyOnly();
    }
    jsonSerializerFactory.setOutputType(outputType);
    jsonSerializerFactory.setIncludeNulls(includeNulls);
    jsonSerializerFactory.setUseAnnotations(useAnnotations);
    jsonSerializerFactory.setIncludeEmpty(includeEmpty);
    jsonSerializerFactory.setJsonFormatForDates(jsonFormatForDates);
    jsonSerializerFactory.setHandleComplexBackReference(handleComplexBackReference);
    jsonSerializerFactory.setHandleSimpleBackReference(handleSimpleBackReference);
    jsonSerializerFactory.setIncludeDefault(includeDefault);
    jsonSerializerFactory.setCacheInstances(cacheInstances);
    jsonSerializerFactory.setView(view);
    return jsonSerializerFactory;
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
/**
 * Set the attribute of a logging event
 */
public static final LoggingEvent setLoggingEventAttribute(LoggingEvent event, String name, Object value) {

  event = ensureLoggingEvent(event);
  
  if (null != name && null != value) {
    JsonSerializer ser = new JsonSerializerFactory().create();    
    event.putToAttributes(name, ser.serialize(value).toString());
  }
  
  return event;
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
public static final LoggingEvent addHttpHeaders(LoggingEvent event, HttpServletRequest req) {
  
  event = ensureLoggingEvent(event);
  
  //
  // Add request headers
  //
  
  Map<String,Object> headerMap = new HashMap<String,Object>();
  
  Enumeration<String> headerNames = req.getHeaderNames();

  while(headerNames.hasMoreElements()) {
    String name = headerNames.nextElement();
    Enumeration<String> values = req.getHeaders(name);
    List<String> hdrs = new ArrayList<String>();
    while(values.hasMoreElements()) {
      hdrs.add(values.nextElement());
    }
    if (!hdrs.isEmpty()) {
      headerMap.put(name, hdrs);
    }
  }
  
  if (!headerMap.isEmpty()) {
    JsonSerializer ser = new JsonSerializerFactory().create();    

    event.putToAttributes(LogUtil.HTTP_HEADERS, ser.serialize(headerMap).toString());
  }
  
  return event;
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
private JsonSerializerFactory factory() {
    JsonSerializerFactory value = factory.get();
    if (value == null) {
        synchronized (factory) {
            value = factory.get();
            if (value == null) {
                value = Boons.createJsonSerializerFactory(outputType, fieldAccessType, includeNulls, useAnnotations, includeEmpty, jsonFormatForDates, handleComplexBackReference, handleSimpleBackReference, includeDefault, cacheInstances, view);
                factory.set(value);
            }
        }
    }
    return value;
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
protected void init(final JsonSerializerFactory factory) {
    if (factory != null) {
        this.factory.set(factory);
    } else {
        factory(); // force init
    }
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
@Test
public void testFlatten1()
{
    ClassLoader classLoader = getClass().getClassLoader();
    URL url = classLoader.getResource("example1.json");
    String path = url.getFile();
    File file = new File(path);

    ValueMap jsonObject = (ValueMap)new JsonSlurper().parse(file);

    ValueList results  = (ValueList)jsonObject.get("results");

    JsonSerializer jsonSerializer = new JsonSerializerFactory().outputType().create();


    System.out.println(jsonSerializer.serialize(jsonObject));

}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
public static final LoggingEvent setLoggingEventStackTrace(LoggingEvent event, String name, Throwable t) {
  
  event = ensureLoggingEvent(event);
  
  if (null == t) {
    return event;
  }
  
  // Fill the stack trace
  
  Object[][] stacktrace = null;
  int offset = 0;
  
  while(null != t) {
    if (null == t.getStackTrace()) {
      t.fillInStackTrace();
    }
    
    StackTraceElement[] ste = t.getStackTrace();

    if (null == stacktrace) {
      stacktrace = new Object[ste.length + 1][];
    } else {
      Object[][] oldtrace = stacktrace;
      
      // Resize stacktrace
      stacktrace = new Object[stacktrace.length + ste.length + 1][];
      
      System.arraycopy(oldtrace, 0, stacktrace, 0, oldtrace.length);
      
      offset = oldtrace.length;
    }
    
    // Fill message
    stacktrace[offset] = new Object[4];
    stacktrace[offset][0] = "";
    stacktrace[offset][1] = 0;
    stacktrace[offset][2] = t.getClass().getName();
    stacktrace[offset][3] = null != t.getMessage() ? t.getMessage() : "";
    offset++;        

    for (int i = 0; i < ste.length; i++) {
      stacktrace[offset+i] = new Object[4];
      stacktrace[offset+i][0] = ste[i].getFileName();
      stacktrace[offset+i][1] = ste[i].getLineNumber();
      stacktrace[offset+i][2] = ste[i].getClassName();
      stacktrace[offset+i][3] = ste[i].getMethodName();
    }

    t = t.getCause();
  }
  
  if (null == event) {
    event = new LoggingEvent();
  }
  
  JsonSerializer ser = new JsonSerializerFactory().create();    

  event.putToAttributes(name, ser.serialize(stacktrace).toString());
  
  return event;
}
 

import org.boon.json.JsonSerializerFactory; //导入依赖的package包/类
@Setup
public void prepare() {
	this.serializer = new JsonSerializerFactory().setSerializeAsSupport(false).useFieldsOnly().create();
}