JsonGenerator - JSON serialization options (closes #371, closes #433) Fixes or partially addresses the following:
GROOVY-6699: ignore properties/fields during serialization GROOVY-6854: serialize ISO-8601 dates GROOVY-6975: deactivate unicode escaping GROOVY-7682: JodaTime/JSR310 (using custom converter) GROOVY-7780: exclude null values Project: http://git-wip-us.apache.org/repos/asf/groovy/repo Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/13202599 Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/13202599 Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/13202599 Branch: refs/heads/parrot Commit: 132025997e110e284fe1ce5e4d19a75ae5418ae6 Parents: 8213bd0 Author: John Wagenleitner <[email protected]> Authored: Sun Oct 23 16:40:11 2016 -0700 Committer: John Wagenleitner <[email protected]> Committed: Sun Oct 23 16:40:11 2016 -0700 ---------------------------------------------------------------------- .../java/groovy/json/DefaultJsonGenerator.java | 549 +++++++++++++++++++ .../src/main/java/groovy/json/JsonBuilder.java | 28 +- .../main/java/groovy/json/JsonGenerator.java | 326 +++++++++++ .../src/main/java/groovy/json/JsonOutput.java | 372 +------------ .../java/groovy/json/StreamingJsonBuilder.java | 134 ++++- .../main/java/groovy/json/internal/CharBuf.java | 57 +- .../groovy-json/src/spec/doc/json-builder.adoc | 9 +- .../src/spec/doc/json-userguide.adoc | 28 +- .../src/spec/doc/streaming-jason-builder.adoc | 9 +- .../src/spec/test/json/JsonBuilderTest.groovy | 32 ++ .../src/spec/test/json/JsonTest.groovy | 68 +++ .../test/json/StreamingJsonBuilderTest.groovy | 35 +- .../test/groovy/groovy/json/CharBufTest.groovy | 35 ++ .../groovy/json/CustomJsonGeneratorTest.groovy | 89 +++ .../groovy/json/DefaultJsonGeneratorTest.groovy | 283 ++++++++++ .../groovy/groovy/json/JsonBuilderTest.groovy | 27 + .../groovy/json/StreamingJsonBuilderTest.groovy | 50 ++ 17 files changed, 1729 insertions(+), 402 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/main/java/groovy/json/DefaultJsonGenerator.java ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/main/java/groovy/json/DefaultJsonGenerator.java b/subprojects/groovy-json/src/main/java/groovy/json/DefaultJsonGenerator.java new file mode 100644 index 0000000..1dbd0ad --- /dev/null +++ b/subprojects/groovy-json/src/main/java/groovy/json/DefaultJsonGenerator.java @@ -0,0 +1,549 @@ +/* + * 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. + */ +package groovy.json; + +import groovy.json.internal.CharBuf; +import groovy.json.internal.Chr; +import groovy.lang.Closure; +import groovy.util.Expando; +import org.codehaus.groovy.runtime.DefaultGroovyMethods; + +import java.io.File; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URL; +import java.text.SimpleDateFormat; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Collections; +import java.util.Date; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.TimeZone; +import java.util.UUID; + +import static groovy.json.JsonOutput.CLOSE_BRACE; +import static groovy.json.JsonOutput.CLOSE_BRACKET; +import static groovy.json.JsonOutput.COMMA; +import static groovy.json.JsonOutput.EMPTY_LIST_CHARS; +import static groovy.json.JsonOutput.EMPTY_MAP_CHARS; +import static groovy.json.JsonOutput.EMPTY_STRING_CHARS; +import static groovy.json.JsonOutput.OPEN_BRACE; +import static groovy.json.JsonOutput.OPEN_BRACKET; + +/** + * A JsonGenerator that can be configured with various {@link JsonGenerator.Options}. + * If the default options are sufficient consider using the static {@code JsonOutput.toJson} + * methods. + * + * @see JsonGenerator.Options#build() + * @since 2.5 + */ +public class DefaultJsonGenerator implements JsonGenerator { + + protected final boolean excludeNulls; + protected final boolean disableUnicodeEscaping; + protected final String dateFormat; + protected final Locale dateLocale; + protected final TimeZone timezone; + protected final Set<Converter> converters = new LinkedHashSet<Converter>(); + protected final Set<String> excludedFieldNames = new HashSet<String>(); + protected final Set<Class<?>> excludedFieldTypes = new HashSet<Class<?>>(); + + protected DefaultJsonGenerator(Options options) { + excludeNulls = options.excludeNulls; + disableUnicodeEscaping = options.disableUnicodeEscaping; + dateFormat = options.dateFormat; + dateLocale = options.dateLocale; + timezone = options.timezone; + if (!options.converters.isEmpty()) { + converters.addAll(options.converters); + } + if (!options.excludedFieldNames.isEmpty()) { + excludedFieldNames.addAll(options.excludedFieldNames); + } + if (!options.excludedFieldTypes.isEmpty()) { + excludedFieldTypes.addAll(options.excludedFieldTypes); + } + } + + /** + * {@inheritDoc} + */ + @Override + public String toJson(Object object) { + CharBuf buffer = CharBuf.create(255); + writeObject(object, buffer); + return buffer.toString(); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isExcludingFieldsNamed(String name) { + return excludedFieldNames.contains(name); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isExcludingValues(Object value) { + if (value == null) { + return excludeNulls; + } else { + return shouldExcludeType(value.getClass()); + } + } + + /** + * Serializes Number value and writes it into specified buffer. + */ + protected void writeNumber(Class<?> numberClass, Number value, CharBuf buffer) { + if (numberClass == Integer.class) { + buffer.addInt((Integer) value); + } else if (numberClass == Long.class) { + buffer.addLong((Long) value); + } else if (numberClass == BigInteger.class) { + buffer.addBigInteger((BigInteger) value); + } else if (numberClass == BigDecimal.class) { + buffer.addBigDecimal((BigDecimal) value); + } else if (numberClass == Double.class) { + Double doubleValue = (Double) value; + if (doubleValue.isInfinite()) { + throw new JsonException("Number " + value + " can't be serialized as JSON: infinite are not allowed in JSON."); + } + if (doubleValue.isNaN()) { + throw new JsonException("Number " + value + " can't be serialized as JSON: NaN are not allowed in JSON."); + } + + buffer.addDouble(doubleValue); + } else if (numberClass == Float.class) { + Float floatValue = (Float) value; + if (floatValue.isInfinite()) { + throw new JsonException("Number " + value + " can't be serialized as JSON: infinite are not allowed in JSON."); + } + if (floatValue.isNaN()) { + throw new JsonException("Number " + value + " can't be serialized as JSON: NaN are not allowed in JSON."); + } + + buffer.addFloat(floatValue); + } else if (numberClass == Byte.class) { + buffer.addByte((Byte) value); + } else if (numberClass == Short.class) { + buffer.addShort((Short) value); + } else { // Handle other Number implementations + buffer.addString(value.toString()); + } + } + + protected void writeObject(Object object, CharBuf buffer) { + writeObject(null, object, buffer); + } + + /** + * Serializes object and writes it into specified buffer. + */ + protected void writeObject(String key, Object object, CharBuf buffer) { + + if (isExcludingValues(object)) { + return; + } + + if (object == null) { + buffer.addNull(); + return; + } + + Class<?> objectClass = object.getClass(); + + Converter converter = findConverter(objectClass); + if (converter != null) { + writeRaw(converter.convert(object, key), buffer); + return; + } + + if (CharSequence.class.isAssignableFrom(objectClass)) { // Handle String, StringBuilder, GString and other CharSequence implementations + writeCharSequence((CharSequence) object, buffer); + } else if (objectClass == Boolean.class) { + buffer.addBoolean((Boolean) object); + } else if (Number.class.isAssignableFrom(objectClass)) { + writeNumber(objectClass, (Number) object, buffer); + } else if (Date.class.isAssignableFrom(objectClass)) { + writeDate((Date) object, buffer); + } else if (Calendar.class.isAssignableFrom(objectClass)) { + writeDate(((Calendar) object).getTime(), buffer); + } else if (Map.class.isAssignableFrom(objectClass)) { + writeMap((Map) object, buffer); + } else if (Iterable.class.isAssignableFrom(objectClass)) { + writeIterator(((Iterable<?>) object).iterator(), buffer); + } else if (Iterator.class.isAssignableFrom(objectClass)) { + writeIterator((Iterator) object, buffer); + } else if (objectClass == Character.class) { + buffer.addJsonEscapedString(Chr.array((Character) object), disableUnicodeEscaping); + } else if (objectClass == URL.class) { + buffer.addJsonEscapedString(object.toString(), disableUnicodeEscaping); + } else if (objectClass == UUID.class) { + buffer.addQuoted(object.toString()); + } else if (objectClass == JsonOutput.JsonUnescaped.class) { + buffer.add(object.toString()); + } else if (Closure.class.isAssignableFrom(objectClass)) { + writeMap(JsonDelegate.cloneDelegateAndGetContent((Closure<?>) object), buffer); + } else if (Expando.class.isAssignableFrom(objectClass)) { + writeMap(((Expando) object).getProperties(), buffer); + } else if (Enumeration.class.isAssignableFrom(objectClass)) { + List<?> list = Collections.list((Enumeration<?>) object); + writeIterator(list.iterator(), buffer); + } else if (objectClass.isArray()) { + writeArray(objectClass, object, buffer); + } else if (Enum.class.isAssignableFrom(objectClass)) { + buffer.addQuoted(((Enum<?>) object).name()); + } else if (File.class.isAssignableFrom(objectClass)) { + Map<?, ?> properties = getObjectProperties(object); + //Clean up all recursive references to File objects + Iterator<? extends Map.Entry<?, ?>> iterator = properties.entrySet().iterator(); + while(iterator.hasNext()) { + Map.Entry<?,?> entry = iterator.next(); + if(entry.getValue() instanceof File) { + iterator.remove(); + } + } + writeMap(properties, buffer); + } else { + Map<?, ?> properties = getObjectProperties(object); + writeMap(properties, buffer); + } + } + + protected Map<?, ?> getObjectProperties(Object object) { + Map<?, ?> properties = DefaultGroovyMethods.getProperties(object); + properties.remove("class"); + properties.remove("declaringClass"); + properties.remove("metaClass"); + return properties; + } + + /** + * Serializes any char sequence and writes it into specified buffer. + */ + protected void writeCharSequence(CharSequence seq, CharBuf buffer) { + if (seq.length() > 0) { + buffer.addJsonEscapedString(seq.toString(), disableUnicodeEscaping); + } else { + buffer.addChars(EMPTY_STRING_CHARS); + } + } + + /** + * Serializes any char sequence and writes it into specified buffer + * without performing any manipulation of the given text. + */ + protected void writeRaw(CharSequence seq, CharBuf buffer) { + if (seq != null) { + buffer.add(seq.toString()); + } + } + + /** + * Serializes date and writes it into specified buffer. + */ + protected void writeDate(Date date, CharBuf buffer) { + SimpleDateFormat formatter = new SimpleDateFormat(dateFormat, dateLocale); + formatter.setTimeZone(timezone); + buffer.addQuoted(formatter.format(date)); + } + + /** + * Serializes array and writes it into specified buffer. + */ + protected void writeArray(Class<?> arrayClass, Object array, CharBuf buffer) { + if (Object[].class.isAssignableFrom(arrayClass)) { + Object[] objArray = (Object[]) array; + writeIterator(Arrays.asList(objArray).iterator(), buffer); + return; + } + buffer.addChar(OPEN_BRACKET); + if (int[].class.isAssignableFrom(arrayClass)) { + int[] intArray = (int[]) array; + if (intArray.length > 0) { + buffer.addInt(intArray[0]); + for (int i = 1; i < intArray.length; i++) { + buffer.addChar(COMMA).addInt(intArray[i]); + } + } + } else if (long[].class.isAssignableFrom(arrayClass)) { + long[] longArray = (long[]) array; + if (longArray.length > 0) { + buffer.addLong(longArray[0]); + for (int i = 1; i < longArray.length; i++) { + buffer.addChar(COMMA).addLong(longArray[i]); + } + } + } else if (boolean[].class.isAssignableFrom(arrayClass)) { + boolean[] booleanArray = (boolean[]) array; + if (booleanArray.length > 0) { + buffer.addBoolean(booleanArray[0]); + for (int i = 1; i < booleanArray.length; i++) { + buffer.addChar(COMMA).addBoolean(booleanArray[i]); + } + } + } else if (char[].class.isAssignableFrom(arrayClass)) { + char[] charArray = (char[]) array; + if (charArray.length > 0) { + buffer.addJsonEscapedString(Chr.array(charArray[0]), disableUnicodeEscaping); + for (int i = 1; i < charArray.length; i++) { + buffer.addChar(COMMA).addJsonEscapedString(Chr.array(charArray[i]), disableUnicodeEscaping); + } + } + } else if (double[].class.isAssignableFrom(arrayClass)) { + double[] doubleArray = (double[]) array; + if (doubleArray.length > 0) { + buffer.addDouble(doubleArray[0]); + for (int i = 1; i < doubleArray.length; i++) { + buffer.addChar(COMMA).addDouble(doubleArray[i]); + } + } + } else if (float[].class.isAssignableFrom(arrayClass)) { + float[] floatArray = (float[]) array; + if (floatArray.length > 0) { + buffer.addFloat(floatArray[0]); + for (int i = 1; i < floatArray.length; i++) { + buffer.addChar(COMMA).addFloat(floatArray[i]); + } + } + } else if (byte[].class.isAssignableFrom(arrayClass)) { + byte[] byteArray = (byte[]) array; + if (byteArray.length > 0) { + buffer.addByte(byteArray[0]); + for (int i = 1; i < byteArray.length; i++) { + buffer.addChar(COMMA).addByte(byteArray[i]); + } + } + } else if (short[].class.isAssignableFrom(arrayClass)) { + short[] shortArray = (short[]) array; + if (shortArray.length > 0) { + buffer.addShort(shortArray[0]); + for (int i = 1; i < shortArray.length; i++) { + buffer.addChar(COMMA).addShort(shortArray[i]); + } + } + } + buffer.addChar(CLOSE_BRACKET); + } + + /** + * Serializes map and writes it into specified buffer. + */ + protected void writeMap(Map<?, ?> map, CharBuf buffer) { + if (map.isEmpty()) { + buffer.addChars(EMPTY_MAP_CHARS); + return; + } + buffer.addChar(OPEN_BRACE); + for (Map.Entry<?, ?> entry : map.entrySet()) { + if (entry.getKey() == null) { + throw new IllegalArgumentException("Maps with null keys can\'t be converted to JSON"); + } + String key = entry.getKey().toString(); + Object value = entry.getValue(); + if (isExcludingValues(value) || isExcludingFieldsNamed(key)) { + continue; + } + writeMapEntry(key, value, buffer); + buffer.addChar(COMMA); + } + buffer.removeLastChar(COMMA); // dangling comma + buffer.addChar(CLOSE_BRACE); + } + + /** + * Serializes a map entry and writes it into specified buffer. + */ + protected void writeMapEntry(String key, Object value, CharBuf buffer) { + buffer.addJsonFieldName(key, disableUnicodeEscaping); + writeObject(key, value, buffer); + } + + /** + * Serializes iterator and writes it into specified buffer. + */ + protected void writeIterator(Iterator<?> iterator, CharBuf buffer) { + if (!iterator.hasNext()) { + buffer.addChars(EMPTY_LIST_CHARS); + return; + } + buffer.addChar(OPEN_BRACKET); + while (iterator.hasNext()) { + Object it = iterator.next(); + if (!isExcludingValues(it)) { + writeObject(it, buffer); + buffer.addChar(COMMA); + } + } + buffer.removeLastChar(COMMA); // dangling comma + buffer.addChar(CLOSE_BRACKET); + } + + /** + * Finds a converter that can handle the given type. The first converter + * that reports it can handle the type is returned, based on the order in + * which the converters were specified. A {@code null} value will be returned + * if no suitable converter can be found for the given type. + * + * @param type that this converter can handle + * @return first converter that can handle the given type; else {@code null} + * if no compatible converters are found for the given type. + */ + protected Converter findConverter(Class<?> type) { + for (Converter c : converters) { + if (c.handles(type)) { + return c; + } + } + return null; + } + + /** + * Indicates whether the given type should be excluded from the generated output. + * + * @param type the type to check + * @return {@code true} if the given type should not be output, else {@code false} + */ + protected boolean shouldExcludeType(Class<?> type) { + for (Class<?> t : excludedFieldTypes) { + if (t.isAssignableFrom(type)) { + return true; + } + } + return false; + } + + /** + * A converter that handles converting a given type to a JSON value + * using a closure. + * + * @since 2.5 + */ + protected static class ClosureConverter implements Converter { + + protected final Class<?> type; + protected final Closure<? extends CharSequence> closure; + protected final int paramCount; + + protected ClosureConverter(Class<?> type, Closure<? extends CharSequence> closure) { + if (type == null) { + throw new NullPointerException("Type parameter must not be null"); + } + if (closure == null) { + throw new NullPointerException("Closure parameter must not be null"); + } + + int paramCount = closure.getMaximumNumberOfParameters(); + if (paramCount < 1) { + throw new IllegalArgumentException("Closure must accept at least one parameter"); + } + Class<?> param1 = closure.getParameterTypes()[0]; + if (!param1.isAssignableFrom(type)) { + throw new IllegalArgumentException("Expected first parameter to be of type: " + type.toString()); + } + if (paramCount > 1) { + Class<?> param2 = closure.getParameterTypes()[1]; + if (!param2.isAssignableFrom(String.class)) { + throw new IllegalArgumentException("Expected second parameter to be of type: " + String.class.toString()); + } + } + this.type = type; + this.closure = closure; + this.paramCount = paramCount; + } + + /** + * Returns {@code true} if this converter can handle conversions + * of the given type. + * + * @param type the type of the object to convert + * @return true if this converter can successfully convert values of + * the given type to a JSON value + */ + public boolean handles(Class<?> type) { + return this.type.isAssignableFrom(type); + } + + /** + * Converts a given value to a JSON value. + * + * @param value the object to convert + * @return a JSON value representing the value + */ + public CharSequence convert(Object value) { + return convert(value, null); + } + + /** + * Converts a given value to a JSON value. + * + * @param value the object to convert + * @param key the key name for the value, may be {@code null} + * @return a JSON value representing the value + */ + public CharSequence convert(Object value, String key) { + return (paramCount == 1) ? + closure.call(value) : + closure.call(value, key); + } + + /** + * Any two Converter instances registered for the same type are considered + * to be equal. This comparison makes managing instances in a Set easier; + * since there is no chaining of Converters it makes sense to only allow + * one per type. + * + * @param o the object with which to compare. + * @return {@code true} if this object contains the same class; {@code false} otherwise. + */ + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ClosureConverter)) { + return false; + } + return this.type == ((ClosureConverter)o).type; + } + + @Override + public int hashCode() { + return this.type.hashCode(); + } + + @Override + public String toString() { + return super.toString() + "<" + this.type.toString() + ">"; + } + } + +} http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/main/java/groovy/json/JsonBuilder.java ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/main/java/groovy/json/JsonBuilder.java b/subprojects/groovy-json/src/main/java/groovy/json/JsonBuilder.java index 0a30b7d..abaac0b 100644 --- a/subprojects/groovy-json/src/main/java/groovy/json/JsonBuilder.java +++ b/subprojects/groovy-json/src/main/java/groovy/json/JsonBuilder.java @@ -65,12 +65,24 @@ import java.util.*; */ public class JsonBuilder extends GroovyObjectSupport implements Writable { + private final JsonGenerator generator; private Object content; /** * Instantiates a JSON builder. */ public JsonBuilder() { + this.generator = JsonOutput.DEFAULT_GENERATOR; + } + + /** + * Instantiates a JSON builder with a configured generator. + * + * @param generator used to generate the output + * @since 2.5 + */ + public JsonBuilder(JsonGenerator generator) { + this.generator = generator; } /** @@ -80,6 +92,20 @@ public class JsonBuilder extends GroovyObjectSupport implements Writable { */ public JsonBuilder(Object content) { this.content = content; + this.generator = JsonOutput.DEFAULT_GENERATOR; + } + + /** + * Instantiates a JSON builder with some existing data structure + * and a configured generator. + * + * @param content a pre-existing data structure + * @param generator used to generate the output + * @since 2.5 + */ + public JsonBuilder(Object content, JsonGenerator generator) { + this.content = content; + this.generator = generator; } public Object getContent() { @@ -344,7 +370,7 @@ public class JsonBuilder extends GroovyObjectSupport implements Writable { * @return a JSON output */ public String toString() { - return JsonOutput.toJson(content); + return generator.toJson(content); } /** http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/main/java/groovy/json/JsonGenerator.java ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/main/java/groovy/json/JsonGenerator.java b/subprojects/groovy-json/src/main/java/groovy/json/JsonGenerator.java new file mode 100644 index 0000000..91b0e06 --- /dev/null +++ b/subprojects/groovy-json/src/main/java/groovy/json/JsonGenerator.java @@ -0,0 +1,326 @@ +/* + * 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. + */ +package groovy.json; + +import groovy.lang.Closure; +import groovy.transform.stc.ClosureParams; +import groovy.transform.stc.FromString; + +import java.text.SimpleDateFormat; +import java.util.Arrays; +import java.util.HashSet; +import java.util.LinkedHashSet; +import java.util.Locale; +import java.util.Set; +import java.util.TimeZone; + +/** + * Generates JSON from objects. + * + * The {@link Options} builder can be used to configure an instance of a JsonGenerator. + * + * @see Options#build() + * @since 2.5 + */ +public interface JsonGenerator { + + /** + * Converts an object to its JSON representation. + * + * @param object to convert to JSON + * @return JSON + */ + String toJson(Object object); + + /** + * Indicates whether this JsonGenerator is configured to exclude fields by + * the given name. + * + * @param name of the field + * @return true if that field is being excluded, else false + */ + boolean isExcludingFieldsNamed(String name); + + /** + * Indicates whether this JsonGenerator is configured to exclude values + * of the given object (may be {@code null}). + * + * @param value an instance of an object + * @return true if values like this are being excluded, else false + */ + boolean isExcludingValues(Object value); + + /** + * Handles converting a given type to a JSON value. + * + * @since 2.5 + */ + interface Converter { + + /** + * Returns {@code true} if this converter can handle conversions + * of the given type. + * + * @param type the type of the object to convert + * @return {@code true} if this converter can successfully convert values of + * the given type to a JSON value, else {@code false} + */ + boolean handles(Class<?> type); + + /** + * Converts a given object to a JSON value. + * + * @param value the object to convert + * @return a JSON value representing the object + */ + CharSequence convert(Object value); + + /** + * Converts a given object to a JSON value. + * + * @param value the object to convert + * @param key the key name for the value, may be {@code null} + * @return a JSON value representing the object + */ + CharSequence convert(Object value, String key); + + } + + /** + * A builder used to construct a {@link JsonGenerator} instance that allows + * control over the serialized JSON output. If you do not need to customize the + * output it is recommended to use the static {@code JsonOutput.toJson} methods. + * + * <p> + * Example: + * <pre><code class="groovyTestCase"> + * def generator = new groovy.json.JsonGenerator.Options() + * .excludeNulls() + * .dateFormat('yyyy') + * .excludeFieldsByName('bar', 'baz') + * .excludeFieldsByType(java.sql.Date) + * .build() + * + * def input = [foo: null, lastUpdated: Date.parse('yyyy-MM-dd', '2014-10-24'), + * bar: 'foo', baz: 'foo', systemDate: new java.sql.Date(new Date().getTime())] + * + * assert generator.toJson(input) == '{"lastUpdated":"2014"}' + * </code></pre> + * + * @since 2.5 + */ + class Options { + + protected static final String JSON_DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ssZ"; + protected static final Locale JSON_DATE_FORMAT_LOCALE = Locale.US; + protected static final String DEFAULT_TIMEZONE = "GMT"; + + protected boolean excludeNulls; + protected boolean disableUnicodeEscaping; + protected String dateFormat = JSON_DATE_FORMAT; + protected Locale dateLocale = JSON_DATE_FORMAT_LOCALE; + protected TimeZone timezone = TimeZone.getTimeZone(DEFAULT_TIMEZONE); + protected final Set<Converter> converters = new LinkedHashSet<Converter>(); + protected final Set<String> excludedFieldNames = new HashSet<String>(); + protected final Set<Class<?>> excludedFieldTypes = new HashSet<Class<?>>(); + + public Options() {} + + /** + * Do not serialize {@code null} values. + * + * @return a reference to this {@code Options} instance + */ + public Options excludeNulls() { + excludeNulls = true; + return this; + } + + /** + * Disables the escaping of Unicode characters in JSON String values. + * + * @return a reference to this {@code Options} instance + */ + public Options disableUnicodeEscaping() { + disableUnicodeEscaping = true; + return this; + } + + /** + * Sets the date format that will be used to serialize {@code Date} objects. + * This must be a valid pattern for {@link java.text.SimpleDateFormat} and the + * date formatter will be constructed with the default locale of {@link Locale#US}. + * + * @param format date format pattern used to serialize dates + * @return a reference to this {@code Options} instance + * @exception NullPointerException if the given pattern is null + * @exception IllegalArgumentException if the given pattern is invalid + */ + public Options dateFormat(String format) { + return dateFormat(format, JSON_DATE_FORMAT_LOCALE); + } + + /** + * Sets the date format that will be used to serialize {@code Date} objects. + * This must be a valid pattern for {@link java.text.SimpleDateFormat}. + * + * @param format date format pattern used to serialize dates + * @param locale the locale whose date format symbols will be used + * @return a reference to this {@code Options} instance + * @exception IllegalArgumentException if the given pattern is invalid + */ + public Options dateFormat(String format, Locale locale) { + // validate date format pattern + new SimpleDateFormat(format, locale); + dateFormat = format; + dateLocale = locale; + return this; + } + + /** + * Sets the time zone that will be used to serialize dates. + * + * @param timezone used to serialize dates + * @return a reference to this {@code Options} instance + * @exception NullPointerException if the given timezone is null + */ + public Options timezone(String timezone) { + this.timezone = TimeZone.getTimeZone(timezone); + return this; + } + + /** + * Registers a closure that will be called when the specified type or subtype + * is serialized. + * + * <p>The closure must accept either 1 or 2 parameters. The first parameter + * is required and will be instance of the {@code type} for which the closure + * is registered. The second optional parameter should be of type {@code String} + * and, if available, will be passed the name of the key associated with this + * value if serializing a JSON Object. This parameter will be {@code null} when + * serializing a JSON Array or when there is no way to determine the name of the key. + * + * <p>The return value from the closure must be a valid JSON value. The result + * of the closure will be written to the internal buffer directly and no quoting, + * escaping or other manipulation will be done to the resulting output. + * + * <p> + * Example: + * <pre><code class="groovyTestCase"> + * def generator = new groovy.json.JsonGenerator.Options() + * .addConverter(URL) { URL u -> + * "\"${u.getHost()}\"" + * } + * .build() + * + * def input = [domain: new URL('http://groovy-lang.org/json.html#_parser_variants')] + * + * assert generator.toJson(input) == '{"domain":"groovy-lang.org"}' + * </code></pre> + * + * <p>If two or more closures are registered for the exact same type the last + * closure based on the order they were specified will be used. When serializing an + * object its type is compared to the list of registered types in the order the were + * given and the closure for the first suitable type will be called. Therefore, it is + * important to register more specific types first. + * + * @param type the type to convert + * @param closure called when the registered type or any type assignable to the given + * type is encountered + * @param <T> the type this converter is registered to handle + * @return a reference to this {@code Options} instance + * @exception NullPointerException if the given type or closure is null + * @exception IllegalArgumentException if the given closure does not accept + * a parameter of the given type + */ + public <T> Options addConverter(Class<T> type, + @ClosureParams(value=FromString.class, options={"T","T,String"}) + Closure<? extends CharSequence> closure) + { + Converter converter = new DefaultJsonGenerator.ClosureConverter(type, closure); + if (converters.contains(converter)) { + converters.remove(converter); + } + converters.add(converter); + return this; + } + + /** + * Excludes from the output any fields that match the specified names. + * + * @param fieldNames name of the field to exclude from the output + * @return a reference to this {@code Options} instance + */ + public Options excludeFieldsByName(CharSequence... fieldNames) { + return excludeFieldsByName(Arrays.asList(fieldNames)); + } + + /** + * Excludes from the output any fields that match the specified names. + * + * @param fieldNames collection of names to exclude from the output + * @return a reference to this {@code Options} instance + */ + public Options excludeFieldsByName(Iterable<? extends CharSequence> fieldNames) { + for (CharSequence cs : fieldNames) { + if (cs != null) { + excludedFieldNames.add(cs.toString()); + } + } + return this; + } + + /** + * Excludes from the output any fields whose type is the same or is + * assignable to any of the given types. + * + * @param types excluded from the output + * @return a reference to this {@code Options} instance + */ + public Options excludeFieldsByType(Class<?>... types) { + return excludeFieldsByType(Arrays.asList(types)); + } + + /** + * Excludes from the output any fields whose type is the same or is + * assignable to any of the given types. + * + * @param types collection of types to exclude from the output + * @return a reference to this {@code Options} instance + */ + public Options excludeFieldsByType(Iterable<Class<?>> types) { + for (Class<?> c : types) { + if (c != null) { + excludedFieldTypes.add(c); + } + } + return this; + } + + /** + * Creates a {@link JsonGenerator} that is based on the current options. + * + * @return a fully configured {@link JsonGenerator} + */ + public JsonGenerator build() { + return new DefaultJsonGenerator(this); + } + } + +} http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/main/java/groovy/json/JsonOutput.java ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/main/java/groovy/json/JsonOutput.java b/subprojects/groovy-json/src/main/java/groovy/json/JsonOutput.java index 322e9f1..aa95b07 100644 --- a/subprojects/groovy-json/src/main/java/groovy/json/JsonOutput.java +++ b/subprojects/groovy-json/src/main/java/groovy/json/JsonOutput.java @@ -22,19 +22,17 @@ import groovy.json.internal.CharBuf; import groovy.json.internal.Chr; import groovy.lang.Closure; import groovy.util.Expando; -import org.codehaus.groovy.runtime.DefaultGroovyMethods; -import java.io.File; import java.io.StringReader; -import java.math.BigDecimal; -import java.math.BigInteger; import java.net.URL; -import java.text.SimpleDateFormat; import java.util.*; /** * Class responsible for the actual String serialization of the possible values of a JSON structure. * This class can also be used as a category, so as to add <code>toJson()</code> methods to various types. + * <p> + * This class does not provide the ability to customize the resulting output. A {@link JsonGenerator} + * can be used if the ability to alter the resulting output is required. * * @author Guillaume Laforge * @author Roshan Dawrani @@ -42,6 +40,7 @@ import java.util.*; * @author Rick Hightower * @author Graeme Rocher * + * @see JsonGenerator * @since 1.8.0 */ public class JsonOutput { @@ -56,20 +55,18 @@ public class JsonOutput { static final char NEW_LINE = '\n'; static final char QUOTE = '"'; - private static final char[] EMPTY_STRING_CHARS = Chr.array(QUOTE, QUOTE); + static final char[] EMPTY_STRING_CHARS = Chr.array(QUOTE, QUOTE); + static final char[] EMPTY_MAP_CHARS = {OPEN_BRACE, CLOSE_BRACE}; + static final char[] EMPTY_LIST_CHARS = {OPEN_BRACKET, CLOSE_BRACKET}; - private static final String NULL_VALUE = "null"; - private static final String JSON_DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ssZ"; - private static final String DEFAULT_TIMEZONE = "GMT"; + /* package-private for use in builders */ + static final JsonGenerator DEFAULT_GENERATOR = new DefaultJsonGenerator(new JsonGenerator.Options()); /** * @return "true" or "false" for a boolean value */ public static String toJson(Boolean bool) { - CharBuf buffer = CharBuf.create(4); - writeObject(bool, buffer); // checking null inside - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(bool); } /** @@ -77,39 +74,21 @@ public class JsonOutput { * @throws JsonException if the number is infinite or not a number. */ public static String toJson(Number n) { - if (n == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(3); - Class<?> numberClass = n.getClass(); - writeNumber(numberClass, n, buffer); - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(n); } /** * @return a JSON string representation of the character */ public static String toJson(Character c) { - CharBuf buffer = CharBuf.create(3); - writeObject(c, buffer); // checking null inside - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(c); } /** * @return a properly encoded string with escape sequences */ public static String toJson(String s) { - if (s == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(s.length() + 2); - writeCharSequence(s, buffer); - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(s); } /** @@ -119,14 +98,7 @@ public class JsonOutput { * @return a formatted date in the form of a string */ public static String toJson(Date date) { - if (date == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(26); - writeDate(date, buffer); - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(date); } /** @@ -136,62 +108,35 @@ public class JsonOutput { * @return a formatted date in the form of a string */ public static String toJson(Calendar cal) { - if (cal == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(26); - writeDate(cal.getTime(), buffer); - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(cal); } /** * @return the string representation of an uuid */ public static String toJson(UUID uuid) { - CharBuf buffer = CharBuf.create(64); - writeObject(uuid, buffer); // checking null inside - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(uuid); } /** * @return the string representation of the URL */ public static String toJson(URL url) { - CharBuf buffer = CharBuf.create(64); - writeObject(url, buffer); // checking null inside - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(url); } /** * @return an object representation of a closure */ public static String toJson(Closure closure) { - if (closure == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(255); - writeMap(JsonDelegate.cloneDelegateAndGetContent(closure), buffer); - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(closure); } /** * @return an object representation of an Expando */ public static String toJson(Expando expando) { - if (expando == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(255); - writeMap(expando.getProperties(), buffer); - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(expando); } /** @@ -199,289 +144,14 @@ public class JsonOutput { * or representation for other object. */ public static String toJson(Object object) { - CharBuf buffer = CharBuf.create(255); - writeObject(object, buffer); // checking null inside - - return buffer.toString(); + return DEFAULT_GENERATOR.toJson(object); } /** * @return a JSON object representation for a map */ public static String toJson(Map m) { - if (m == null) { - return NULL_VALUE; - } - - CharBuf buffer = CharBuf.create(255); - writeMap(m, buffer); - - return buffer.toString(); - } - - /** - * Serializes Number value and writes it into specified buffer. - */ - private static void writeNumber(Class<?> numberClass, Number value, CharBuf buffer) { - if (numberClass == Integer.class) { - buffer.addInt((Integer) value); - } else if (numberClass == Long.class) { - buffer.addLong((Long) value); - } else if (numberClass == BigInteger.class) { - buffer.addBigInteger((BigInteger) value); - } else if (numberClass == BigDecimal.class) { - buffer.addBigDecimal((BigDecimal) value); - } else if (numberClass == Double.class) { - Double doubleValue = (Double) value; - if (doubleValue.isInfinite()) { - throw new JsonException("Number " + value + " can't be serialized as JSON: infinite are not allowed in JSON."); - } - if (doubleValue.isNaN()) { - throw new JsonException("Number " + value + " can't be serialized as JSON: NaN are not allowed in JSON."); - } - - buffer.addDouble(doubleValue); - } else if (numberClass == Float.class) { - Float floatValue = (Float) value; - if (floatValue.isInfinite()) { - throw new JsonException("Number " + value + " can't be serialized as JSON: infinite are not allowed in JSON."); - } - if (floatValue.isNaN()) { - throw new JsonException("Number " + value + " can't be serialized as JSON: NaN are not allowed in JSON."); - } - - buffer.addFloat(floatValue); - } else if (numberClass == Byte.class) { - buffer.addByte((Byte) value); - } else if (numberClass == Short.class) { - buffer.addShort((Short) value); - } else { // Handle other Number implementations - buffer.addString(value.toString()); - } - } - - /** - * Serializes object and writes it into specified buffer. - */ - private static void writeObject(Object object, CharBuf buffer) { - if (object == null) { - buffer.addNull(); - } else { - Class<?> objectClass = object.getClass(); - - if (CharSequence.class.isAssignableFrom(objectClass)) { // Handle String, StringBuilder, GString and other CharSequence implementations - writeCharSequence((CharSequence) object, buffer); - } else if (objectClass == Boolean.class) { - buffer.addBoolean((Boolean) object); - } else if (Number.class.isAssignableFrom(objectClass)) { - writeNumber(objectClass, (Number) object, buffer); - } else if (Date.class.isAssignableFrom(objectClass)) { - writeDate((Date) object, buffer); - } else if (Calendar.class.isAssignableFrom(objectClass)) { - writeDate(((Calendar) object).getTime(), buffer); - } else if (Map.class.isAssignableFrom(objectClass)) { - writeMap((Map) object, buffer); - } else if (Iterable.class.isAssignableFrom(objectClass)) { - writeIterator(((Iterable<?>) object).iterator(), buffer); - } else if (Iterator.class.isAssignableFrom(objectClass)) { - writeIterator((Iterator) object, buffer); - } else if (objectClass == Character.class) { - buffer.addJsonEscapedString(Chr.array((Character) object)); - } else if (objectClass == URL.class) { - buffer.addJsonEscapedString(object.toString()); - } else if (objectClass == UUID.class) { - buffer.addQuoted(object.toString()); - } else if (objectClass == JsonUnescaped.class) { - buffer.add(object.toString()); - } else if (Closure.class.isAssignableFrom(objectClass)) { - writeMap(JsonDelegate.cloneDelegateAndGetContent((Closure<?>) object), buffer); - } else if (Expando.class.isAssignableFrom(objectClass)) { - writeMap(((Expando) object).getProperties(), buffer); - } else if (Enumeration.class.isAssignableFrom(objectClass)) { - List<?> list = Collections.list((Enumeration<?>) object); - writeIterator(list.iterator(), buffer); - } else if (objectClass.isArray()) { - writeArray(objectClass, object, buffer); - } else if (Enum.class.isAssignableFrom(objectClass)) { - buffer.addQuoted(((Enum<?>) object).name()); - }else if (File.class.isAssignableFrom(objectClass)){ - Map<?, ?> properties = getObjectProperties(object); - //Clean up all recursive references to File objects - Iterator<? extends Map.Entry<?, ?>> iterator = properties.entrySet().iterator(); - while(iterator.hasNext()){ - Map.Entry<?,?> entry = iterator.next(); - if(entry.getValue() instanceof File){ - iterator.remove(); - } - } - - writeMap(properties, buffer); - } else { - Map<?, ?> properties = getObjectProperties(object); - writeMap(properties, buffer); - } - } - } - - private static Map<?, ?> getObjectProperties(Object object) { - Map<?, ?> properties = DefaultGroovyMethods.getProperties(object); - properties.remove("class"); - properties.remove("declaringClass"); - properties.remove("metaClass"); - return properties; - } - - - /** - * Serializes any char sequence and writes it into specified buffer. - */ - private static void writeCharSequence(CharSequence seq, CharBuf buffer) { - if (seq.length() > 0) { - buffer.addJsonEscapedString(seq.toString()); - } else { - buffer.addChars(EMPTY_STRING_CHARS); - } - } - - /** - * Serializes date and writes it into specified buffer. - */ - private static void writeDate(Date date, CharBuf buffer) { - SimpleDateFormat formatter = new SimpleDateFormat(JSON_DATE_FORMAT, Locale.US); - formatter.setTimeZone(TimeZone.getTimeZone(DEFAULT_TIMEZONE)); - buffer.addQuoted(formatter.format(date)); - } - - /** - * Serializes array and writes it into specified buffer. - */ - private static void writeArray(Class<?> arrayClass, Object array, CharBuf buffer) { - buffer.addChar(OPEN_BRACKET); - if (Object[].class.isAssignableFrom(arrayClass)) { - Object[] objArray = (Object[]) array; - if (objArray.length > 0) { - writeObject(objArray[0], buffer); - for (int i = 1; i < objArray.length; i++) { - buffer.addChar(COMMA); - writeObject(objArray[i], buffer); - } - } - } else if (int[].class.isAssignableFrom(arrayClass)) { - int[] intArray = (int[]) array; - if (intArray.length > 0) { - buffer.addInt(intArray[0]); - for (int i = 1; i < intArray.length; i++) { - buffer.addChar(COMMA).addInt(intArray[i]); - } - } - } else if (long[].class.isAssignableFrom(arrayClass)) { - long[] longArray = (long[]) array; - if (longArray.length > 0) { - buffer.addLong(longArray[0]); - for (int i = 1; i < longArray.length; i++) { - buffer.addChar(COMMA).addLong(longArray[i]); - } - } - } else if (boolean[].class.isAssignableFrom(arrayClass)) { - boolean[] booleanArray = (boolean[]) array; - if (booleanArray.length > 0) { - buffer.addBoolean(booleanArray[0]); - for (int i = 1; i < booleanArray.length; i++) { - buffer.addChar(COMMA).addBoolean(booleanArray[i]); - } - } - } else if (char[].class.isAssignableFrom(arrayClass)) { - char[] charArray = (char[]) array; - if (charArray.length > 0) { - buffer.addJsonEscapedString(Chr.array(charArray[0])); - for (int i = 1; i < charArray.length; i++) { - buffer.addChar(COMMA).addJsonEscapedString(Chr.array(charArray[i])); - } - } - } else if (double[].class.isAssignableFrom(arrayClass)) { - double[] doubleArray = (double[]) array; - if (doubleArray.length > 0) { - buffer.addDouble(doubleArray[0]); - for (int i = 1; i < doubleArray.length; i++) { - buffer.addChar(COMMA).addDouble(doubleArray[i]); - } - } - } else if (float[].class.isAssignableFrom(arrayClass)) { - float[] floatArray = (float[]) array; - if (floatArray.length > 0) { - buffer.addFloat(floatArray[0]); - for (int i = 1; i < floatArray.length; i++) { - buffer.addChar(COMMA).addFloat(floatArray[i]); - } - } - } else if (byte[].class.isAssignableFrom(arrayClass)) { - byte[] byteArray = (byte[]) array; - if (byteArray.length > 0) { - buffer.addByte(byteArray[0]); - for (int i = 1; i < byteArray.length; i++) { - buffer.addChar(COMMA).addByte(byteArray[i]); - } - } - } else if (short[].class.isAssignableFrom(arrayClass)) { - short[] shortArray = (short[]) array; - if (shortArray.length > 0) { - buffer.addShort(shortArray[0]); - for (int i = 1; i < shortArray.length; i++) { - buffer.addChar(COMMA).addShort(shortArray[i]); - } - } - } - buffer.addChar(CLOSE_BRACKET); - } - - private static final char[] EMPTY_MAP_CHARS = {OPEN_BRACE, CLOSE_BRACE}; - - /** - * Serializes map and writes it into specified buffer. - */ - private static void writeMap(Map<?, ?> map, CharBuf buffer) { - if (!map.isEmpty()) { - buffer.addChar(OPEN_BRACE); - boolean firstItem = true; - for (Map.Entry<?, ?> entry : map.entrySet()) { - if (entry.getKey() == null) { - throw new IllegalArgumentException("Maps with null keys can\'t be converted to JSON"); - } - - if (!firstItem) { - buffer.addChar(COMMA); - } else { - firstItem = false; - } - - buffer.addJsonFieldName(entry.getKey().toString()); - writeObject(entry.getValue(), buffer); - } - buffer.addChar(CLOSE_BRACE); - } else { - buffer.addChars(EMPTY_MAP_CHARS); - } - } - - private static final char[] EMPTY_LIST_CHARS = {OPEN_BRACKET, CLOSE_BRACKET}; - - /** - * Serializes iterator and writes it into specified buffer. - */ - private static void writeIterator(Iterator<?> iterator, CharBuf buffer) { - if (iterator.hasNext()) { - buffer.addChar(OPEN_BRACKET); - Object it = iterator.next(); - writeObject(it, buffer); - while (iterator.hasNext()) { - it = iterator.next(); - buffer.addChar(COMMA); - writeObject(it, buffer); - } - buffer.addChar(CLOSE_BRACKET); - } else { - buffer.addChars(EMPTY_LIST_CHARS); - } + return DEFAULT_GENERATOR.toJson(m); } /** http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/main/java/groovy/json/StreamingJsonBuilder.java ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/main/java/groovy/json/StreamingJsonBuilder.java b/subprojects/groovy-json/src/main/java/groovy/json/StreamingJsonBuilder.java index e52986f..69d5173 100644 --- a/subprojects/groovy-json/src/main/java/groovy/json/StreamingJsonBuilder.java +++ b/subprojects/groovy-json/src/main/java/groovy/json/StreamingJsonBuilder.java @@ -73,6 +73,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { private static final String COLON_WITH_OPEN_BRACE = ":{"; private final Writer writer; + private final JsonGenerator generator; /** * Instantiates a JSON builder. @@ -81,6 +82,19 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { */ public StreamingJsonBuilder(Writer writer) { this.writer = writer; + generator = JsonOutput.DEFAULT_GENERATOR; + } + + /** + * Instantiates a JSON builder with the given generator. + * + * @param writer A writer to which Json will be written + * @param generator used to generate the output + * @since 2.5 + */ + public StreamingJsonBuilder(Writer writer, JsonGenerator generator) { + this.writer = writer; + this.generator = generator; } /** @@ -88,11 +102,27 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * * @param writer A writer to which Json will be written * @param content a pre-existing data structure, default to null + * @throws IOException */ public StreamingJsonBuilder(Writer writer, Object content) throws IOException { - this(writer); + this(writer, content, JsonOutput.DEFAULT_GENERATOR); + } + + /** + * Instantiates a JSON builder, possibly with some existing data structure and + * the given generator. + * + * @param writer A writer to which Json will be written + * @param content a pre-existing data structure, default to null + * @param generator used to generate the output + * @throws IOException + * @since 2.5 + */ + public StreamingJsonBuilder(Writer writer, Object content, JsonGenerator generator) throws IOException { + this.writer = writer; + this.generator = generator; if (content != null) { - writer.write(JsonOutput.toJson(content)); + writer.write(generator.toJson(content)); } } @@ -113,7 +143,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @return a map of key / value pairs */ public Object call(Map m) throws IOException { - writer.write(JsonOutput.toJson(m)); + writer.write(generator.toJson(m)); return m; } @@ -133,7 +163,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name) throws IOException { - writer.write(JsonOutput.toJson(Collections.singletonMap(name, Collections.emptyMap()))); + writer.write(generator.toJson(Collections.singletonMap(name, Collections.emptyMap()))); } /** @@ -154,7 +184,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @return a list of values */ public Object call(List l) throws IOException { - writer.write(JsonOutput.toJson(l)); + writer.write(generator.toJson(l)); return l; } @@ -204,7 +234,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @param c a closure used to convert the objects of coll */ public Object call(Iterable coll, @DelegatesTo(StreamingJsonDelegate.class) Closure c) throws IOException { - return StreamingJsonDelegate.writeCollectionWithClosure(writer, coll, c); + return StreamingJsonDelegate.writeCollectionWithClosure(writer, coll, c, generator); } /** @@ -234,7 +264,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { */ public Object call(@DelegatesTo(StreamingJsonDelegate.class) Closure c) throws IOException { writer.write(JsonOutput.OPEN_BRACE); - StreamingJsonDelegate.cloneDelegateAndGetContent(writer, c); + StreamingJsonDelegate.cloneDelegateAndGetContent(writer, c, true, generator); writer.write(JsonOutput.CLOSE_BRACE); return null; @@ -261,7 +291,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { */ public void call(String name, @DelegatesTo(StreamingJsonDelegate.class) Closure c) throws IOException { writer.write(JsonOutput.OPEN_BRACE); - writer.write(JsonOutput.toJson(name)); + writer.write(generator.toJson(name)); writer.write(JsonOutput.COLON); call(c); writer.write(JsonOutput.CLOSE_BRACE); @@ -292,7 +322,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { */ public void call(String name, Iterable coll, @DelegatesTo(StreamingJsonDelegate.class) Closure c) throws IOException { writer.write(JsonOutput.OPEN_BRACE); - writer.write(JsonOutput.toJson(name)); + writer.write(generator.toJson(name)); writer.write(JsonOutput.COLON); call(coll, c); writer.write(JsonOutput.CLOSE_BRACE); @@ -329,7 +359,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { */ public void call(String name, Map map, @DelegatesTo(StreamingJsonDelegate.class) Closure callable) throws IOException { writer.write(JsonOutput.OPEN_BRACE); - writer.write(JsonOutput.toJson(name)); + writer.write(generator.toJson(name)); writer.write(COLON_WITH_OPEN_BRACE); boolean first = true; for (Object it : map.entrySet()) { @@ -340,11 +370,19 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { } Map.Entry entry = (Map.Entry) it; - writer.write(JsonOutput.toJson(entry.getKey())); + String key = entry.getKey().toString(); + if (generator.isExcludingFieldsNamed(key)) { + continue; + } + Object value = entry.getValue(); + if (generator.isExcludingValues(value)) { + return; + } + writer.write(generator.toJson(key)); writer.write(JsonOutput.COLON); - writer.write(JsonOutput.toJson(entry.getValue())); + writer.write(generator.toJson(value)); } - StreamingJsonDelegate.cloneDelegateAndGetContent(writer, callable, map.size() == 0); + StreamingJsonDelegate.cloneDelegateAndGetContent(writer, callable, map.size() == 0, generator); writer.write(DOUBLE_CLOSE_BRACKET); } @@ -479,10 +517,16 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { protected boolean first; protected State state; + private final JsonGenerator generator; public StreamingJsonDelegate(Writer w, boolean first) { + this(w, first, null); + } + + StreamingJsonDelegate(Writer w, boolean first, JsonGenerator generator) { this.writer = w; this.first = first; + this.generator = (generator != null) ? generator : JsonOutput.DEFAULT_GENERATOR; } /** @@ -548,6 +592,9 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name, List<Object> list) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } writeName(name); writeArray(list); } @@ -559,6 +606,9 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name, Object...array) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } writeName(name); writeArray(Arrays.asList(array)); } @@ -589,6 +639,9 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @param c a closure used to convert the objects of coll */ public void call(String name, Iterable coll, @DelegatesTo(StreamingJsonDelegate.class) Closure c) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } writeName(name); writeObjects(coll, c); } @@ -608,6 +661,9 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name, Object value) throws IOException { + if (generator.isExcludingFieldsNamed(name) || generator.isExcludingValues(value)) { + return; + } writeName(name); writeValue(value); } @@ -620,9 +676,12 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name, Object value, @DelegatesTo(StreamingJsonDelegate.class) Closure callable) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } writeName(name); verifyValue(); - writeObject(writer, value, callable); + writeObject(writer, value, callable, generator); } /** * Writes the name and another JSON object @@ -632,10 +691,13 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name,@DelegatesTo(StreamingJsonDelegate.class) Closure value) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } writeName(name); verifyValue(); writer.write(JsonOutput.OPEN_BRACE); - StreamingJsonDelegate.cloneDelegateAndGetContent(writer, value); + StreamingJsonDelegate.cloneDelegateAndGetContent(writer, value, true, generator); writer.write(JsonOutput.CLOSE_BRACE); } @@ -647,6 +709,9 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { * @throws IOException */ public void call(String name, JsonOutput.JsonUnescaped json) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } writeName(name); verifyValue(); writer.write(json.toString()); @@ -672,7 +737,7 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { private void writeObjects(Iterable coll, @DelegatesTo(StreamingJsonDelegate.class) Closure c) throws IOException { verifyValue(); - writeCollectionWithClosure(writer, coll, c); + writeCollectionWithClosure(writer, coll, c, generator); } protected void verifyValue() { @@ -686,6 +751,9 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { protected void writeName(String name) throws IOException { + if (generator.isExcludingFieldsNamed(name)) { + return; + } if(state == State.NAME) { throw new IllegalStateException("Cannot write a name when a name has just been written. Write a value first!"); } @@ -697,18 +765,21 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { } else { first = false; } - writer.write(JsonOutput.toJson(name)); + writer.write(generator.toJson(name)); writer.write(JsonOutput.COLON); } protected void writeValue(Object value) throws IOException { + if (generator.isExcludingValues(value)) { + return; + } verifyValue(); - writer.write(JsonOutput.toJson(value)); + writer.write(generator.toJson(value)); } protected void writeArray(List<Object> list) throws IOException { verifyValue(); - writer.write(JsonOutput.toJson(list)); + writer.write(generator.toJson(list)); } public static boolean isCollectionWithClosure(Object[] args) { @@ -716,10 +787,11 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { } public static Object writeCollectionWithClosure(Writer writer, Collection coll, @DelegatesTo(StreamingJsonDelegate.class) Closure closure) throws IOException { - return writeCollectionWithClosure(writer, (Iterable)coll, closure); + return writeCollectionWithClosure(writer, (Iterable)coll, closure, JsonOutput.DEFAULT_GENERATOR); } - public static Object writeCollectionWithClosure(Writer writer, Iterable coll, @DelegatesTo(StreamingJsonDelegate.class) Closure closure) throws IOException { + private static Object writeCollectionWithClosure(Writer writer, Iterable coll, @DelegatesTo(StreamingJsonDelegate.class) Closure closure, JsonGenerator generator) + throws IOException { writer.write(JsonOutput.OPEN_BRACKET); boolean first = true; for (Object it : coll) { @@ -729,16 +801,16 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { first = false; } - writeObject(writer, it, closure); + writeObject(writer, it, closure, generator); } writer.write(JsonOutput.CLOSE_BRACKET); return writer; } - private static void writeObject(Writer writer, Object object, Closure closure) throws IOException { + private static void writeObject(Writer writer, Object object, Closure closure, JsonGenerator generator) throws IOException { writer.write(JsonOutput.OPEN_BRACE); - curryDelegateAndGetContent(writer, closure, object); + curryDelegateAndGetContent(writer, closure, object, true, generator); writer.write(JsonOutput.CLOSE_BRACE); } @@ -748,7 +820,11 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { } public static void cloneDelegateAndGetContent(Writer w, @DelegatesTo(StreamingJsonDelegate.class) Closure c, boolean first) { - StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first); + cloneDelegateAndGetContent(w, c, first, JsonOutput.DEFAULT_GENERATOR); + } + + private static void cloneDelegateAndGetContent(Writer w, @DelegatesTo(StreamingJsonDelegate.class) Closure c, boolean first, JsonGenerator generator) { + StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first, generator); Closure cloned = (Closure) c.clone(); cloned.setDelegate(delegate); cloned.setResolveStrategy(Closure.DELEGATE_FIRST); @@ -760,7 +836,11 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { } public static void curryDelegateAndGetContent(Writer w, @DelegatesTo(StreamingJsonDelegate.class) Closure c, Object o, boolean first) { - StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first); + curryDelegateAndGetContent(w, c, o, first, JsonOutput.DEFAULT_GENERATOR); + } + + private static void curryDelegateAndGetContent(Writer w, @DelegatesTo(StreamingJsonDelegate.class) Closure c, Object o, boolean first, JsonGenerator generator) { + StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first, generator); Closure curried = c.curry(o); curried.setDelegate(delegate); curried.setResolveStrategy(Closure.DELEGATE_FIRST); @@ -772,5 +852,3 @@ public class StreamingJsonBuilder extends GroovyObjectSupport { } } } - - http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/main/java/groovy/json/internal/CharBuf.java ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/main/java/groovy/json/internal/CharBuf.java b/subprojects/groovy-json/src/main/java/groovy/json/internal/CharBuf.java index feaa614..18f5d6a 100644 --- a/subprojects/groovy-json/src/main/java/groovy/json/internal/CharBuf.java +++ b/subprojects/groovy-json/src/main/java/groovy/json/internal/CharBuf.java @@ -341,32 +341,34 @@ public class CharBuf extends Writer implements CharSequence { } public final CharBuf addJsonEscapedString(String jsonString) { + return addJsonEscapedString(jsonString, false); + } + + public final CharBuf addJsonEscapedString(String jsonString, boolean disableUnicodeEscaping) { char[] charArray = FastStringUtils.toCharArray(jsonString); - return addJsonEscapedString(charArray); + return addJsonEscapedString(charArray, disableUnicodeEscaping); } - private static boolean hasAnyJSONControlOrUnicodeChars(int c) { - /* Anything less than space is a control character. */ - if (c < 30) { + private static boolean shouldEscape(int c, boolean disableUnicodeEscaping) { + if (c < 32) { /* less than space is a control char */ return true; - /* 34 is double quote. */ - } else if (c == 34) { + } else if (c == 34) { /* double quote */ return true; - } else if (c == 92) { + } else if (c == 92) { /* backslash */ return true; - } else if (c < ' ' || c > 126) { + } else if (!disableUnicodeEscaping && c > 126) { /* non-ascii char range */ return true; } return false; } - private static boolean hasAnyJSONControlChars(final char[] charArray) { + private static boolean hasAnyJSONControlChars(final char[] charArray, boolean disableUnicodeEscaping) { int index = 0; char c; while (true) { c = charArray[index]; - if (hasAnyJSONControlOrUnicodeChars(c)) { + if (shouldEscape(c, disableUnicodeEscaping)) { return true; } if (++index >= charArray.length) return false; @@ -374,9 +376,13 @@ public class CharBuf extends Writer implements CharSequence { } public final CharBuf addJsonEscapedString(final char[] charArray) { + return addJsonEscapedString(charArray, false); + } + + public final CharBuf addJsonEscapedString(final char[] charArray, boolean disableUnicodeEscaping) { if (charArray.length == 0) return this; - if (hasAnyJSONControlChars(charArray)) { - return doAddJsonEscapedString(charArray); + if (hasAnyJSONControlChars(charArray, disableUnicodeEscaping)) { + return doAddJsonEscapedString(charArray, disableUnicodeEscaping); } else { return this.addQuoted(charArray); } @@ -386,7 +392,7 @@ public class CharBuf extends Writer implements CharSequence { final byte[] charTo = new byte[2]; - private CharBuf doAddJsonEscapedString(char[] charArray) { + private CharBuf doAddJsonEscapedString(char[] charArray, boolean disableUnicodeEscaping) { char[] _buffer = buffer; int _location = this.location; @@ -410,7 +416,7 @@ public class CharBuf extends Writer implements CharSequence { while (true) { char c = charArray[index]; - if (hasAnyJSONControlOrUnicodeChars(c)) { + if (shouldEscape(c, disableUnicodeEscaping)) { /* We are covering our bet with a safety net. otherwise we would have to have 5x buffer allocated for control chars */ @@ -514,14 +520,22 @@ public class CharBuf extends Writer implements CharSequence { } public final CharBuf addJsonFieldName(String str) { - return addJsonFieldName(FastStringUtils.toCharArray(str)); + return addJsonFieldName(str, false); + } + + public final CharBuf addJsonFieldName(String str, boolean disableUnicodeEscaping) { + return addJsonFieldName(FastStringUtils.toCharArray(str), disableUnicodeEscaping); } private static final char[] EMPTY_STRING_CHARS = Chr.array('"', '"'); public final CharBuf addJsonFieldName(char[] chars) { + return addJsonFieldName(chars, false); + } + + public final CharBuf addJsonFieldName(char[] chars, boolean disableUnicodeEscaping) { if (chars.length > 0) { - addJsonEscapedString(chars); + addJsonEscapedString(chars, disableUnicodeEscaping); } else { addChars(EMPTY_STRING_CHARS); } @@ -671,7 +685,16 @@ public class CharBuf extends Writer implements CharSequence { } public void removeLastChar() { - location--; + if (location > 0) { + location--; + } + } + + public void removeLastChar(char expect) { + if (location == 0 || buffer[location-1] != expect) { + return; + } + removeLastChar(); } private Cache<BigDecimal, char[]> bigDCache; http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/spec/doc/json-builder.adoc ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/spec/doc/json-builder.adoc b/subprojects/groovy-json/src/spec/doc/json-builder.adoc index dcf21d4..28ffd58 100644 --- a/subprojects/groovy-json/src/spec/doc/json-builder.adoc +++ b/subprojects/groovy-json/src/spec/doc/json-builder.adoc @@ -40,4 +40,11 @@ We use https://github.com/lukas-krecan/JsonUnit[JsonUnit] to check that the buil [source,groovy] ---- include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy[tags=json_assert,indent=0] ----- \ No newline at end of file +---- + +If you need to customize the generated output you can pass a `JsonGenerator` instance when creating a `JsonBuilder`: + +[source,groovy] +---- +include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy[tags=json_builder_generator,indent=0] +---- http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/spec/doc/json-userguide.adoc ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/spec/doc/json-userguide.adoc b/subprojects/groovy-json/src/spec/doc/json-userguide.adoc index 5557568..683e403 100644 --- a/subprojects/groovy-json/src/spec/doc/json-userguide.adoc +++ b/subprojects/groovy-json/src/spec/doc/json-userguide.adoc @@ -159,7 +159,7 @@ include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonTest.gr <<json-userguide.adoc#json_jsonslurper,JsonSlurper>>, being a JSON parser. `JsonOutput` comes with overloaded, static `toJson` methods. Each `toJson` implementation takes a different parameter type. -The static method can either be used directly or by importing the methods with a static import statement. +The static methods can either be used directly or by importing the methods with a static import statement. The result of a `toJson` call is a `String` containing the JSON code. @@ -176,6 +176,30 @@ has support for serialising POGOs, that is, plain-old Groovy objects. include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonTest.groovy[tags=json_output_pogo,indent=0] ---- +=== Customizing Output + +If you need control over the serialized output you can use a `JsonGenerator`. The `JsonGenerator.Options` builder +can be used to create a customized generator. One or more options can be set on this builder in order to alter +the resulting output. When you are done setting the options simply call the `build()` method in order to get a fully +configured instance that will generate output based on the options selected. + +[source,groovy] +---- +include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonTest.groovy[tags=json_output_generator,indent=0] +---- + +A closure can be used to transform a type into a valid JSON value. These closure converters are registered +for a given type and will be called any time that type or a subtype is encountered. The first parameter to the +closure is an object matching the type for which the converter is registered and this parameter is required. +The closure may take an optional second `String` parameter and this will be set to the key name if one is available. + +[source,groovy] +---- +include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonTest.groovy[tags=json_output_converter,indent=0] +---- + +==== Formatted Output + As we saw in previous examples, the JSON output is not pretty printed per default. However, the `prettyPrint` method in `JsonOutput` comes to rescue for this task. @@ -187,6 +211,8 @@ include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/JsonTest.gr `prettyPrint` takes a `String` as single parameter; therefore, it can be applied on arbitrary JSON `String` instances, not only the result of `JsonOutput.toJson`. +=== Builders + Another way to create JSON from Groovy is to use `JsonBuilder` or `StreamingJsonBuilder`. Both builders provide a DSL which allows to formulate an object graph which is then converted to JSON. http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/spec/doc/streaming-jason-builder.adoc ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/spec/doc/streaming-jason-builder.adoc b/subprojects/groovy-json/src/spec/doc/streaming-jason-builder.adoc index 296794e..98d3e59 100644 --- a/subprojects/groovy-json/src/spec/doc/streaming-jason-builder.adoc +++ b/subprojects/groovy-json/src/spec/doc/streaming-jason-builder.adoc @@ -44,4 +44,11 @@ We use https://github.com/lukas-krecan/JsonUnit[JsonUnit] to check the expected [source,groovy] ---- include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/StreamingJsonBuilderTest.groovy[tags=json_assert,indent=0] ----- \ No newline at end of file +---- + +If you need to customize the generated output you can pass a `JsonGenerator` instance when creating a `StreamingJsonBuilder`: + +[source,groovy] +---- +include::{rootProjectDir}/subprojects/groovy-json/src/spec/test/json/StreamingJsonBuilderTest.groovy[tags=streaming_json_builder_generator,indent=0] +---- http://git-wip-us.apache.org/repos/asf/groovy/blob/13202599/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy ---------------------------------------------------------------------- diff --git a/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy b/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy index 87ab5f1..d4a1576 100644 --- a/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy +++ b/subprojects/groovy-json/src/spec/test/json/JsonBuilderTest.groovy @@ -69,4 +69,36 @@ class JsonBuilderTest extends GroovyTestCase { // end::json_assert[] """ } + + void testJsonBuilderWithGenerator() { + assertScript """ + // tag::json_builder_generator[] + import groovy.json.* + + def generator = new JsonGenerator.Options() + .excludeNulls() + .excludeFieldsByName('make', 'country', 'record') + .excludeFieldsByType(Number) + .addConverter(URL) { url -> '"http://groovy-lang.org";' } + .build() + + JsonBuilder builder = new JsonBuilder(generator) + builder.records { + car { + name 'HSV Maloo' + make 'Holden' + year 2006 + country 'Australia' + homepage new URL('http://example.org') + record { + type 'speed' + description 'production pickup truck with speed of 271kph' + } + } + } + + assert builder.toString() == '{"records":{"car":{"name":"HSV Maloo","homepage":"http://groovy-lang.org"}}}' + // end::json_builder_generator[] + """ + } }
