Class PlainTextParser.Builder
- Enclosing class:
PlainTextParser
-
Constructor Summary
ModifierConstructorDescriptionprotected
Builder()
Constructor, default settings.protected
Builder
(PlainTextParser copyFrom) Copy constructor.protected
Builder
(PlainTextParser.Builder copyFrom) Copy constructor. -
Method Summary
Modifier and TypeMethodDescriptionannotations
(Annotation... values) Defines annotations to apply to specific classes and methods.apply
(AnnotationWorkList work) Applies a set of applied to this builder.applyAnnotations
(Class<?>... fromClasses) Applies any of the various@XConfig annotations on the specified class to this context.applyAnnotations
(Method... fromMethods) Applies any of the various@XConfig annotations on the specified method to this context.Auto-close streams.autoCloseStreams
(boolean value) Same asParser.Builder.autoCloseStreams()
but allows you to explicitly specify the value.beanClassVisibility
(Visibility value) Minimum bean class visibility.Minimum bean constructor visibility.beanContext
(BeanContext value) Specifies an already-instantiated bean context to use.beanContext
(BeanContext.Builder value) Overrides the bean context builder.beanDictionary
(Class<?>... values) Bean dictionary.beanFieldVisibility
(Visibility value) Minimum bean field visibility.beanInterceptor
(Class<?> on, Class<? extends BeanInterceptor<?>> value) Bean interceptor.BeanMap.put() returns old property value.beanMethodVisibility
(Visibility value) Minimum bean method visibility.beanProperties
(Class<?> beanClass, String properties) Bean property includes.beanProperties
(String beanClassName, String properties) Bean property includes.beanProperties
(Map<String, Object> values) Bean property includes.beanPropertiesExcludes
(Class<?> beanClass, String properties) Bean property excludes.beanPropertiesExcludes
(String beanClassName, String properties) Bean property excludes.beanPropertiesExcludes
(Map<String, Object> values) Bean property excludes.beanPropertiesReadOnly
(Class<?> beanClass, String properties) Read-only bean properties.beanPropertiesReadOnly
(String beanClassName, String properties) Read-only bean properties.beanPropertiesReadOnly
(Map<String, Object> values) Read-only bean properties.beanPropertiesWriteOnly
(Class<?> beanClass, String properties) Write-only bean properties.beanPropertiesWriteOnly
(String beanClassName, String properties) Write-only bean properties.beanPropertiesWriteOnly
(Map<String, Object> values) Write-only bean properties.Beans require no-arg constructors.Beans require Serializable interface.Beans require setters for getters.build()
Build the object.Specifies a cache to use for hashkey-based caching.Specifies the media type that this parser consumes.copy()
Copy creator.debug()
Context configuration property: Debug mode.debug
(boolean value) Same asContext.Builder.debug()
but allows you to explicitly specify the value.debugOutputLines
(int value) Debug output lines.dictionaryOn
(Class<?> on, Class<?>... values) Bean dictionary.Beans don't require at least one property.Don't silently ignore missing setters.Don't ignore transient fields.Don't ignore unknown properties with null values.Don't use interface proxies.POJO example.POJO example.fileCharset
(Charset value) File charset.Find fluent setters.findFluentSetters
(Class<?> on) Find fluent setters.hashKey()
Returns the hashkey of this builder.Ignore invocation errors on getters.Ignore invocation errors on setters.Ignore unknown properties.Ignore unknown enum values.Specifies a pre-instantiated bean for theContext.Builder.build()
method to return.Implementation classes.implClasses
(Map<Class<?>, Class<?>> values) Implementation classes.interfaceClass
(Class<?> on, Class<?> value) Identifies a class to be used as the interface class for the specified class and all subclasses.interfaces
(Class<?>... value) Identifies a set of interfaces.listener
(Class<? extends ParserListener> value) Parser listener.Context configuration property: Locale.Context configuration property: Media type.notBeanClasses
(Class<?>... values) Bean class exclusions.notBeanPackages
(String... values) Bean package exclusions.propertyNamer
(Class<?> on, Class<? extends PropertyNamer> value) Bean property namerpropertyNamer
(Class<? extends PropertyNamer> value) Bean property namerSort bean properties.sortProperties
(Class<?>... on) Sort bean properties.Identifies a stop class for the annotated class.streamCharset
(Charset value) Input stream charset.strict()
Strict mode.strict
(boolean value) Same asParser.Builder.strict()
but allows you to explicitly specify the value.<T,
S> PlainTextParser.Builder swap
(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T, S> swapFunction) A shortcut for defining aFunctionalSwap
.<T,
S> PlainTextParser.Builder swap
(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T, S> swapFunction, ThrowingFunction<S, T> unswapFunction) A shortcut for defining aFunctionalSwap
.Java object swaps.Context configuration property: TimeZone.Trim parsed strings.trimStrings
(boolean value) Same asParser.Builder.trimStrings()
but allows you to explicitly specify the value.Associates a context class with this builder.An identifying name for this class.typePropertyName
(Class<?> on, String value) Bean type property name.typePropertyName
(String value) Bean type property name.Unbuffered.unbuffered
(boolean value) Same asParser.Builder.unbuffered()
but allows you to explicitly specify the value.Use enum names.Use Java Introspector.Methods inherited from class org.apache.juneau.parser.Parser.Builder
getConsumes
Methods inherited from class org.apache.juneau.BeanContextable.Builder
beanContext, beanContext
Methods inherited from class org.apache.juneau.Context.Builder
apply, build, canApply, env, env, getApplied, getType, isDebug, registerBuilders
-
Constructor Details
-
Builder
protected Builder()Constructor, default settings. -
Builder
Copy constructor.- Parameters:
copyFrom
- The bean to copy from.
-
Builder
Copy constructor.- Parameters:
copyFrom
- The builder to copy from.
-
-
Method Details
-
copy
Description copied from class:Context.Builder
Copy creator.- Overrides:
copy
in classReaderParser.Builder
- Returns:
- A new mutable copy of this builder.
-
build
Description copied from class:Context.Builder
Build the object.- Overrides:
build
in classReaderParser.Builder
- Returns:
- The built object.
-
hashKey
Description copied from class:Context.Builder
Returns the hashkey of this builder.Used to return previously instantiated context beans that have matching hashkeys. The
HashKey
object is suitable for use as a hashmap key of a map of context beans. A context bean is considered equivalent if theHashKey.equals(Object)
method is the same.- Overrides:
hashKey
in classReaderParser.Builder
- Returns:
- The hashkey of this builder.
-
annotations
Description copied from class:Context.Builder
Defines annotations to apply to specific classes and methods.Allows you to dynamically apply Juneau annotations typically applied directly to classes and methods. Useful in cases where you want to use the functionality of the annotation on beans and bean properties but do not have access to the code to do so.
As a rule, any Juneau annotation with an
on() method can be used with this setting.The following example shows the equivalent methods for applying the
@Bean
annotation:// Class with explicit annotation. @Bean (properties="street,city,state" )public class A {...}// Class with annotation applied via @BeanConfig public class B {...}// Java REST method with @BeanConfig annotation. @RestGet (...)@Bean (on="B" , properties="street,city,state" )public void doFoo() {...}In general, the underlying framework uses this method when it finds dynamically applied annotations on config annotations. However, concrete implementations of annotations are also provided that can be passed directly into builder classes like so:
// Create a concrete @Bean annotation. Bean annotation = BeanAnnotation.create (B.class ).properties("street,city,state" ).build();// Apply it to a serializer. WriterSerializerserializer = JsonSerializer.create ().annotations(annotation ).build();// Serialize a bean with the dynamically applied annotation. Stringjson =serializer .serialize(new B());The following is the list of annotations builders provided that can be constructed and passed into the builder class:
BeanAnnotation
BeancAnnotation
BeanIgnoreAnnotation
BeanpAnnotation
ExampleAnnotation
NamePropertyAnnotation
ParentPropertyAnnotation
SwapAnnotation
UriAnnotation
CsvAnnotation
HtmlAnnotation
JsonAnnotation
SchemaAnnotation
MsgPackAnnotation
OpenApiAnnotation
PlainTextAnnotation
SoapXmlAnnotation
UonAnnotation
UrlEncodingAnnotation
XmlAnnotation
The syntax for the
on() pattern match parameter depends on whether it applies to a class, method, field, or constructor. The valid pattern matches are:- Classes:
- Fully qualified:
"com.foo.MyClass"
- Fully qualified inner class:
"com.foo.MyClass$Inner1$Inner2"
- Simple:
"MyClass"
- Simple inner:
"MyClass$Inner1$Inner2" "Inner1$Inner2" "Inner2"
- Fully qualified:
- Methods:
- Fully qualified with args:
"com.foo.MyClass.myMethod(String,int)" "com.foo.MyClass.myMethod(java.lang.String,int)" "com.foo.MyClass.myMethod()"
- Fully qualified:
"com.foo.MyClass.myMethod"
- Simple with args:
"MyClass.myMethod(String,int)" "MyClass.myMethod(java.lang.String,int)" "MyClass.myMethod()"
- Simple:
"MyClass.myMethod"
- Simple inner class:
"MyClass$Inner1$Inner2.myMethod" "Inner1$Inner2.myMethod" "Inner2.myMethod"
- Fully qualified with args:
- Fields:
- Fully qualified:
"com.foo.MyClass.myField"
- Simple:
"MyClass.myField"
- Simple inner class:
"MyClass$Inner1$Inner2.myField" "Inner1$Inner2.myField" "Inner2.myField"
- Fully qualified:
- Constructors:
- Fully qualified with args:
"com.foo.MyClass(String,int)" "com.foo.MyClass(java.lang.String,int)" "com.foo.MyClass()"
- Simple with args:
"MyClass(String,int)" "MyClass(java.lang.String,int)" "MyClass()"
- Simple inner class:
"MyClass$Inner1$Inner2()" "Inner1$Inner2()" "Inner2()"
- Fully qualified with args:
- A comma-delimited list of anything on this list.
See Also:
- Overrides:
annotations
in classReaderParser.Builder
- Parameters:
values
- The annotations to register with the context.- Returns:
- This object.
-
apply
Description copied from class:Context.Builder
Applies a set of applied to this builder.An
AnnotationWork
consists of a single pair ofAnnotationInfo
that represents an annotation instance, andAnnotationApplier
which represents the code used to apply the values in that annotation to a specific builder.Example:
// A class annotated with a config annotation. @BeanConfig (sortProperties="$S{sortProperties,false}" )public class MyClass {...}// Find all annotations that themselves are annotated with @ContextPropertiesApply. AnnotationListannotations = ClassInfo.of (MyClass.class ).getAnnotationList(CONTEXT_APPLY_FILTER ); VarResolverSessionvrs = VarResolver.DEFAULT .createSession(); AnnotationWorkListwork = AnnotationWorkList.of(vrs ,annotations );// Apply any settings found on the annotations. WriterSerializerserializer = JsonSerializer .create () .apply(work ) .build();- Overrides:
apply
in classReaderParser.Builder
- Parameters:
work
- The list of annotations and appliers to apply to this builder.- Returns:
- This object.
-
applyAnnotations
Description copied from class:Context.Builder
Applies any of the various@XConfig annotations on the specified class to this context.Any annotations found that themselves are annotated with
ContextApply
will be resolved and applied as properties to this builder. These annotations include:BeanConfig
CsvConfig
HtmlConfig
HtmlDocConfig
JsonConfig
JsonSchemaConfig
MsgPackConfig
OpenApiConfig
ParserConfig
PlainTextConfig
SerializerConfig
SoapXmlConfig
UonConfig
UrlEncodingConfig
XmlConfig
RdfConfig
Annotations on classes are appended in the following order:
- On the package of this class.
- On interfaces ordered parent-to-child.
- On parent classes ordered parent-to-child.
- On this class.
The default var resolver
VarResolver.DEFAULT
is used to resolve any variables in annotation field values.Example:
// A class annotated with a config annotation. @BeanConfig (sortProperties="$S{sortProperties,false}" )public class MyClass {...}// Apply any settings found on the annotations. WriterSerializerserializer = JsonSerializer .create () .applyAnnotations(MyClass.class ) .build();- Overrides:
applyAnnotations
in classReaderParser.Builder
- Parameters:
fromClasses
- The classes on which the annotations are defined.- Returns:
- This object.
-
applyAnnotations
Description copied from class:Context.Builder
Applies any of the various@XConfig annotations on the specified method to this context.Any annotations found that themselves are annotated with
ContextApply
will be resolved and applied as properties to this builder. These annotations include:BeanConfig
CsvConfig
HtmlConfig
HtmlDocConfig
JsonConfig
JsonSchemaConfig
MsgPackConfig
OpenApiConfig
ParserConfig
PlainTextConfig
SerializerConfig
SoapXmlConfig
UonConfig
UrlEncodingConfig
XmlConfig
RdfConfig
Annotations on methods are appended in the following order:
- On the package of the method class.
- On interfaces ordered parent-to-child.
- On parent classes ordered parent-to-child.
- On the method class.
- On this method and matching methods ordered parent-to-child.
The default var resolver
VarResolver.DEFAULT
is used to resolve any variables in annotation field values.Example:
// A method annotated with a config annotation. public class MyClass {@BeanConfig (sortProperties="$S{sortProperties,false}" )public void myMethod() {...} }// Apply any settings found on the annotations. WriterSerializerserializer = JsonSerializer .create () .applyAnnotations(MyClass.class .getMethod("myMethod" )) .build();- Overrides:
applyAnnotations
in classReaderParser.Builder
- Parameters:
fromMethods
- The methods on which the annotations are defined.- Returns:
- This object.
-
cache
Description copied from class:Context.Builder
Specifies a cache to use for hashkey-based caching.- Overrides:
cache
in classReaderParser.Builder
- Parameters:
value
- The cache.- Returns:
- This object.
-
debug
Description copied from class:Context.Builder
Context configuration property: Debug mode.Enables the following additional information during serialization:
- When bean getters throws exceptions, the exception includes the object stack information in order to determine how that method was invoked.
-
Enables
BeanTraverseContext.Builder.detectRecursions()
.
Enables the following additional information during parsing:
- When bean setters throws exceptions, the exception includes the object stack information in order to determine how that method was invoked.
Example:
// Create a serializer with debug enabled. WriterSerializerserializer = JsonSerializer .create () .debug() .build();// Create a POJO model with a recursive loop. public class MyBean {public Objectf ; } MyBeanbean =new MyBean();bean .f =bean ;// Throws a SerializeException and not a StackOverflowError Stringjson =serializer .serialize(bean );See Also:
- Overrides:
debug
in classReaderParser.Builder
- Returns:
- This object.
-
debug
Description copied from class:Context.Builder
Same asContext.Builder.debug()
but allows you to explicitly specify the value.- Overrides:
debug
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
impl
Description copied from class:Context.Builder
Specifies a pre-instantiated bean for theContext.Builder.build()
method to return.- Overrides:
impl
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
type
Description copied from class:Context.Builder
Associates a context class with this builder.This is the type of object that this builder creates when the
Context.Builder.build()
method is called.By default, it's the outer class of where the builder class is defined.
- Overrides:
type
in classReaderParser.Builder
- Parameters:
value
- The context class that this builder should create.- Returns:
- This object.
-
beanClassVisibility
Description copied from class:BeanContextable.Builder
Minimum bean class visibility.Classes are not considered beans unless they meet the minimum visibility requirements. For example, if the visibility is
PUBLIC and the bean class isprotected , then the class will not be interpreted as a bean class and be serialized as a string. Use this setting to reduce the visibility requirement.Example:
// A bean with a protected class and one field. protected class MyBean {public Stringfoo ="bar" ; }// Create a serializer that's capable of serializing the class. WriterSerializerserializer = JsonSerializer .create () .beanClassVisibility(PROTECTED ) .build();// Produces: {"foo","bar"} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Bean
annotation can be used on a non-public bean class to override this setting. - The
@BeanIgnore
annotation can also be used on a public bean class to ignore it as a bean.
See Also:
- Overrides:
beanClassVisibility
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.
The default isVisibility.PUBLIC
.- Returns:
- This object.
- The
-
beanConstructorVisibility
Description copied from class:BeanContextable.Builder
Minimum bean constructor visibility.Only look for constructors with the specified minimum visibility.
This setting affects the logic for finding no-arg constructors for bean. Normally, only
public no-arg constructors are used. Use this setting if you want to reduce the visibility requirement.Example:
// A bean with a protected constructor and one field. public class MyBean {public Stringfoo ;protected MyBean() {} }// Create a parser capable of calling the protected constructor. ReaderParserparser = ReaderParser .create () .beanConstructorVisibility(PROTECTED ) .build();// Use it. MyBeanbean =parser .parse("{foo:'bar'}" , MyBean.class );Notes:
- The
@Beanc
annotation can also be used to expose a non-public constructor. - The
@BeanIgnore
annotation can also be used on a public bean constructor to ignore it.
See Also:
- Overrides:
beanConstructorVisibility
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.
The default isVisibility.PUBLIC
.- Returns:
- This object.
- The
-
beanContext
Description copied from class:BeanContextable.Builder
Specifies an already-instantiated bean context to use.Provides an optimization for cases where serializers and parsers can use an existing bean context without having to go through
. An example isbeanContext .copy().build()BeanContext.getBeanToStringSerializer()
.- Overrides:
beanContext
in classReaderParser.Builder
- Parameters:
value
- The bean context to use.- Returns:
- This object.
-
beanContext
Description copied from class:BeanContextable.Builder
Overrides the bean context builder.Used when sharing bean context builders across multiple context objects. For example,
JsonSchemaGenerator.Builder
uses this to apply common bean settings with the JSON serializer and parser.- Overrides:
beanContext
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.- Returns:
- This object.
-
beanDictionary
Description copied from class:BeanContextable.Builder
Bean dictionary.The list of classes that make up the bean dictionary in this bean context.
Values are prepended to the list so that later calls can override classes of earlier calls.
A dictionary is a name/class mapping used to find class types during parsing when they cannot be inferred through reflection. The names are defined through the
@Bean(typeName)
annotation defined on the bean class. For example, if a classFoo has a type-name of"myfoo" , then it would end up serialized as"{_type:'myfoo',...}" in JSON or"<myfoo>...</myfoo>" in XML.This setting tells the parsers which classes to look for when resolving
"_type" attributes.Values can consist of any of the following types:
- Any bean class that specifies a value for
@Bean(typeName)
. - Any subclass of
BeanDictionaryList
containing a collection of bean classes with type name annotations. - Any subclass of
BeanDictionaryMap
containing a mapping of type names to classes without type name annotations. - Any array or collection of the objects above.
Example:
// POJOs with @Bean(name) annotations. @Bean (typeName="foo" )public class Foo {...}@Bean (typeName="bar" )public class Bar {...}// Create a parser and tell it which classes to try to resolve. ReaderParserparser = JsonParser .create () .dictionary(Foo.class , Bar.class ) .addBeanTypes() .build();// A bean with a field with an indeterminate type. public class MyBean {public ObjectmySimpleField ; }// Parse bean. MyBeanbean =parser .parse("{mySimpleField:{_type:'foo',...}}" , MyBean.class );Another option is to use the
Bean.dictionary()
annotation on the POJO class itself:// Instead of by parser, define a bean dictionary on a class through an annotation. // This applies to all properties on this class and all subclasses. @Bean (dictionary={Foo.class ,Bar.class })public class MyBean {public ObjectmySimpleField ;// May contain Foo or Bar object. public Map<String,Object>myMapField ;// May contain Foo or Bar objects. }A typical usage is to allow for HTML documents to be parsed back into HTML beans:
// Use the predefined HTML5 bean dictionary which is a BeanDictionaryList. ReaderParserparser = HtmlParser .create () .dictionary(HtmlBeanDictionary.class ) .build();// Parse an HTML body into HTML beans. Bodybody =parser .parse("<body><ul><li>foo</li><li>bar</li></ul>" , Body.class );See Also:
- Overrides:
beanDictionary
in classReaderParser.Builder
- Parameters:
values
- The values to add to this setting.- Returns:
- This object.
- Any bean class that specifies a value for
-
beanFieldVisibility
Description copied from class:BeanContextable.Builder
Minimum bean field visibility.Only look for bean fields with the specified minimum visibility.
This affects which fields on a bean class are considered bean properties. Normally only
public fields are considered. Use this setting if you want to reduce the visibility requirement.Example:
// A bean with a protected field. public class MyBean {protected Stringfoo ="bar" ; }// Create a serializer that recognizes the protected field. WriterSerializerserializer = JsonSerializer .create () .beanFieldVisibility(PROTECTED ) .build();// Produces: {"foo":"bar"} Stringjson =serializer .serialize(new MyBean());Bean fields can be ignored as properties entirely by setting the value to
Visibility.NONE
// Disable using fields as properties entirely. WriterSerializerserializer = JsonSerializer .create () .beanFieldVisibility(NONE ) .build();Notes:
- The
@Beanp
annotation can also be used to expose a non-public field. - The
@BeanIgnore
annotation can also be used on a public bean field to ignore it as a bean property.
See Also:
- Overrides:
beanFieldVisibility
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.
The default isVisibility.PUBLIC
.- Returns:
- This object.
- The
-
beanInterceptor
public PlainTextParser.Builder beanInterceptor(Class<?> on, Class<? extends BeanInterceptor<?>> value) Description copied from class:BeanContextable.Builder
Bean interceptor.Bean interceptors can be used to intercept calls to getters and setters and alter their values in transit.
Example:
// Interceptor that strips out sensitive information. public class AddressInterceptorextends BeanInterceptor<Address> {public Object readProperty(Addressbean , Stringname , Objectvalue ) {if ("taxInfo" .equals(name ))return "redacted" ;return value ; }public Object writeProperty(Addressbean , Stringname , Objectvalue ) {if ("taxInfo" .equals(name ) &&"redacted" .equals(value ))return TaxInfoUtils.lookup (bean .getStreet(),bean .getCity(),bean .getState());return value ; } }// Our bean class. public class Address {public String getTaxInfo() {...}public void setTaxInfo(Stringvalue ) {...} }// Register filter on serializer or parser. WriterSerializerserializer = JsonSerializer .create () .beanInterceptor(Address.class , AddressInterceptor.class ) .build();// Produces: {"taxInfo":"redacted"} Stringjson =serializer .serialize(new Address());See Also:
- Overrides:
beanInterceptor
in classReaderParser.Builder
- Parameters:
on
- The bean that the filter applies to.value
- The new value for this setting.- Returns:
- This object.
-
beanMapPutReturnsOldValue
Description copied from class:BeanContextable.Builder
BeanMap.put() returns old property value.When enabled, then the
BeanMap.put()
method will return old property values. Otherwise, it returnsnull .Disabled by default because it introduces a slight performance penalty during serialization.
Example:
// Create a context that creates BeanMaps with normal put() behavior. BeanContextcontext = BeanContext .create () .beanMapPutReturnsOldValue() .build(); BeanMap<MyBean>beanMap =context .createSession().toBeanMap(new MyBean());beanMap .put("foo" ,"bar" ); ObjectoldValue =beanMap .put("foo" ,"baz" );// oldValue == "bar" See Also:
- Overrides:
beanMapPutReturnsOldValue
in classReaderParser.Builder
- Returns:
- This object.
-
beanMethodVisibility
Description copied from class:BeanContextable.Builder
Minimum bean method visibility.Only look for bean methods with the specified minimum visibility.
This affects which methods are detected as getters and setters on a bean class. Normally only
public getters and setters are considered. Use this setting if you want to reduce the visibility requirement.Example:
// A bean with a protected getter. public class MyBean {public String getFoo() {return "foo" ; }protected String getBar() {return "bar" ; } }// Create a serializer that looks for protected getters and setters. WriterSerializerserializer = JsonSerializer .create () .beanMethodVisibility(PROTECTED ) .build();// Produces: {"foo":"foo","bar":"bar"} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Beanp
annotation can also be used to expose a non-public method. - The
@BeanIgnore
annotation can also be used on a public bean getter/setter to ignore it as a bean property.
See Also:
- Overrides:
beanMethodVisibility
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.
The default isVisibility.PUBLIC
- Returns:
- This object.
- The
-
beanProperties
Description copied from class:BeanContextable.Builder
Bean property includes.Specifies the set and order of names of properties associated with bean classes.
For example,
beanProperties(AMap. means only serialize theof ("MyBean" ,"foo,bar" ))foo andbar properties on the specified bean. Likewise, parsing will ignore any bean properties not specified and either throw an exception or silently ignore them depending on whetherBeanContextable.Builder.ignoreUnknownBeanProperties()
has been called.This value is entirely optional if you simply want to expose all the getters and public fields on a class as bean properties. However, it's useful if you want certain getters to be ignored or you want the properties to be serialized in a particular order. Note that on IBM JREs, the property order is the same as the order in the source code, whereas on Oracle JREs, the order is entirely random.
Setting applies to specified class and all subclasses.
Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ="foo" ,bar ="bar" ,baz ="baz" ; }// Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .beanProperties(AMap.of ("MyBean" ,"foo,bar" )) .build();// Produces: {"foo":"foo","bar":"bar"} Stringjson =serializer .serialize(new MyBean());This method is functionally equivalent to the following code for each entry:
builder .annotations(BeanAnnotation.create (key ).properties(value .toString()).build());See Also:
Bean.properties()
/Bean.p()
- On an annotation on the bean class itself.
- Overrides:
beanProperties
in classReaderParser.Builder
- Parameters:
values
- The values to add to this builder.
Keys are bean class names which can be a simple name, fully-qualified name, or"*" for all beans.
Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.- Returns:
- This object.
-
beanProperties
Description copied from class:BeanContextable.Builder
Bean property includes.Specifies the set and order of names of properties associated with the bean class.
For example,
beanProperties(MyBean. means only serialize theclass ,"foo,bar" )foo andbar properties on the specified bean. Likewise, parsing will ignore any bean properties not specified and either throw an exception or silently ignore them depending on whetherBeanContextable.Builder.ignoreUnknownBeanProperties()
has been called.This value is entirely optional if you simply want to expose all the getters and public fields on a class as bean properties. However, it's useful if you want certain getters to be ignored or you want the properties to be serialized in a particular order. Note that on IBM JREs, the property order is the same as the order in the source code, whereas on Oracle JREs, the order is entirely random.
Setting applies to specified class and all subclasses.
Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ="foo" ,bar ="bar" ,baz ="baz" ; }// Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .beanProperties(MyBean.class ,"foo,bar" ) .build();// Produces: {"foo":"foo","bar":"bar"} Stringjson =serializer .serialize(new MyBean());This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClass ).properties(properties ).build());See Also:
Bean.properties()
/Bean.p()
- On an annotation on the bean class itself.
- Overrides:
beanProperties
in classReaderParser.Builder
- Parameters:
beanClass
- The bean class.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanProperties
Description copied from class:BeanContextable.Builder
Bean property includes.Specifies the set and order of names of properties associated with the bean class.
For example,
beanProperties( means only serialize the"MyBean" ,"foo,bar" )foo andbar properties on the specified bean. Likewise, parsing will ignore any bean properties not specified and either throw an exception or silently ignore them depending on whetherBeanContextable.Builder.ignoreUnknownBeanProperties()
has been called.This value is entirely optional if you simply want to expose all the getters and public fields on a class as bean properties. However, it's useful if you want certain getters to be ignored or you want the properties to be serialized in a particular order. Note that on IBM JREs, the property order is the same as the order in the source code, whereas on Oracle JREs, the order is entirely random.
Setting applies to specified class and all subclasses.
Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ="foo" ,bar ="bar" ,baz ="baz" ; }// Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .beanProperties("MyBean" ,"foo,bar" ) .build();// Produces: {"foo":"foo","bar":"bar"} Stringjson =serializer .serialize(new MyBean());This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClassName ).properties(properties ).build());See Also:
Bean.properties()
/Bean.p()
- On an annotation on the bean class itself.
- Overrides:
beanProperties
in classReaderParser.Builder
- Parameters:
beanClassName
- The bean class name.
Can be a simple name, fully-qualified name, or"*" for all beans.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanPropertiesExcludes
Description copied from class:BeanContextable.Builder
Bean property excludes.Specifies to exclude the specified list of properties for the specified bean classes.
Same as
BeanContextable.Builder.beanProperties(Map)
except you specify a list of bean property names that you want to exclude from serialization.Setting applies to specified class and all subclasses.
Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ="foo" ,bar ="bar" ,baz ="baz" ; }// Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesExcludes(AMap.of("MyBean" ,"bar,baz" )) .build();// Produces: {"foo":"foo"} Stringjson =serializer .serialize(new MyBean());This method is functionally equivalent to the following code for each entry:
builder .annotations(BeanAnnotation.create (key ).excludeProperties(value .toString()).build());See Also:
- Overrides:
beanPropertiesExcludes
in classReaderParser.Builder
- Parameters:
values
- The values to add to this builder.
Keys are bean class names which can be a simple name, fully-qualified name, or"*" for all beans.
Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.- Returns:
- This object.
-
beanPropertiesExcludes
Description copied from class:BeanContextable.Builder
Bean property excludes.Specifies to exclude the specified list of properties for the specified bean class.
Same as
BeanContextable.Builder.beanProperties(Class, String)
except you specify a list of bean property names that you want to exclude from serialization.Setting applies to specified class and all subclasses.
Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ="foo" ,bar ="bar" ,baz ="baz" ; }// Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesExcludes(MyBean.class ,"bar,baz" ) .build();// Produces: {"foo":"foo"} Stringjson =serializer .serialize(new MyBean());This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClass ).excludeProperties(properties ).build());See Also:
- Overrides:
beanPropertiesExcludes
in classReaderParser.Builder
- Parameters:
beanClass
- The bean class.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanPropertiesExcludes
Description copied from class:BeanContextable.Builder
Bean property excludes.Specifies to exclude the specified list of properties for the specified bean class.
Same as
BeanContextable.Builder.beanPropertiesExcludes(String, String)
except you specify a list of bean property names that you want to exclude from serialization.Setting applies to specified class and all subclasses.
Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ="foo" ,bar ="bar" ,baz ="baz" ; }// Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesExcludes("MyBean" ,"bar,baz" ) .build();// Produces: {"foo":"foo"} Stringjson =serializer .serialize(new MyBean());This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClassName ).excludeProperties(properties ).build());See Also:
- Overrides:
beanPropertiesExcludes
in classReaderParser.Builder
- Parameters:
beanClassName
- The bean class name.
Can be a simple name, fully-qualified name, or"*" for all bean classes.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanPropertiesReadOnly
Description copied from class:BeanContextable.Builder
Read-only bean properties.Specifies one or more properties on beans that are read-only despite having valid getters. Serializers will serialize such properties as usual, but parsers will silently ignore them. Note that this is different from the
beanProperties
/beanPropertiesExcludes
settings which include or exclude properties for both serializers and parsers.Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ,bar ,baz ; }// Create a serializer with read-only property settings. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesReadOnly(AMap.of ("MyBean" ,"bar,baz" )) .build();// All 3 properties will be serialized. Stringjson =serializer .serialize(new MyBean());// Create a parser with read-only property settings. ReaderParserparser = JsonParser .create () .beanPropertiesReadOnly(AMap.of ("MyBean" ,"bar,baz" )) .ignoreUnknownBeanProperties() .build();// Parser ignores bar and baz properties. MyBeanbean =parser .parse("{foo:'foo',bar:'bar',baz:'baz'}" , MyBean.class );This method is functionally equivalent to the following code for each entry:
builder .annotations(BeanAnnotation.create (key ).readOnlyProperties(value .toString()).build());See Also:
- Overrides:
beanPropertiesReadOnly
in classReaderParser.Builder
- Parameters:
values
- The values to add to this builder.
Keys are bean class names which can be a simple name, fully-qualified name, or"*" for all beans.
Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.- Returns:
- This object.
-
beanPropertiesReadOnly
Description copied from class:BeanContextable.Builder
Read-only bean properties.Specifies one or more properties on a bean that are read-only despite having valid getters. Serializers will serialize such properties as usual, but parsers will silently ignore them. Note that this is different from the
beanProperties
/beanPropertiesExcludes
settings which include or exclude properties for both serializers and parsers.Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ,bar ,baz ; }// Create a serializer with read-only property settings. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesReadOnly(MyBean.class ,"bar,baz" ) .build();// All 3 properties will be serialized. Stringjson =serializer .serialize(new MyBean());// Create a parser with read-only property settings. ReaderParserparser = JsonParser .create () .beanPropertiesReadOnly(MyBean.class ,"bar,baz" ) .ignoreUnknownBeanProperties() .build();// Parser ignores bar and baz properties. MyBeanbean =parser .parse("{foo:'foo',bar:'bar',baz:'baz'}" , MyBean.class );This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClass ).readOnlyProperties(properties ).build());See Also:
- Overrides:
beanPropertiesReadOnly
in classReaderParser.Builder
- Parameters:
beanClass
- The bean class.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanPropertiesReadOnly
Description copied from class:BeanContextable.Builder
Read-only bean properties.Specifies one or more properties on a bean that are read-only despite having valid getters. Serializers will serialize such properties as usual, but parsers will silently ignore them. Note that this is different from the
beanProperties
/beanPropertiesExcludes
settings which include or exclude properties for both serializers and parsers.Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ,bar ,baz ; }// Create a serializer with read-only property settings. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesReadOnly("MyBean" ,"bar,baz" ) .build();// All 3 properties will be serialized. Stringjson =serializer .serialize(new MyBean());// Create a parser with read-only property settings. ReaderParserparser = JsonParser .create () .beanPropertiesReadOnly("MyBean" ,"bar,baz" ) .ignoreUnknownBeanProperties() .build();// Parser ignores bar and baz properties. MyBeanbean =parser .parse("{foo:'foo',bar:'bar',baz:'baz'}" , MyBean.class );This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClassName ).readOnlyProperties(properties ).build());See Also:
- Overrides:
beanPropertiesReadOnly
in classReaderParser.Builder
- Parameters:
beanClassName
- The bean class name.
Can be a simple name, fully-qualified name, or"*" for all bean classes.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanPropertiesWriteOnly
Description copied from class:BeanContextable.Builder
Write-only bean properties.Specifies one or more properties on a bean that are write-only despite having valid setters. Parsers will parse such properties as usual, but serializers will silently ignore them. Note that this is different from the
beanProperties
/beanPropertiesExcludes
settings which include or exclude properties for both serializers and parsers.Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ,bar ,baz ; }// Create a serializer with write-only property settings. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesWriteOnly(AMap.of ("MyBean" ,"bar,baz" )) .build();// Only foo will be serialized. Stringjson =serializer .serialize(new MyBean());// Create a parser with write-only property settings. ReaderParserparser = JsonParser .create () .beanPropertiesWriteOnly(AMap.of ("MyBean" ,"bar,baz" )) .build();// Parser parses all 3 properties. MyBeanbean =parser .parse("{foo:'foo',bar:'bar',baz:'baz'}" , MyBean.class );This method is functionally equivalent to the following code for each entry:
builder .annotations(BeanAnnotation.create (key ).writeOnlyProperties(value .toString()).build());See Also:
- Overrides:
beanPropertiesWriteOnly
in classReaderParser.Builder
- Parameters:
values
- The values to add to this builder.
Keys are bean class names which can be a simple name, fully-qualified name, or"*" for all beans.
Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.- Returns:
- This object.
-
beanPropertiesWriteOnly
Description copied from class:BeanContextable.Builder
Write-only bean properties.Specifies one or more properties on a bean that are write-only despite having valid setters. Parsers will parse such properties as usual, but serializers will silently ignore them. Note that this is different from the
beanProperties
/beanPropertiesExcludes
settings which include or exclude properties for both serializers and parsers.Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ,bar ,baz ; }// Create a serializer with write-only property settings. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesWriteOnly(MyBean.class ,"bar,baz" ) .build();// Only foo will be serialized. Stringjson =serializer .serialize(new MyBean());// Create a parser with write-only property settings. ReaderParserparser = JsonParser .create () .beanPropertiesWriteOnly(MyBean.class ,"bar,baz" ) .build();// Parser parses all 3 properties. MyBeanbean =parser .parse("{foo:'foo',bar:'bar',baz:'baz'}" , MyBean.class );This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClass ).writeOnlyProperties(properties ).build());See Also:
- Overrides:
beanPropertiesWriteOnly
in classReaderParser.Builder
- Parameters:
beanClass
- The bean class.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beanPropertiesWriteOnly
Description copied from class:BeanContextable.Builder
Write-only bean properties.Specifies one or more properties on a bean that are write-only despite having valid setters. Parsers will parse such properties as usual, but serializers will silently ignore them. Note that this is different from the
beanProperties
/beanPropertiesExcludes
settings which include or exclude properties for both serializers and parsers.Example:
// A bean with 3 properties. public class MyBean {public Stringfoo ,bar ,baz ; }// Create a serializer with write-only property settings. WriterSerializerserializer = JsonSerializer .create () .beanPropertiesWriteOnly("MyBean" ,"bar,baz" ) .build();// Only foo will be serialized. Stringjson =serializer .serialize(new MyBean());// Create a parser with write-only property settings. ReaderParserparser = JsonParser .create () .beanPropertiesWriteOnly("MyBean" ,"bar,baz" ) .build();// Parser parses all 3 properties. MyBeanbean =parser .parse("{foo:'foo',bar:'bar',baz:'baz'}" , MyBean.class );This method is functionally equivalent to the following code:
builder .annotations(BeanAnnotation.create (beanClassName ).writeOnlyProperties(properties ).build());See Also:
- Overrides:
beanPropertiesWriteOnly
in classReaderParser.Builder
- Parameters:
beanClassName
- The bean class name.
Can be a simple name, fully-qualified name, or"*" for all bean classes.properties
- Comma-delimited list of property names.- Returns:
- This object.
-
beansRequireDefaultConstructor
Description copied from class:BeanContextable.Builder
Beans require no-arg constructors.When enabled, a Java class must implement a default no-arg constructor to be considered a bean. Otherwise, the bean will be serialized as a string using the
Object.toString()
method.Example:
// A bean without a no-arg constructor. public class MyBean {// A property method. public Stringfoo ="bar" ;// A no-arg constructor public MyBean(Stringfoo ) {this .foo =foo ; }@Override public String toString() {return "bar" ; } }// Create a serializer that ignores beans without default constructors. WriterSerializerserializer = JsonSerializer .create () .beansRequireDefaultConstructor() .build();// Produces: "bar" Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Bean
annotation can be used on a bean class to override this setting. - The
@BeanIgnore
annotation can also be used on a class to ignore it as a bean.
See Also:
- Overrides:
beansRequireDefaultConstructor
in classReaderParser.Builder
- Returns:
- This object.
- The
-
beansRequireSerializable
Description copied from class:BeanContextable.Builder
Beans require Serializable interface.When enabled, a Java class must implement the
Serializable
interface to be considered a bean. Otherwise, the bean will be serialized as a string using theObject.toString()
method.Example:
// A bean without a Serializable interface. public class MyBean {// A property method. public Stringfoo ="bar" ;@Override public String toString() {return "bar" ; } }// Create a serializer that ignores beans not implementing Serializable. WriterSerializerserializer = JsonSerializer .create () .beansRequireSerializable() .build();// Produces: "bar" Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Bean
annotation can be used on a bean class to override this setting. - The
@BeanIgnore
annotation can also be used on a class to ignore it as a bean.
See Also:
- Overrides:
beansRequireSerializable
in classReaderParser.Builder
- Returns:
- This object.
- The
-
beansRequireSettersForGetters
Description copied from class:BeanContextable.Builder
Beans require setters for getters.When enabled, ignore read-only properties (properties with getters but not setters).
Example:
// A bean without a Serializable interface. public class MyBean {// A read/write property. public String getFoo() {return "foo" ; }public void setFoo(Stringfoo ) { ... }// A read-only property. public String getBar() {return "bar" ; } }// Create a serializer that ignores bean properties without setters. WriterSerializerserializer = JsonSerializer .create () .beansRequireSettersForGetters() .build();// Produces: {"foo":"foo"} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Beanp
annotation can be used on the getter to override this setting. - The
@BeanIgnore
annotation can also be used on getters to ignore them as bean properties.
See Also:
- Overrides:
beansRequireSettersForGetters
in classReaderParser.Builder
- Returns:
- This object.
- The
-
dictionaryOn
Description copied from class:BeanContextable.Builder
Bean dictionary.This is identical to
BeanContextable.Builder.beanDictionary(Class...)
, but specifies a dictionary within the context of a single class as opposed to globally.Example:
// POJOs with @Bean(name) annotations. @Bean (typeName="foo" )public class Foo {...}@Bean (typeName="bar" )public class Bar {...}// A bean with a field with an indeterminate type. public class MyBean {public ObjectmySimpleField ; }// Create a parser and tell it which classes to try to resolve. ReaderParserparser = JsonParser .create () .dictionaryOn(MyBean.class , Foo.class , Bar.class ) .build();// Parse bean. MyBeanbean =parser .parse("{mySimpleField:{_type:'foo',...}}" , MyBean.class );This is functionally equivalent to the
Bean.dictionary()
annotation.See Also:
- Overrides:
dictionaryOn
in classReaderParser.Builder
- Parameters:
on
- The class that the dictionary values apply to.values
- The new values for this setting.- Returns:
- This object.
-
disableBeansRequireSomeProperties
Description copied from class:BeanContextable.Builder
Beans don't require at least one property.When enabled, then a Java class doesn't need to contain at least 1 property to be considered a bean. Otherwise, the bean will be serialized as a string using the
Object.toString()
method.The
@Bean
annotation can be used on a class to override this setting whentrue .Example:
// A bean with no properties. public class MyBean { }// Create a serializer that serializes beans even if they have zero properties. WriterSerializerserializer = JsonSerializer .create () .disableBeansRequireSomeProperties() .build();// Produces: {} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Bean
annotation can be used on the class to force it to be recognized as a bean class even if it has no properties.
See Also:
- Overrides:
disableBeansRequireSomeProperties
in classReaderParser.Builder
- Returns:
- This object.
- The
-
disableIgnoreMissingSetters
Description copied from class:BeanContextable.Builder
Don't silently ignore missing setters.When enabled, trying to set a value on a bean property without a setter will throw a
BeanRuntimeException
. Otherwise, it will be silently ignored.Example:
// A bean with a property with a getter but not a setter. public class MyBean {public void getFoo() {return "foo" ; } }// Create a parser that throws an exception if a setter is not found but a getter is. ReaderParserparser = JsonParser .create () .disableIgnoreMissingSetters() .build();// Throws a ParseException. MyBeanbean =parser .parse("{foo:'bar'}" , MyBean.class );Notes:
- The
@BeanIgnore
annotation can also be used on getters and fields to ignore them.
See Also:
- Overrides:
disableIgnoreMissingSetters
in classReaderParser.Builder
- Returns:
- This object.
- The
-
disableIgnoreTransientFields
Description copied from class:BeanContextable.Builder
Don't ignore transient fields.When enabled, methods and fields marked as
transient will not be ignored as bean properties.Example:
// A bean with a transient field. public class MyBean {public transient Stringfoo ="foo" ; }// Create a serializer that doesn't ignore transient fields. WriterSerializerserializer = JsonSerializer .create () .disableIgnoreTransientFields() .build();// Produces: {"foo":"foo"} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Beanp
annotation can also be used on transient fields to keep them from being ignored.
See Also:
- Overrides:
disableIgnoreTransientFields
in classReaderParser.Builder
- Returns:
- This object.
- The
-
disableIgnoreUnknownNullBeanProperties
Description copied from class:BeanContextable.Builder
Don't ignore unknown properties with null values.When enabled, trying to set a
null value on a non-existent bean property will throw aBeanRuntimeException
. Otherwise it will be silently ignored.Example:
// A bean with a single property. public class MyBean {public Stringfoo ; }// Create a parser that throws an exception on an unknown property even if the value being set is null. ReaderParserparser = JsonParser .create () .disableIgnoreUnknownNullBeanProperties() .build();// Throws a BeanRuntimeException wrapped in a ParseException on the unknown 'bar' property. MyBeanbean =parser .parse("{foo:'foo',bar:null}" , MyBean.class );See Also:
- Overrides:
disableIgnoreUnknownNullBeanProperties
in classReaderParser.Builder
- Returns:
- This object.
-
disableInterfaceProxies
Description copied from class:BeanContextable.Builder
Don't use interface proxies.When enabled, interfaces will be instantiated as proxy classes through the use of an
InvocationHandler
if there is no other way of instantiating them. Otherwise, throws aBeanRuntimeException
.See Also:
- Overrides:
disableInterfaceProxies
in classReaderParser.Builder
- Returns:
- This object.
-
example
Description copied from class:BeanContextable.Builder
POJO example.Specifies an example of the specified class.
Examples are used in cases such as POJO examples in Swagger documents.
Example:
// Create a serializer that excludes the 'foo' and 'bar' properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .example(MyBean.class ,new MyBean().setFoo("foo" ).setBar(123)) .build();This is a shorthand method for the following code:
builder .annotations(MarshalledAnnotation.create (pojoClass ).example(Json5.DEFAULT .toString(object )).build())Notes:
- Using this method assumes the serialized form of the object is the same as that produced by the default serializer. This may not be true based on settings or swaps on the constructed serializer.
POJO examples can also be defined on classes via the following:
- The
Marshalled.example()
annotation on the class itself. - A static field annotated with
@Example
. - A static method annotated with
@Example
with zero arguments or oneBeanSession
argument. - A static method with name
example with no arguments or oneBeanSession
argument.
- Overrides:
example
in classReaderParser.Builder
- Type Parameters:
T
- The POJO class.- Parameters:
pojoClass
- The POJO class.o
- An instance of the POJO class used for examples.- Returns:
- This object.
-
example
Description copied from class:BeanContextable.Builder
POJO example.Specifies an example in JSON of the specified class.
Examples are used in cases such as POJO examples in Swagger documents.
Setting applies to specified class and all subclasses.
Example:
// Create a serializer that excludes the 'foo' and 'bar' properties on the MyBean class. WriterSerializerserializer = JsonSerializer .create () .example(MyBean.class ,"{foo:'bar'}" ) .build();This is a shorthand method for the following code:
builder .annotations(MarshalledAnnotation.create (pojoClass ).example(json ).build())POJO examples can also be defined on classes via the following:
- A static field annotated with
@Example
. - A static method annotated with
@Example
with zero arguments or oneBeanSession
argument. - A static method with name
example with no arguments or oneBeanSession
argument.
See Also:
- Overrides:
example
in classReaderParser.Builder
- Type Parameters:
T
- The POJO class type.- Parameters:
pojoClass
- The POJO class.json
- The JSON 5 representation of the example.- Returns:
- This object.
- A static field annotated with
-
findFluentSetters
Description copied from class:BeanContextable.Builder
Find fluent setters.When enabled, fluent setters are detected on beans during parsing.
Fluent setters must have the following attributes:
- Public.
- Not static.
- Take in one parameter.
- Return the bean itself.
Example:
// A bean with a fluent setter. public class MyBean {public MyBean foo(Stringvalue ) {...} }// Create a parser that finds fluent setters. ReaderParserparser = JsonParser .create () .findFluentSetters() .build();// Parse into bean using fluent setter. MyBeanbean =parser .parse("{foo:'bar'}" , MyBean.class );Notes:
- The
@Beanp
annotation can also be used on methods to individually identify them as fluent setters. - The
@Bean.fluentSetters()
annotation can also be used on classes to specify to look for fluent setters.
See Also:
- Overrides:
findFluentSetters
in classReaderParser.Builder
- Returns:
- This object.
-
findFluentSetters
Description copied from class:BeanContextable.Builder
Find fluent setters.Identical to
BeanContextable.Builder.findFluentSetters()
but enables it on a specific class only.Example:
// A bean with a fluent setter. public class MyBean {public MyBean foo(Stringvalue ) {...} }// Create a parser that finds fluent setters. ReaderParserparser = JsonParser .create () .findFluentSetters(MyBean.class ) .build();// Parse into bean using fluent setter. MyBeanbean =parser .parse("{foo:'bar'}" , MyBean.class );Notes:
- This method is functionally equivalent to using the
Bean.findFluentSetters()
annotation.
See Also:
- Overrides:
findFluentSetters
in classReaderParser.Builder
- Parameters:
on
- The class that this applies to.- Returns:
- This object.
- This method is functionally equivalent to using the
-
ignoreInvocationExceptionsOnGetters
Description copied from class:BeanContextable.Builder
Ignore invocation errors on getters.When enabled, errors thrown when calling bean getter methods will silently be ignored. Otherwise, a
BeanRuntimeException
is thrown.Example:
// A bean with a property that throws an exception. public class MyBean {public String getFoo() {throw new RuntimeException("foo" ); } }// Create a serializer that ignores bean getter exceptions. WriterSerializerserializer = JsonSerializer .create () .ingoreInvocationExceptionsOnGetters() .build();// Exception is ignored. Stringjson =serializer .serialize(new MyBean());See Also:
- Overrides:
ignoreInvocationExceptionsOnGetters
in classReaderParser.Builder
- Returns:
- This object.
-
ignoreInvocationExceptionsOnSetters
Description copied from class:BeanContextable.Builder
Ignore invocation errors on setters.When enabled, errors thrown when calling bean setter methods will silently be ignored. Otherwise, a
BeanRuntimeException
is thrown.Example:
// A bean with a property that throws an exception. public class MyBean {public void setFoo(Stringfoo ) {throw new RuntimeException("foo" ); } }// Create a parser that ignores bean setter exceptions. ReaderParserparser = JsonParser .create () .ignoreInvocationExceptionsOnSetters() .build();// Exception is ignored. MyBeanbean =parser .parse("{foo:'bar'}" , MyBean.class );See Also:
- Overrides:
ignoreInvocationExceptionsOnSetters
in classReaderParser.Builder
- Returns:
- This object.
-
ignoreUnknownBeanProperties
Description copied from class:BeanContextable.Builder
Ignore unknown properties.When enabled, trying to set a value on a non-existent bean property will silently be ignored. Otherwise, a
BeanRuntimeException
is thrown.Example:
// A bean with a single property. public class MyBean {public Stringfoo ; }// Create a parser that ignores missing bean properties. ReaderParserparser = JsonParser .create () .ignoreUnknownBeanProperties() .build();// Doesn't throw an exception on unknown 'bar' property. MyBeanbean =parser .parse("{foo:'foo',bar:'bar'}" , MyBean.class );See Also:
- Overrides:
ignoreUnknownBeanProperties
in classReaderParser.Builder
- Returns:
- This object.
-
ignoreUnknownEnumValues
Description copied from class:BeanContextable.Builder
Ignore unknown enum values.When enabled, unknown enum values are set to
null instead of throwing a parse exception.See Also:
- Overrides:
ignoreUnknownEnumValues
in classReaderParser.Builder
- Returns:
- This object.
-
implClass
Description copied from class:BeanContextable.Builder
Implementation classes.For interfaces and abstract classes this method can be used to specify an implementation class for the interface/abstract class so that instances of the implementation class are used when instantiated (e.g. during a parse).
Example:
// A bean interface. public interface MyBean { ... }// A bean implementation. public class MyBeanImplimplements MyBean { ... }// Create a parser that instantiates MyBeanImpls when parsing MyBeans. ReaderParserparser = JsonParser .create () .implClass(MyBean.class , MyBeanImpl.class ) .build();// Instantiates a MyBeanImpl, MyBeanbean =parser .parse("..." , MyBean.class );- Overrides:
implClass
in classReaderParser.Builder
- Parameters:
interfaceClass
- The interface class.implClass
- The implementation class.- Returns:
- This object.
-
implClasses
Description copied from class:BeanContextable.Builder
Implementation classes.For interfaces and abstract classes this method can be used to specify an implementation class for the interface/abstract class so that instances of the implementation class are used when instantiated (e.g. during a parse).
Example:
// A bean with a single property. public interface MyBean { ... }// A bean with a single property. public class MyBeanImplimplements MyBean { ... }// Create a parser that instantiates MyBeanImpls when parsing MyBeans. ReaderParserparser = JsonParser .create () .implClasses(AMap.of (MyBean.class , MyBeanImpl.class )) .build();// Instantiates a MyBeanImpl, MyBeanbean =parser .parse("..." , MyBean.class );- Overrides:
implClasses
in classReaderParser.Builder
- Parameters:
values
- The new value for this setting.- Returns:
- This object.
-
interfaceClass
Description copied from class:BeanContextable.Builder
Identifies a class to be used as the interface class for the specified class and all subclasses.When specified, only the list of properties defined on the interface class will be used during serialization. Additional properties on subclasses will be ignored.
// Parent class or interface public abstract class A {public Stringfoo ="foo" ; }// Sub class public class A1extends A {public Stringbar ="bar" ; }// Create a serializer and define our interface class mapping. WriterSerializerserializer = JsonSerializer .create () .interfaceClass(A1.class , A.class ) .build();// Produces "{"foo":"foo"}" Stringjson =serializer .serialize(new A1());This annotation can be used on the parent class so that it filters to all child classes, or can be set individually on the child classes.
Notes:
- The
@Bean(interfaceClass)
annotation is the equivalent annotation-based solution.
- Overrides:
interfaceClass
in classReaderParser.Builder
- Parameters:
on
- The class that the interface class applies to.value
- The new value for this setting.- Returns:
- This object.
- The
-
interfaces
Description copied from class:BeanContextable.Builder
Identifies a set of interfaces.When specified, only the list of properties defined on the interface class will be used during serialization of implementation classes. Additional properties on subclasses will be ignored.
// Parent class or interface public abstract class A {public Stringfoo ="foo" ; }// Sub class public class A1extends A {public Stringbar ="bar" ; }// Create a serializer and define our interface class mapping. WriterSerializerserializer = JsonSerializer .create () .interfaces(A.class ) .build();// Produces "{"foo":"foo"}" Stringjson =serializer .serialize(new A1());This annotation can be used on the parent class so that it filters to all child classes, or can be set individually on the child classes.
Notes:
- The
@Bean(interfaceClass)
annotation is the equivalent annotation-based solution.
- Overrides:
interfaces
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.- Returns:
- This object.
- The
-
locale
Description copied from class:BeanContextable.Builder
Context configuration property: Locale.Specifies the default locale for serializer and parser sessions when not specified via
BeanSession.Builder.locale(Locale)
. Typically used for POJO swaps that need to deal with locales such as swaps that convertDate andCalendar objects to strings by accessing it via the session passed into theObjectSwap.swap(BeanSession, Object)
andObjectSwap.unswap(BeanSession, Object, ClassMeta, String)
methods.Example:
// Define a POJO swap that skips serializing beans if we're in the UK. public class MyBeanSwapextends StringSwap<MyBean> {@Override public String swap(BeanSessionsession , MyBeanbean )throws Exception {if (session .getLocale().equals(Locale.UK ))return null ;return bean .toString(); } }// Create a serializer that uses the specified locale if it's not passed in through session args. WriterSerializerserializer = JsonSerializer .create () .locale(Locale.UK ) .swaps(MyBeanSwap.class ) .build();See Also:
- Overrides:
locale
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.- Returns:
- This object.
-
mediaType
Description copied from class:BeanContextable.Builder
Context configuration property: Media type.Specifies the default media type for serializer and parser sessions when not specified via
BeanSession.Builder.mediaType(MediaType)
. Typically used for POJO swaps that need to serialize the same POJO classes differently depending on the specific requested media type. For example, a swap could handle a request for media types"application/json" and"application/json+foo" slightly differently even though they're both being handled by the same JSON serializer or parser.Example:
// Define a POJO swap that skips serializing beans if the media type is application/json. public class MyBeanSwapextends StringSwap<MyBean> {@Override public String swap(BeanSessionsession , MyBeanbean )throws Exception {if (session .getMediaType().equals("application/json" ))return null ;return bean .toString(); } }// Create a serializer that uses the specified media type if it's not passed in through session args. WriterSerializerserializer = JsonSerializer .create () .mediaType(MediaType.JSON ) .build();See Also:
- Overrides:
mediaType
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.- Returns:
- This object.
-
notBeanClasses
Description copied from class:BeanContextable.Builder
Bean class exclusions.List of classes that should not be treated as beans even if they appear to be bean-like. Not-bean classes are converted to
Strings during serialization.Values can consist of any of the following types:
- Classes.
- Arrays and collections of classes.
Example:
// A bean with a single property. public class MyBean {public Stringfoo ="bar" ;public String toString() {return "baz" ; } }// Create a serializer that doesn't treat MyBean as a bean class. WriterSerializerserializer = JsonSerializer .create () .notBeanClasses(MyBean.class ) .build();// Produces "baz" instead of {"foo":"bar"} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@BeanIgnore
annotation can also be used on classes to prevent them from being recognized as beans.
See Also:
- Overrides:
notBeanClasses
in classReaderParser.Builder
- Parameters:
values
- The values to add to this setting.
Values can consist of any of the following types:- Classes.
- Arrays and collections of classes.
- Returns:
- This object.
-
notBeanPackages
Description copied from class:BeanContextable.Builder
Bean package exclusions.Used as a convenient way of defining the
BeanContext.Builder.notBeanClasses(Class...)
property for entire packages. Any classes within these packages will be serialized to strings usingObject.toString()
.Note that you can specify suffix patterns to include all subpackages.
Values can consist of any of the following types:
- Strings.
- Arrays and collections of strings.
Example:
// Create a serializer that ignores beans in the specified packages. WriterSerializerserializer = JsonSerializer .create () .notBeanPackages("org.apache.foo" ,"org.apache.bar.*" ) .build();See Also:
- Overrides:
notBeanPackages
in classReaderParser.Builder
- Parameters:
values
- The values to add to this setting.
Values can consist of any of the following types:Package
objects.- Strings.
- Arrays and collections of anything in this list.
- Returns:
- This object.
-
propertyNamer
Description copied from class:BeanContextable.Builder
Bean property namerThe class to use for calculating bean property names.
Predefined classes:
BasicPropertyNamer
- Default.PropertyNamerDLC
- Dashed-lower-case names.PropertyNamerULC
- Dashed-upper-case names.
Example:
// A bean with a single property. public class MyBean {public StringfooBarBaz ="fooBarBaz" ; }// Create a serializer that uses Dashed-Lower-Case property names. // (e.g. "foo-bar-baz" instead of "fooBarBaz") WriterSerializerserializer = JsonSerializer .create () .propertyNamer(PropertyNamerDLC.class ) .build();// Produces: {"foo-bar-baz":"fooBarBaz"} Stringjson =serializer .serialize(new MyBean());See Also:
- Overrides:
propertyNamer
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.
The default isBasicPropertyNamer
.- Returns:
- This object.
-
propertyNamer
Description copied from class:BeanContextable.Builder
Bean property namerSame as
BeanContextable.Builder.propertyNamer(Class)
but allows you to specify a namer for a specific class.Example:
// A bean with a single property. public class MyBean {public StringfooBarBaz ="fooBarBaz" ; }// Create a serializer that uses Dashed-Lower-Case property names for the MyBean class only. // (e.g. "foo-bar-baz" instead of "fooBarBaz") WriterSerializerserializer = JsonSerializer .create () .propertyNamer(MyBean.class , PropertyNamerDLC.class ) .build();// Produces: {"foo-bar-baz":"fooBarBaz"} Stringjson =serializer .serialize(new MyBean());See Also:
- Overrides:
propertyNamer
in classReaderParser.Builder
- Parameters:
on
- The class that the namer applies to.value
- The new value for this setting.
The default isBasicPropertyNamer
.- Returns:
- This object.
-
sortProperties
Description copied from class:BeanContextable.Builder
Sort bean properties.When enabled, all bean properties will be serialized and access in alphabetical order. Otherwise, the natural order of the bean properties is used which is dependent on the JVM vendor. On IBM JVMs, the bean properties are ordered based on their ordering in the Java file. On Oracle JVMs, the bean properties are not ordered (which follows the official JVM specs).
this setting is disabled by default so that IBM JVM users don't have to use
@Bean
annotations to force bean properties to be in a particular order and can just alter the order of the fields/methods in the Java file.Example:
// A bean with 3 properties. public class MyBean {public Stringc ="1" ;public Stringb ="2" ;public Stringa ="3" ; }// Create a serializer that sorts bean properties. WriterSerializerserializer = JsonSerializer .create () .sortProperties() .build();// Produces: {"a":"3","b":"2","c":"1"} Stringjson =serializer .serialize(new MyBean());Notes:
- The
@Bean.sort()
annotation can also be used to sort properties on just a single class.
See Also:
- Overrides:
sortProperties
in classReaderParser.Builder
- Returns:
- This object.
- The
-
sortProperties
Description copied from class:BeanContextable.Builder
Sort bean properties.Same as
BeanContextable.Builder.sortProperties()
but allows you to specify individual bean classes instead of globally.Example:
// A bean with 3 properties. public class MyBean {public Stringc ="1" ;public Stringb ="2" ;public Stringa ="3" ; }// Create a serializer that sorts properties on MyBean. WriterSerializerserializer = JsonSerializer .create () .sortProperties(MyBean.class ) .build();// Produces: {"a":"3","b":"2","c":"1"} Stringjson =serializer .serialize(new MyBean());See Also:
- Overrides:
sortProperties
in classReaderParser.Builder
- Parameters:
on
- The bean classes to sort properties on.- Returns:
- This object.
-
stopClass
Description copied from class:BeanContextable.Builder
Identifies a stop class for the annotated class.Identical in purpose to the stop class specified by
Introspector.getBeanInfo(Class, Class)
. Any properties in the stop class or in its base classes will be ignored during analysis.For example, in the following class hierarchy, instances of
C3 will include propertyp3 , but notp1 orp2 .Example:
public class C1 {public int getP1(); }public class C2extends C1 {public int getP2(); }public class C3extends C2 {public int getP3(); }// Create a serializer specifies a stop class for C3. WriterSerializerserializer = JsonSerializer .create () .stopClass(C3.class , C2.class ) .build();// Produces: {"p3":"..."} Stringjson =serializer .serialize(new C3());- Overrides:
stopClass
in classReaderParser.Builder
- Parameters:
on
- The class on which the stop class is being applied.value
- The new value for this setting.- Returns:
- This object.
-
swap
public <T,S> PlainTextParser.Builder swap(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T, S> swapFunction) Description copied from class:BeanContextable.Builder
A shortcut for defining aFunctionalSwap
.Example:
// Create a serializer that performs a custom format for Date objects. WriterSerializerserializer = JsonSerializer .create () .swap(Date.class , String.class ,x ->format (x )) .build();- Overrides:
swap
in classReaderParser.Builder
- Type Parameters:
T
- The object type being swapped out.S
- The object type being swapped in.- Parameters:
normalClass
- The object type being swapped out.swappedClass
- The object type being swapped in.swapFunction
- The function to convert the object.- Returns:
- This object.
-
swap
public <T,S> PlainTextParser.Builder swap(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T, S> swapFunction, ThrowingFunction<S, T> unswapFunction) Description copied from class:BeanContextable.Builder
A shortcut for defining aFunctionalSwap
.Example:
// Create a serializer that performs a custom format for Date objects. WriterSerializerserializer = JsonSerializer .create () .swap(Date.class , String.class ,x ->format (x ),x ->parse (x )) .build();- Overrides:
swap
in classReaderParser.Builder
- Type Parameters:
T
- The object type being swapped out.S
- The object type being swapped in.- Parameters:
normalClass
- The object type being swapped out.swappedClass
- The object type being swapped in.swapFunction
- The function to convert the object during serialization.unswapFunction
- The function to convert the object during parsing.- Returns:
- This object.
-
swaps
Description copied from class:BeanContextable.Builder
Java object swaps.Swaps are used to "swap out" non-serializable classes with serializable equivalents during serialization, and "swap in" the non-serializable class during parsing.
An example of a swap would be a
Calendar object that gets swapped out for an ISO8601 string.Multiple swaps can be associated with a single class. When multiple swaps are applicable to the same class, the media type pattern defined by
ObjectSwap.forMediaTypes()
or@Swap(mediaTypes)
are used to come up with the best match.Values can consist of any of the following types:
- Any subclass of
ObjectSwap
. - Any instance of
ObjectSwap
. - Any surrogate class. A shortcut for defining a
SurrogateSwap
. - Any array or collection of the objects above.
Example:
// Sample swap for converting Dates to ISO8601 strings. public class MyDateSwapextends StringSwap<Date> {// ISO8601 formatter. private DateFormatformat =new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ" );@Override public String swap(BeanSessionsession , Datedate ) {return format .format(date ); }@Override public Date unswap(BeanSessionsession , Stringstring , ClassMetahint )throws Exception {return format .parse(string ); } }// Sample bean with a Date field. public class MyBean {public Datedate =new Date(112, 2, 3, 4, 5, 6); }// Create a serializer that uses our date swap. WriterSerializerserializer = JsonSerializer .create () .swaps(MyDateSwap.class ) .build();// Produces: {"date":"2012-03-03T04:05:06-0500"} Stringjson =serializer .serialize(new MyBean());// Create a serializer that uses our date swap. ReaderParserparser = JsonParser .create () .swaps(MyDateSwap.class ) .build();// Use our parser to parse a bean. MyBeanbean =parser .parse(json , MyBean.class );Notes:
- The
@Swap
annotation can also be used on classes to identify swaps for the class. - The
@Swap
annotation can also be used on bean methods and fields to identify swaps for values of those bean properties.
See Also:
- Overrides:
swaps
in classReaderParser.Builder
- Parameters:
values
- The values to add to this setting.
Values can consist of any of the following types:- Any subclass of
ObjectSwap
. - Any surrogate class. A shortcut for defining a
SurrogateSwap
. - Any array or collection of the objects above.
- Any subclass of
- Returns:
- This object.
- Any subclass of
-
timeZone
Description copied from class:BeanContextable.Builder
Context configuration property: TimeZone.Specifies the default time zone for serializer and parser sessions when not specified via
BeanSession.Builder.timeZone(TimeZone)
. Typically used for POJO swaps that need to deal with timezones such as swaps that convertDate andCalendar objects to strings by accessing it via the session passed into theObjectSwap.swap(BeanSession, Object)
andObjectSwap.unswap(BeanSession, Object, ClassMeta, String)
methods.Example:
// Define a POJO swap that skips serializing beans if the time zone is GMT. public class MyBeanSwapextends StringSwap<MyBean> {@Override public String swap(BeanSessionsession , MyBeanbean )throws Exception {if (session .getTimeZone().equals(TimeZone.GMT ))return null ;return bean .toString(); } }// Create a serializer that uses GMT if the timezone is not specified in the session args. WriterSerializerserializer = JsonSerializer .create () .timeZone(TimeZone.GMT ) .build();See Also:
- Overrides:
timeZone
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.- Returns:
- This object.
-
typeName
Description copied from class:BeanContextable.Builder
An identifying name for this class.The name is used to identify the class type during parsing when it cannot be inferred through reflection. For example, if a bean property is of type
Object , then the serializer will add the name to the output so that the class can be determined during parsing.It is also used to specify element names in XML.
Example:
// Use _type='mybean' to identify this bean. public class MyBean {...}// Create a serializer and specify the type name.. WriterSerializerserializer = JsonSerializer .create () .typeName(MyBean.class ,"mybean" ) .build();// Produces: {"_type":"mybean",...} Stringjson =serializer .serialize(new MyBean());Notes:
- Equivalent to the
Bean(typeName)
annotation.
See Also:
- Overrides:
typeName
in classReaderParser.Builder
- Parameters:
on
- The class the type name is being defined on.value
- The new value for this setting.- Returns:
- This object.
- Equivalent to the
-
typePropertyName
Description copied from class:BeanContextable.Builder
Bean type property name.This specifies the name of the bean property used to store the dictionary name of a bean type so that the parser knows the data type to reconstruct.
Example:
// POJOs with @Bean(name) annotations. @Bean (typeName="foo" )public class Foo {...}@Bean (typeName="bar" )public class Bar {...}// Create a serializer that uses 't' instead of '_type' for dictionary names. WriterSerializerserializer = JsonSerializer .create () .typePropertyName("t" ) .dictionary(Foo.class , Bar.class ) .build();// Create a serializer that uses 't' instead of '_type' for dictionary names. ReaderParserparser = JsonParser .create () .typePropertyName("t" ) .dictionary(Foo.class , Bar.class ) .build();// A bean with a field with an indeterminate type. public class MyBean {public ObjectmySimpleField ; }// Produces "{mySimpleField:{t:'foo',...}}". Stringjson =serializer .serialize(new MyBean());// Parse bean. MyBeanbean =parser .parse(json , MyBean.class );See Also:
- Overrides:
typePropertyName
in classReaderParser.Builder
- Parameters:
value
- The new value for this setting.
The default is"_type" .- Returns:
- This object.
-
typePropertyName
Description copied from class:BeanContextable.Builder
Bean type property name.Same as
BeanContextable.Builder.typePropertyName(String)
except targets a specific bean class instead of globally.Example:
// POJOs with @Bean(name) annotations. @Bean (typeName="foo" )public class Foo {...}@Bean (typeName="bar" )public class Bar {...}// A bean with a field with an indeterminate type. public class MyBean {public ObjectmySimpleField ; }// Create a serializer that uses 't' instead of '_type' for dictionary names. WriterSerializerserializer = JsonSerializer .create () .typePropertyName(MyBean.class ,"t" ) .dictionary(Foo.class , Bar.class ) .build();// Produces "{mySimpleField:{t:'foo',...}}". Stringjson =serializer .serialize(new MyBean());See Also:
- Overrides:
typePropertyName
in classReaderParser.Builder
- Parameters:
on
- The class the type property name applies to.value
- The new value for this setting.
The default is"_type" .- Returns:
- This object.
-
useEnumNames
Description copied from class:BeanContextable.Builder
Use enum names.When enabled, enums are always serialized by name, not using
Object.toString()
.Example:
// Create a serializer with debug enabled. WriterSerializerserializer = JsonSerializer .create () .useEnumNames() .build();// Enum with overridden toString(). // Will be serialized as ONE/TWO/THREE even though there's a toString() method. public enum Option {ONE (1),TWO (2),THREE (3);private int value ; Option(int value ) {this .value =value ; }@Override public String toString() {return String.valueOf (value ); } }See Also:
- Overrides:
useEnumNames
in classReaderParser.Builder
- Returns:
- This object.
-
useJavaBeanIntrospector
Description copied from class:BeanContextable.Builder
Use Java Introspector.Using the built-in Java bean introspector will not pick up fields or non-standard getters/setters.
Most@Bean
annotations will be ignored.Example:
// Create a serializer that only uses the built-in java bean introspector for finding properties. WriterSerializerserializer = JsonSerializer .create () .useJavaBeanIntrospector() .build();See Also:
- Overrides:
useJavaBeanIntrospector
in classReaderParser.Builder
- Returns:
- This object.
-
autoCloseStreams
Description copied from class:Parser.Builder
Auto-close streams.When enabled,
InputStreams andReaders passed into parsers will be closed after parsing is complete.Example:
// Create a parser using strict mode. ReaderParserparser = JsonParser .create () .autoCloseStreams() .build(); ReadermyReader =new FileReader("/tmp/myfile.json" ); MyBeanmyBean =parser .parse(myReader , MyBean.class );assertTrue (myReader .isClosed());- Overrides:
autoCloseStreams
in classReaderParser.Builder
- Returns:
- This object.
-
autoCloseStreams
Description copied from class:Parser.Builder
Same asParser.Builder.autoCloseStreams()
but allows you to explicitly specify the value.- Overrides:
autoCloseStreams
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
consumes
Description copied from class:Parser.Builder
Specifies the media type that this parser consumes.- Overrides:
consumes
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
debugOutputLines
Description copied from class:Parser.Builder
Debug output lines.When parse errors occur, this specifies the number of lines of input before and after the error location to be printed as part of the exception message.
Example:
// Create a parser whose exceptions print out 100 lines before and after the parse error location. ReaderParserparser = JsonParser .create () .debug()// Enable debug mode to capture Reader contents as strings. .debugOuputLines(100) .build(); ReadermyReader =new FileReader("/tmp/mybadfile.json" );try {parser .parse(myReader , Object.class ); }catch (ParseExceptione ) { System.err .println(e .getMessage());// Will display 200 lines of the output. }- Overrides:
debugOutputLines
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.
The default value is5 .- Returns:
- This object.
-
listener
Description copied from class:Parser.Builder
Parser listener.Class used to listen for errors and warnings that occur during parsing.
Example:
// Define our parser listener. // Simply captures all unknown bean property events. public class MyParserListenerextends ParserListener {// A simple property to store our events. public List<String>events =new LinkedList<>();@Override public <T>void onUnknownBeanProperty(ParserSessionsession , StringpropertyName , Class<T>beanClass , Tbean ) { Positionposition =parser .getPosition();events .add(propertyName +"," +position .getLine() +"," +position .getColumn()); } }// Create a parser using our listener. ReaderParserparser = JsonParser .create () .listener(MyParserListener.class ) .build();// Create a session object. // Needed because listeners are created per-session. try (ReaderParserSessionsession =parser .createSession()) {// Parse some JSON object. MyBeanmyBean =session .parse("{...}" , MyBean.class );// Get the listener. MyParserListenerlistener =session .getListener(MyParserListener.class );// Dump the results to the console. Json5.DEFAULT .println(listener .events ); }- Overrides:
listener
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.- Returns:
- This object.
-
strict
Description copied from class:Parser.Builder
Strict mode.When enabled, strict mode for the parser is enabled.
Strict mode can mean different things for different parsers.
Parser class Strict behavior All reader-based parsers When enabled, throws ParseExceptions
on malformed charset input. Otherwise, malformed input is ignored.JsonParser
When enabled, throws exceptions on the following invalid JSON syntax: - Unquoted attributes.
- Missing attribute values.
- Concatenated strings.
- Javascript comments.
- Numbers and booleans when Strings are expected.
- Numbers valid in Java but not JSON (e.g. octal notation, etc...)
Example:
// Create a parser using strict mode. ReaderParserparser = JsonParser .create () .strict() .build();// Use it. try { Stringjson ="{unquotedAttr:'value'}" ;parser .parse(json , MyBean.class ); }catch (ParseExceptione ) {assertTrue (e .getMessage().contains("Unquoted attribute detected." ); }- Overrides:
strict
in classReaderParser.Builder
- Returns:
- This object.
-
strict
Description copied from class:Parser.Builder
Same asParser.Builder.strict()
but allows you to explicitly specify the value.- Overrides:
strict
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
trimStrings
Description copied from class:Parser.Builder
Trim parsed strings.When enabled, string values will be trimmed of whitespace using
String.trim()
before being added to the POJO.Example:
// Create a parser with trim-strings enabled. ReaderParserparser = JsonParser .create () .trimStrings() .build();// Use it. Stringjson ="{' foo ':' bar '}" ; Map<String,String>myMap =parser .parse(json , HashMap.class , String.class , String.class );// Make sure strings are parsed. assertEquals ("bar" ,myMap .get("foo" ));- Overrides:
trimStrings
in classReaderParser.Builder
- Returns:
- This object.
-
trimStrings
Description copied from class:Parser.Builder
Same asParser.Builder.trimStrings()
but allows you to explicitly specify the value.- Overrides:
trimStrings
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
unbuffered
Description copied from class:Parser.Builder
Unbuffered.When enabled, don't use internal buffering during parsing.
This is useful in cases when you want to parse the same input stream or reader multiple times because it may contain multiple independent POJOs to parse.
Buffering would cause the parser to read past the current POJO in the stream.Example:
// Create a parser using strict mode. ReaderParserparser = JsonParser. .create () .unbuffered(true ) .build();// If you're calling parse on the same input multiple times, use a session instead of the parser directly. // It's more efficient because we don't need to recalc the session settings again. ReaderParserSessionsession =parser .createSession();// Read input with multiple POJOs Readerjson =new StringReader("{foo:'bar'}{foo:'baz'}" ); MyBeanmyBean1 =session .parse(json , MyBean.class ); MyBeanmyBean2 =session .parse(json , MyBean.class );Notes:
-
This only allows for multi-input streams for the following parsers:
It has no effect on the following parsers:
MsgPackParser
- It already doesn't use buffering.XmlParser
,HtmlParser
- These use StAX which doesn't allow for more than one root element anyway.- RDF parsers - These read everything into an internal model before any parsing begins.
- Overrides:
unbuffered
in classReaderParser.Builder
- Returns:
- This object.
-
This only allows for multi-input streams for the following parsers:
It has no effect on the following parsers:
-
unbuffered
Description copied from class:Parser.Builder
Same asParser.Builder.unbuffered()
but allows you to explicitly specify the value.- Overrides:
unbuffered
in classReaderParser.Builder
- Parameters:
value
- The value for this setting.- Returns:
- This object.
-
fileCharset
Description copied from class:ReaderParser.Builder
File charset.The character set to use for reading
Files from the file system.Used when passing in files to
Parser.parse(Object, Class)
.Example:
// Create a parser that reads UTF-8 files. ReaderParserparser = JsonParser .create () .fileCharset("UTF-8" ) .build();// Use it to read a UTF-8 encoded file. MyBeanmyBean =parser .parse(new File("MyBean.txt" ), MyBean.class );- Overrides:
fileCharset
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.
The default value is"DEFAULT" which causes the system default to be used.- Returns:
- This object.
-
streamCharset
Description copied from class:ReaderParser.Builder
Input stream charset.The character set to use for converting
InputStreams and byte arrays to readers.Used when passing in input streams and byte arrays to
Parser.parse(Object, Class)
.Example:
// Create a parser that reads UTF-8 files. ReaderParserparser = JsonParser .create () .streamCharset(Charset.forName ("UTF-8" )) .build();// Use it to read a UTF-8 encoded input stream. MyBeanmyBean =parser .parse(new FileInputStream("MyBean.txt" ), MyBean.class );- Overrides:
streamCharset
in classReaderParser.Builder
- Parameters:
value
- The new value for this property.
The default value is"UTF-8" .- Returns:
- This object.
-