Package org.apache.juneau.html

Class HtmlDocSerializer.Builder

java.lang.Object
org.apache.juneau.Context.Builder
org.apache.juneau.BeanContextable.Builder
org.apache.juneau.BeanTraverseContext.Builder
org.apache.juneau.serializer.Serializer.Builder
org.apache.juneau.serializer.WriterSerializer.Builder
org.apache.juneau.xml.XmlSerializer.Builder
org.apache.juneau.html.HtmlSerializer.Builder
org.apache.juneau.html.HtmlStrippedDocSerializer.Builder
org.apache.juneau.html.HtmlDocSerializer.Builder
Direct Known Subclasses:
HtmlSchemaDocSerializer.Builder
Enclosing class:
HtmlDocSerializer
public static class HtmlDocSerializer.Builder extends HtmlStrippedDocSerializer.Builder
Builder class.

  • Constructor Details

  • Method Details

    • copy

      public HtmlDocSerializer.Builder copy()
      Description copied from class: Context.Builder
      Copy creator.
      Overrides:
      copy in class HtmlStrippedDocSerializer.Builder
      Returns:
      A new mutable copy of this builder.

    • build

      public HtmlDocSerializer build()
      Description copied from class: Context.Builder
      Build the object.
      Overrides:
      build in class HtmlStrippedDocSerializer.Builder
      Returns:
      The built object.

    • hashKey

      public HashKey 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 the HashKey.equals(Object) method is the same.

      Overrides:
      hashKey in class HtmlStrippedDocSerializer.Builder
      Returns:
      The hashkey of this builder.

    • aside

      public HtmlDocSerializer.Builder aside(String... value)
      Aside section contents.

      Allows you to specify the contents of the aside section on the HTML page. The aside section floats on the right of the page for providing content supporting the serialized content of the page.

      By default, the aside section is empty.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .aside( "<ul>", " <li>Item 1", " <li>Item 2", " <li>Item 3", "</ul>" ) .build();

      Notes:
      • Format: HTML
      • Supports SVL Variables (e.g. "$L{my.localized.variable}").
      • A value of "NONE" can be used to force no value.
      • The parent value can be included by adding the literal "INHERIT" as a value.
      • Multiple values are combined with newlines into a single string.
      • On methods, this value is inherited from the @HtmlDocConfig annotation on the servlet/resource class.
      • On servlet/resource classes, this value is inherited from the @HtmlDocConfig annotation on the parent class.
      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • aside

      public List<String> aside()
      Returns the list of aside section contents.

      Gives access to the inner list if you need to make more than simple additions via aside(String...).

      Returns:
      The list of aside section contents.
      See Also:

    • asideFloat

      public HtmlDocSerializer.Builder asideFloat(AsideFloat value)
      Float aside section contents.

      Allows you to position the aside contents of the page around the main contents.

      By default, the aside section is floated to the right.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .aside( "<ul>", " <li>Item 1", " <li>Item 2", " <li>Item 3", "</ul>" ) .asideFloat(RIGHT) .build();

      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • footer

      public HtmlDocSerializer.Builder footer(String... value)
      Footer section contents.

      Allows you to specify the contents of the footer section on the HTML page.

      By default, the footer section is empty.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .footer( "<b>This interface is great!</b>" ) .build();

      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • footer

      public List<String> footer()
      Returns the list of footer section contents.

      Gives access to the inner list if you need to make more than simple additions via footer(String...).

      Returns:
      The list of footer section contents.
      See Also:

    • head

      public HtmlDocSerializer.Builder head(String... value)
      Additional head section content.

      Adds the specified HTML content to the head section of the page.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .head( "<link rel='icon' href='$U{servlet:/htdocs/mypageicon.ico}'>" ) .build();

      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • head

      public List<String> head()
      Returns the list of head section contents.

      Gives access to the inner list if you need to make more than simple additions via head(String...).

      Returns:
      The list of head section contents.
      See Also:

    • header

      public HtmlDocSerializer.Builder header(String... value)
      Header section contents.

      Allows you to override the contents of the header section on the HTML page. The header section normally contains the title and description at the top of the page.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .header( "<h1>My own header</h1>" ) .build()

      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • header

      public List<String> header()
      Returns the list of header section contents.

      Gives access to the inner list if you need to make more than simple additions via header(String...).

      Returns:
      The list of header section contents.
      See Also:

    • noResultsMessage

      public HtmlDocSerializer.Builder noResultsMessage(String value)
      No-results message.

      Allows you to specify the string message used when trying to serialize an empty array or empty list.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .noResultsMessage("<b>This interface is great!</b>") .build();

      A value of "NONE" can be used to represent no value to differentiate it from an empty string.

      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • nowrap

      public HtmlDocSerializer.Builder nowrap()
      Prevent word wrap on page.

      Adds "* {white-space:nowrap}" to the CSS instructions on the page to prevent word wrapping.

      Returns:
      This object.

    • nowrap

      public HtmlDocSerializer.Builder nowrap(boolean value)
      Same as nowrap() but allows you to explicitly specify the boolean value.
      Parameters:
      value - The new value for this property.
      Returns:
      This object.
      See Also:

    • script

      public HtmlDocSerializer.Builder script(String... value)
      Adds the specified Javascript code to the HTML page.

      A shortcut on @Rest is also provided for this setting:

      WriterSerializer serializer = HtmlDocSerializer .create() .script("alert('hello!');") .build();

      Parameters:
      value - The value to add to this property.
      Returns:
      This object.

    • script

      public List<String> script()
      Returns the list of page script contents.

      Gives access to the inner list if you need to make more than simple additions via script(String...).

      Returns:
      The list of page script contents.
      See Also:

    • style

      public HtmlDocSerializer.Builder style(String... value)
      Adds the specified CSS instructions to the HTML page.

      WriterSerializer serializer = HtmlDocSerializer .create() .style( "h3 { color: red; }", "h5 { font-weight: bold; }" ) .build();

      Parameters:
      value - The value to add to this property.
      Returns:
      This object.

    • style

      public List<String> style()
      Returns the list of page style contents.

      Gives access to the inner list if you need to make more than simple additions via style(String...).

      Returns:
      The list of page style contents.
      See Also:

    • stylesheet

      public HtmlDocSerializer.Builder stylesheet(String... value)
      Adds to the list of stylesheet URLs.

      Note that this stylesheet is controlled by the @Rest.stylesheet() annotation.

      Parameters:
      value - The value to add to this property.
      Returns:
      This object.

    • stylesheet

      public List<String> stylesheet()
      Returns the list of stylesheet URLs.

      Gives access to the inner list if you need to make more than simple additions via stylesheet(String...).

      Returns:
      The list of stylesheet URLs.
      See Also:

    • template

      public HtmlDocSerializer.Builder template(Class<? extends HtmlDocTemplate> value)
      HTML document template.

      Specifies the template to use for serializing the page.

      By default, the BasicHtmlDocTemplate class is used to construct the contents of the HTML page, but can be overridden with your own custom implementation class.

      Example:

      WriterSerializer serializer = HtmlDocSerializer .create() .template(MySpecialDocTemplate.class) .build();

      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • widgets

      public HtmlDocSerializer.Builder widgets(Class<? extends HtmlWidget>... values)
      HTML Widgets.

      Defines widgets that can be used in conjunction with string variables of the form "$W{name}"to quickly generate arbitrary replacement text. Widgets resolve the following variables:

      The following examples shows how to associate a widget with a REST method and then have it rendered in the links and aside section of the page:

      WriterSerializer serializer = HtmlDocSerializer .create() .widgets( MyWidget.class ) .navlinks( "$W{MyWidget}" ) .aside( "Check out this widget: $W{MyWidget}" ) .build();

      Notes:
      • Widgets are inherited from super classes, but can be overridden by reusing the widget name.
      See Also:
      Parameters:
      values - The values to add to this setting.
      Returns:
      This object.

    • widgets

      public List<Class<? extends HtmlWidget>> widgets()
      Returns the list of page widgets.

      Gives access to the inner list if you need to make more than simple additions via widgets(Class...).

      Returns:
      The list of page widgets.
      See Also:

    • annotations

      public HtmlDocSerializer.Builder annotations(Annotation... values)
      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. WriterSerializer serializer = JsonSerializer.create().annotations(annotation).build(); // Serialize a bean with the dynamically applied annotation. String json = serializer.serialize(new B());

      The following is the list of annotations builders provided that can be constructed and passed into the builder class:

      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"
      • 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"
      • Fields:
        • Fully qualified:
          • "com.foo.MyClass.myField"
        • Simple:
          • "MyClass.myField"
        • Simple inner class:
          • "MyClass$Inner1$Inner2.myField"
          • "Inner1$Inner2.myField"
          • "Inner2.myField"
      • 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()"
      • A comma-delimited list of anything on this list.
      See Also:
      Overrides:
      annotations in class HtmlStrippedDocSerializer.Builder
      Parameters:
      values - The annotations to register with the context.
      Returns:
      This object.

    • apply

      public HtmlDocSerializer.Builder apply(AnnotationWorkList work)
      Description copied from class: Context.Builder
      Applies a set of applied to this builder.

      An AnnotationWork consists of a single pair of AnnotationInfo that represents an annotation instance, and AnnotationApplier 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. AnnotationList annotations = ClassInfo.of(MyClass.class).getAnnotationList(CONTEXT_APPLY_FILTER); VarResolverSession vrs = VarResolver.DEFAULT.createSession(); AnnotationWorkList work = AnnotationWorkList.of(vrs, annotations); // Apply any settings found on the annotations. WriterSerializer serializer = JsonSerializer .create() .apply(work) .build();

      Overrides:
      apply in class HtmlStrippedDocSerializer.Builder
      Parameters:
      work - The list of annotations and appliers to apply to this builder.
      Returns:
      This object.

    • applyAnnotations

      public HtmlDocSerializer.Builder applyAnnotations(Class<?>... fromClasses)
      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:

      Annotations on classes are appended in the following order:

      1. On the package of this class.
      2. On interfaces ordered parent-to-child.
      3. On parent classes ordered parent-to-child.
      4. 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. WriterSerializer serializer = JsonSerializer .create() .applyAnnotations(MyClass.class) .build();

      Overrides:
      applyAnnotations in class HtmlStrippedDocSerializer.Builder
      Parameters:
      fromClasses - The classes on which the annotations are defined.
      Returns:
      This object.

    • applyAnnotations

      public HtmlDocSerializer.Builder applyAnnotations(Method... fromMethods)
      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:

      Annotations on methods are appended in the following order:

      1. On the package of the method class.
      2. On interfaces ordered parent-to-child.
      3. On parent classes ordered parent-to-child.
      4. On the method class.
      5. 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. WriterSerializer serializer = JsonSerializer .create() .applyAnnotations(MyClass.class.getMethod("myMethod")) .build();

      Overrides:
      applyAnnotations in class HtmlStrippedDocSerializer.Builder
      Parameters:
      fromMethods - The methods on which the annotations are defined.
      Returns:
      This object.

    • cache

      public HtmlDocSerializer.Builder cache(Cache<HashKey,? extends Context> value)
      Description copied from class: Context.Builder
      Specifies a cache to use for hashkey-based caching.
      Overrides:
      cache in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The cache.
      Returns:
      This object.

    • debug

      public HtmlDocSerializer.Builder debug()
      Description copied from class: Context.Builder
      Context configuration property:  Debug mode.

      Enables the following additional information during serialization:

      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. WriterSerializer serializer = JsonSerializer .create() .debug() .build(); // Create a POJO model with a recursive loop. public class MyBean { public Object f; } MyBean bean = new MyBean(); bean.f = bean; // Throws a SerializeException and not a StackOverflowError String json = serializer.serialize(bean);

      See Also:
      Overrides:
      debug in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • debug

      public HtmlDocSerializer.Builder debug(boolean value)
      Description copied from class: Context.Builder
      Same as Context.Builder.debug() but allows you to explicitly specify the value.
      Overrides:
      debug in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • impl

      public HtmlDocSerializer.Builder impl(Context value)
      Description copied from class: Context.Builder
      Specifies a pre-instantiated bean for the Context.Builder.build() method to return.
      Overrides:
      impl in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • type

      public HtmlDocSerializer.Builder type(Class<? extends Context> value)
      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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The context class that this builder should create.
      Returns:
      This object.

    • beanClassVisibility

      public HtmlDocSerializer.Builder beanClassVisibility(Visibility value)
      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 is protected, 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 String foo = "bar"; } // Create a serializer that's capable of serializing the class. WriterSerializer serializer = JsonSerializer .create() .beanClassVisibility(PROTECTED) .build(); // Produces: {"foo","bar"} String json = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is Visibility.PUBLIC.
      Returns:
      This object.

    • beanConstructorVisibility

      public HtmlDocSerializer.Builder beanConstructorVisibility(Visibility value)
      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 String foo; protected MyBean() {} } // Create a parser capable of calling the protected constructor. ReaderParser parser = ReaderParser .create() .beanConstructorVisibility(PROTECTED) .build(); // Use it. MyBean bean = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is Visibility.PUBLIC.
      Returns:
      This object.

    • beanContext

      public HtmlDocSerializer.Builder beanContext(BeanContext value)
      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 beanContext.copy().build(). An example is BeanContext.getBeanToStringSerializer().

      Overrides:
      beanContext in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The bean context to use.
      Returns:
      This object.

    • beanContext

      public HtmlDocSerializer.Builder beanContext(BeanContext.Builder value)
      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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      Returns:
      This object.

    • beanDictionary

      public HtmlDocSerializer.Builder beanDictionary(Class<?>... values)
      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 class Foo 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. ReaderParser parser = JsonParser .create() .dictionary(Foo.class, Bar.class) .addBeanTypes() .build(); // A bean with a field with an indeterminate type. public class MyBean { public Object mySimpleField; } // Parse bean. MyBean bean = 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 Object mySimpleField; // 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. ReaderParser parser = HtmlParser .create() .dictionary(HtmlBeanDictionary.class) .build(); // Parse an HTML body into HTML beans. Body body = parser.parse("<body><ul><li>foo</li><li>bar</li></ul>", Body.class);

      See Also:
      Overrides:
      beanDictionary in class HtmlStrippedDocSerializer.Builder
      Parameters:
      values - The values to add to this setting.
      Returns:
      This object.

    • beanFieldVisibility

      public HtmlDocSerializer.Builder beanFieldVisibility(Visibility value)
      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 String foo = "bar"; } // Create a serializer that recognizes the protected field. WriterSerializer serializer = JsonSerializer .create() .beanFieldVisibility(PROTECTED) .build(); // Produces: {"foo":"bar"} String json = 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. WriterSerializer serializer = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is Visibility.PUBLIC.
      Returns:
      This object.

    • beanInterceptor

      public HtmlDocSerializer.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 AddressInterceptor extends BeanInterceptor<Address> { public Object readProperty(Address bean, String name, Object value) { if ("taxInfo".equals(name)) return "redacted"; return value; } public Object writeProperty(Address bean, String name, Object value) { 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(String value) {...} } // Register filter on serializer or parser. WriterSerializer serializer = JsonSerializer .create() .beanInterceptor(Address.class, AddressInterceptor.class) .build(); // Produces: {"taxInfo":"redacted"} String json = serializer.serialize(new Address());

      See Also:
      Overrides:
      beanInterceptor in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The bean that the filter applies to.
      value - The new value for this setting.
      Returns:
      This object.

    • beanMapPutReturnsOldValue

      public HtmlDocSerializer.Builder 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 returns null.

      Disabled by default because it introduces a slight performance penalty during serialization.

      Example:

      // Create a context that creates BeanMaps with normal put() behavior. BeanContext context = BeanContext .create() .beanMapPutReturnsOldValue() .build(); BeanMap<MyBean> beanMap = context.createSession().toBeanMap(new MyBean()); beanMap.put("foo", "bar"); Object oldValue = beanMap.put("foo", "baz"); // oldValue == "bar"

      See Also:
      Overrides:
      beanMapPutReturnsOldValue in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • beanMethodVisibility

      public HtmlDocSerializer.Builder beanMethodVisibility(Visibility value)
      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. WriterSerializer serializer = JsonSerializer .create() .beanMethodVisibility(PROTECTED) .build(); // Produces: {"foo":"foo","bar":"bar"} String json = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is Visibility.PUBLIC
      Returns:
      This object.

    • beanProperties

      public HtmlDocSerializer.Builder beanProperties(Map<String,Object> values)
      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.of("MyBean", "foo,bar")) means only serialize the foo and bar 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 whether BeanContextable.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 String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializer serializer = JsonSerializer .create() .beanProperties(AMap.of("MyBean", "foo,bar")) .build(); // Produces: {"foo":"foo","bar":"bar"} String json = 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:
      Overrides:
      beanProperties in class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanProperties(Class<?> beanClass, String properties)
      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.class, "foo,bar") means only serialize the foo and bar 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 whether BeanContextable.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 String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializer serializer = JsonSerializer .create() .beanProperties(MyBean.class, "foo,bar") .build(); // Produces: {"foo":"foo","bar":"bar"} String json = serializer.serialize(new MyBean());

      This method is functionally equivalent to the following code:

      builder.annotations(BeanAnnotation.create(beanClass).properties(properties).build());

      See Also:
      Overrides:
      beanProperties in class HtmlStrippedDocSerializer.Builder
      Parameters:
      beanClass - The bean class.
      properties - Comma-delimited list of property names.
      Returns:
      This object.

    • beanProperties

      public HtmlDocSerializer.Builder beanProperties(String beanClassName, String properties)
      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", "foo,bar") means only serialize the foo and bar 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 whether BeanContextable.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 String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializer serializer = JsonSerializer .create() .beanProperties("MyBean", "foo,bar") .build(); // Produces: {"foo":"foo","bar":"bar"} String json = serializer.serialize(new MyBean());

      This method is functionally equivalent to the following code:

      builder.annotations(BeanAnnotation.create(beanClassName).properties(properties).build());

      See Also:
      Overrides:
      beanProperties in class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanPropertiesExcludes(Map<String,Object> values)
      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 String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesExcludes(AMap.of("MyBean", "bar,baz")) .build(); // Produces: {"foo":"foo"} String json = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanPropertiesExcludes(Class<?> beanClass, String properties)
      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 String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesExcludes(MyBean.class, "bar,baz") .build(); // Produces: {"foo":"foo"} String json = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      beanClass - The bean class.
      properties - Comma-delimited list of property names.
      Returns:
      This object.

    • beanPropertiesExcludes

      public HtmlDocSerializer.Builder beanPropertiesExcludes(String beanClassName, String properties)
      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 String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesExcludes("MyBean", "bar,baz") .build(); // Produces: {"foo":"foo"} String json = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanPropertiesReadOnly(Map<String,Object> values)
      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 String foo, bar, baz; } // Create a serializer with read-only property settings. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesReadOnly(AMap.of("MyBean", "bar,baz")) .build(); // All 3 properties will be serialized. String json = serializer.serialize(new MyBean()); // Create a parser with read-only property settings. ReaderParser parser = JsonParser .create() .beanPropertiesReadOnly(AMap.of("MyBean", "bar,baz")) .ignoreUnknownBeanProperties() .build(); // Parser ignores bar and baz properties. MyBean bean = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanPropertiesReadOnly(Class<?> beanClass, String properties)
      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 String foo, bar, baz; } // Create a serializer with read-only property settings. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesReadOnly(MyBean.class, "bar,baz") .build(); // All 3 properties will be serialized. String json = serializer.serialize(new MyBean()); // Create a parser with read-only property settings. ReaderParser parser = JsonParser .create() .beanPropertiesReadOnly(MyBean.class, "bar,baz") .ignoreUnknownBeanProperties() .build(); // Parser ignores bar and baz properties. MyBean bean = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      beanClass - The bean class.
      properties - Comma-delimited list of property names.
      Returns:
      This object.

    • beanPropertiesReadOnly

      public HtmlDocSerializer.Builder beanPropertiesReadOnly(String beanClassName, String properties)
      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 String foo, bar, baz; } // Create a serializer with read-only property settings. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesReadOnly("MyBean", "bar,baz") .build(); // All 3 properties will be serialized. String json = serializer.serialize(new MyBean()); // Create a parser with read-only property settings. ReaderParser parser = JsonParser .create() .beanPropertiesReadOnly("MyBean", "bar,baz") .ignoreUnknownBeanProperties() .build(); // Parser ignores bar and baz properties. MyBean bean = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanPropertiesWriteOnly(Map<String,Object> values)
      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 String foo, bar, baz; } // Create a serializer with write-only property settings. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesWriteOnly(AMap.of("MyBean", "bar,baz")) .build(); // Only foo will be serialized. String json = serializer.serialize(new MyBean()); // Create a parser with write-only property settings. ReaderParser parser = JsonParser .create() .beanPropertiesWriteOnly(AMap.of("MyBean", "bar,baz")) .build(); // Parser parses all 3 properties. MyBean bean = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder beanPropertiesWriteOnly(Class<?> beanClass, String properties)
      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 String foo, bar, baz; } // Create a serializer with write-only property settings. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesWriteOnly(MyBean.class, "bar,baz") .build(); // Only foo will be serialized. String json = serializer.serialize(new MyBean()); // Create a parser with write-only property settings. ReaderParser parser = JsonParser .create() .beanPropertiesWriteOnly(MyBean.class, "bar,baz") .build(); // Parser parses all 3 properties. MyBean bean = 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 class HtmlStrippedDocSerializer.Builder
      Parameters:
      beanClass - The bean class.
      properties - Comma-delimited list of property names.
      Returns:
      This object.

    • beanPropertiesWriteOnly

      public HtmlDocSerializer.Builder beanPropertiesWriteOnly(String beanClassName, String properties)
      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 String foo, bar, baz; } // Create a serializer with write-only property settings. WriterSerializer serializer = JsonSerializer .create() .beanPropertiesWriteOnly("MyBean", "bar,baz") .build(); // Only foo will be serialized. String json = serializer.serialize(new MyBean()); // Create a parser with write-only property settings. ReaderParser parser = JsonParser .create() .beanPropertiesWriteOnly("MyBean", "bar,baz") .build(); // Parser parses all 3 properties. MyBean bean = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder 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 String foo = "bar"; // A no-arg constructor public MyBean(String foo) { this.foo = foo; } @Override public String toString() { return "bar"; } } // Create a serializer that ignores beans without default constructors. WriterSerializer serializer = JsonSerializer .create() .beansRequireDefaultConstructor() .build(); // Produces: "bar" String json = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • beansRequireSerializable

      public HtmlDocSerializer.Builder 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 the Object.toString() method.

      Example:

      // A bean without a Serializable interface. public class MyBean { // A property method. public String foo = "bar"; @Override public String toString() { return "bar"; } } // Create a serializer that ignores beans not implementing Serializable. WriterSerializer serializer = JsonSerializer .create() .beansRequireSerializable() .build(); // Produces: "bar" String json = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • beansRequireSettersForGetters

      public HtmlDocSerializer.Builder 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(String foo) { ... } // A read-only property. public String getBar() { return "bar"; } } // Create a serializer that ignores bean properties without setters. WriterSerializer serializer = JsonSerializer .create() .beansRequireSettersForGetters() .build(); // Produces: {"foo":"foo"} String json = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • dictionaryOn

      public HtmlDocSerializer.Builder dictionaryOn(Class<?> on, Class<?>... values)
      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 Object mySimpleField; } // Create a parser and tell it which classes to try to resolve. ReaderParser parser = JsonParser .create() .dictionaryOn(MyBean.class, Foo.class, Bar.class) .build(); // Parse bean. MyBean bean = parser.parse("{mySimpleField:{_type:'foo',...}}", MyBean.class);

      This is functionally equivalent to the Bean.dictionary() annotation.

      See Also:
      Overrides:
      dictionaryOn in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The class that the dictionary values apply to.
      values - The new values for this setting.
      Returns:
      This object.

    • disableBeansRequireSomeProperties

      public HtmlDocSerializer.Builder 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 when true.

      Example:

      // A bean with no properties. public class MyBean { } // Create a serializer that serializes beans even if they have zero properties. WriterSerializer serializer = JsonSerializer .create() .disableBeansRequireSomeProperties() .build(); // Produces: {} String json = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableIgnoreMissingSetters

      public HtmlDocSerializer.Builder 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. ReaderParser parser = JsonParser .create() .disableIgnoreMissingSetters() .build(); // Throws a ParseException. MyBean bean = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableIgnoreTransientFields

      public HtmlDocSerializer.Builder 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 String foo = "foo"; } // Create a serializer that doesn't ignore transient fields. WriterSerializer serializer = JsonSerializer .create() .disableIgnoreTransientFields() .build(); // Produces: {"foo":"foo"} String json = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableIgnoreUnknownNullBeanProperties

      public HtmlDocSerializer.Builder 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 a BeanRuntimeException. Otherwise it will be silently ignored.

      Example:

      // A bean with a single property. public class MyBean { public String foo; } // Create a parser that throws an exception on an unknown property even if the value being set is null. ReaderParser parser = JsonParser .create() .disableIgnoreUnknownNullBeanProperties() .build(); // Throws a BeanRuntimeException wrapped in a ParseException on the unknown 'bar' property. MyBean bean = parser.parse("{foo:'foo',bar:null}", MyBean.class);

      See Also:
      Overrides:
      disableIgnoreUnknownNullBeanProperties in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableInterfaceProxies

      public HtmlDocSerializer.Builder 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 a BeanRuntimeException.

      See Also:
      Overrides:
      disableInterfaceProxies in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • example

      public <T> HtmlDocSerializer.Builder example(Class<T> pojoClass, T o)
      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. WriterSerializer serializer = 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:

      Overrides:
      example in class HtmlStrippedDocSerializer.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

      public <T> HtmlDocSerializer.Builder example(Class<T> pojoClass, String json)
      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. WriterSerializer serializer = 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 one BeanSession argument.
      • A static method with name example with no arguments or one BeanSession argument.
      See Also:
      Overrides:
      example in class HtmlStrippedDocSerializer.Builder
      Type Parameters:
      T - The POJO class type.
      Parameters:
      pojoClass - The POJO class.
      json - The JSON 5 representation of the example.
      Returns:
      This object.

    • findFluentSetters

      public HtmlDocSerializer.Builder 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(String value) {...} } // Create a parser that finds fluent setters. ReaderParser parser = JsonParser .create() .findFluentSetters() .build(); // Parse into bean using fluent setter. MyBean bean = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • findFluentSetters

      public HtmlDocSerializer.Builder findFluentSetters(Class<?> on)
      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(String value) {...} } // Create a parser that finds fluent setters. ReaderParser parser = JsonParser .create() .findFluentSetters(MyBean.class) .build(); // Parse into bean using fluent setter. MyBean bean = parser.parse("{foo:'bar'}", MyBean.class);

      Notes:
      See Also:
      Overrides:
      findFluentSetters in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The class that this applies to.
      Returns:
      This object.

    • ignoreInvocationExceptionsOnGetters

      public HtmlDocSerializer.Builder 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. WriterSerializer serializer = JsonSerializer .create() .ingoreInvocationExceptionsOnGetters() .build(); // Exception is ignored. String json = serializer.serialize(new MyBean());

      See Also:
      Overrides:
      ignoreInvocationExceptionsOnGetters in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • ignoreInvocationExceptionsOnSetters

      public HtmlDocSerializer.Builder 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(String foo) { throw new RuntimeException("foo"); } } // Create a parser that ignores bean setter exceptions. ReaderParser parser = JsonParser .create() .ignoreInvocationExceptionsOnSetters() .build(); // Exception is ignored. MyBean bean = parser.parse("{foo:'bar'}", MyBean.class);

      See Also:
      Overrides:
      ignoreInvocationExceptionsOnSetters in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • ignoreUnknownBeanProperties

      public HtmlDocSerializer.Builder 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 String foo; } // Create a parser that ignores missing bean properties. ReaderParser parser = JsonParser .create() .ignoreUnknownBeanProperties() .build(); // Doesn't throw an exception on unknown 'bar' property. MyBean bean = parser.parse("{foo:'foo',bar:'bar'}", MyBean.class);

      See Also:
      Overrides:
      ignoreUnknownBeanProperties in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • ignoreUnknownEnumValues

      public HtmlDocSerializer.Builder 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • implClass

      public HtmlDocSerializer.Builder implClass(Class<?> interfaceClass, Class<?> 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 MyBeanImpl implements MyBean { ... } // Create a parser that instantiates MyBeanImpls when parsing MyBeans. ReaderParser parser = JsonParser .create() .implClass(MyBean.class, MyBeanImpl.class) .build(); // Instantiates a MyBeanImpl, MyBean bean = parser.parse("...", MyBean.class);

      Overrides:
      implClass in class HtmlStrippedDocSerializer.Builder
      Parameters:
      interfaceClass - The interface class.
      implClass - The implementation class.
      Returns:
      This object.

    • implClasses

      public HtmlDocSerializer.Builder implClasses(Map<Class<?>,Class<?>> values)
      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 MyBeanImpl implements MyBean { ... } // Create a parser that instantiates MyBeanImpls when parsing MyBeans. ReaderParser parser = JsonParser .create() .implClasses(AMap.of(MyBean.class, MyBeanImpl.class)) .build(); // Instantiates a MyBeanImpl, MyBean bean = parser.parse("...", MyBean.class);

      Overrides:
      implClasses in class HtmlStrippedDocSerializer.Builder
      Parameters:
      values - The new value for this setting.
      Returns:
      This object.

    • interfaceClass

      public HtmlDocSerializer.Builder interfaceClass(Class<?> on, Class<?> value)
      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 String foo = "foo"; } // Sub class public class A1 extends A { public String bar = "bar"; } // Create a serializer and define our interface class mapping. WriterSerializer serializer = JsonSerializer .create() .interfaceClass(A1.class, A.class) .build(); // Produces "{"foo":"foo"}" String json = 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:
      Overrides:
      interfaceClass in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The class that the interface class applies to.
      value - The new value for this setting.
      Returns:
      This object.

    • interfaces

      public HtmlDocSerializer.Builder interfaces(Class<?>... value)
      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 String foo = "foo"; } // Sub class public class A1 extends A { public String bar = "bar"; } // Create a serializer and define our interface class mapping. WriterSerializer serializer = JsonSerializer .create() .interfaces(A.class) .build(); // Produces "{"foo":"foo"}" String json = 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:
      Overrides:
      interfaces in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      Returns:
      This object.

    • locale

      public HtmlDocSerializer.Builder locale(Locale value)
      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 convert Date and Calendar objects to strings by accessing it via the session passed into the ObjectSwap.swap(BeanSession, Object) and ObjectSwap.unswap(BeanSession, Object, ClassMeta, String) methods.

      Example:

      // Define a POJO swap that skips serializing beans if we're in the UK. public class MyBeanSwap extends StringSwap<MyBean> { @Override public String swap(BeanSession session, MyBean bean) 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. WriterSerializer serializer = JsonSerializer .create() .locale(Locale.UK) .swaps(MyBeanSwap.class) .build();

      See Also:
      Overrides:
      locale in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • mediaType

      public HtmlDocSerializer.Builder mediaType(MediaType value)
      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 MyBeanSwap extends StringSwap<MyBean> { @Override public String swap(BeanSession session, MyBean bean) 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. WriterSerializer serializer = JsonSerializer .create() .mediaType(MediaType.JSON) .build();

      See Also:
      Overrides:
      mediaType in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • notBeanClasses

      public HtmlDocSerializer.Builder notBeanClasses(Class<?>... values)
      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 String foo = "bar"; public String toString() { return "baz"; } } // Create a serializer that doesn't treat MyBean as a bean class. WriterSerializer serializer = JsonSerializer .create() .notBeanClasses(MyBean.class) .build(); // Produces "baz" instead of {"foo":"bar"} String json = 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 class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder notBeanPackages(String... values)
      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 using Object.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. WriterSerializer serializer = JsonSerializer .create() .notBeanPackages("org.apache.foo", "org.apache.bar.*") .build();

      See Also:
      Overrides:
      notBeanPackages in class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder propertyNamer(Class<? extends PropertyNamer> value)
      Description copied from class: BeanContextable.Builder
      Bean property namer

      The class to use for calculating bean property names.

      Predefined classes:

      Example:

      // A bean with a single property. public class MyBean { public String fooBarBaz = "fooBarBaz"; } // Create a serializer that uses Dashed-Lower-Case property names. // (e.g. "foo-bar-baz" instead of "fooBarBaz") WriterSerializer serializer = JsonSerializer .create() .propertyNamer(PropertyNamerDLC.class) .build(); // Produces: {"foo-bar-baz":"fooBarBaz"} String json = serializer.serialize(new MyBean());

      See Also:
      Overrides:
      propertyNamer in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is BasicPropertyNamer.
      Returns:
      This object.

    • propertyNamer

      public HtmlDocSerializer.Builder propertyNamer(Class<?> on, Class<? extends PropertyNamer> value)
      Description copied from class: BeanContextable.Builder
      Bean property namer

      Same 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 String fooBarBaz = "fooBarBaz"; } // Create a serializer that uses Dashed-Lower-Case property names for the MyBean class only. // (e.g. "foo-bar-baz" instead of "fooBarBaz") WriterSerializer serializer = JsonSerializer .create() .propertyNamer(MyBean.class, PropertyNamerDLC.class) .build(); // Produces: {"foo-bar-baz":"fooBarBaz"} String json = serializer.serialize(new MyBean());

      See Also:
      Overrides:
      propertyNamer in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The class that the namer applies to.
      value - The new value for this setting.
      The default is BasicPropertyNamer.
      Returns:
      This object.

    • sortProperties

      public HtmlDocSerializer.Builder 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 String c = "1"; public String b = "2"; public String a = "3"; } // Create a serializer that sorts bean properties. WriterSerializer serializer = JsonSerializer .create() .sortProperties() .build(); // Produces: {"a":"3","b":"2","c":"1"} String json = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • sortProperties

      public HtmlDocSerializer.Builder sortProperties(Class<?>... on)
      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 String c = "1"; public String b = "2"; public String a = "3"; } // Create a serializer that sorts properties on MyBean. WriterSerializer serializer = JsonSerializer .create() .sortProperties(MyBean.class) .build(); // Produces: {"a":"3","b":"2","c":"1"} String json = serializer.serialize(new MyBean());

      See Also:
      Overrides:
      sortProperties in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The bean classes to sort properties on.
      Returns:
      This object.

    • stopClass

      public HtmlDocSerializer.Builder stopClass(Class<?> on, Class<?> value)
      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 property p3, but not p1 or p2.

      Example:

      public class C1 { public int getP1(); } public class C2 extends C1 { public int getP2(); } public class C3 extends C2 { public int getP3(); } // Create a serializer specifies a stop class for C3. WriterSerializer serializer = JsonSerializer .create() .stopClass(C3.class, C2.class) .build(); // Produces: {"p3":"..."} String json = serializer.serialize(new C3());

      Overrides:
      stopClass in class HtmlStrippedDocSerializer.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> HtmlDocSerializer.Builder swap(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T,S> swapFunction)
      Description copied from class: BeanContextable.Builder
      A shortcut for defining a FunctionalSwap.
      Example:

      // Create a serializer that performs a custom format for Date objects. WriterSerializer serializer = JsonSerializer .create() .swap(Date.class, String.class, x -> format(x)) .build();

      Overrides:
      swap in class HtmlStrippedDocSerializer.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> HtmlDocSerializer.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 a FunctionalSwap.
      Example:

      // Create a serializer that performs a custom format for Date objects. WriterSerializer serializer = JsonSerializer .create() .swap(Date.class, String.class, x -> format(x), x -> parse(x)) .build();

      Overrides:
      swap in class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder swaps(Class<?>... values)
      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 MyDateSwap extends StringSwap<Date> { // ISO8601 formatter. private DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ"); @Override public String swap(BeanSession session, Date date) { return format.format(date); } @Override public Date unswap(BeanSession session, String string, ClassMeta hint) throws Exception { return format.parse(string); } } // Sample bean with a Date field. public class MyBean { public Date date = new Date(112, 2, 3, 4, 5, 6); } // Create a serializer that uses our date swap. WriterSerializer serializer = JsonSerializer .create() .swaps(MyDateSwap.class) .build(); // Produces: {"date":"2012-03-03T04:05:06-0500"} String json = serializer.serialize(new MyBean()); // Create a serializer that uses our date swap. ReaderParser parser = JsonParser .create() .swaps(MyDateSwap.class) .build(); // Use our parser to parse a bean. MyBean bean = 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 class HtmlStrippedDocSerializer.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.
      Returns:
      This object.

    • timeZone

      public HtmlDocSerializer.Builder timeZone(TimeZone value)
      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 convert Date and Calendar objects to strings by accessing it via the session passed into the ObjectSwap.swap(BeanSession, Object) and ObjectSwap.unswap(BeanSession, Object, ClassMeta, String) methods.

      Example:

      // Define a POJO swap that skips serializing beans if the time zone is GMT. public class MyBeanSwap extends StringSwap<MyBean> { @Override public String swap(BeanSession session, MyBean bean) 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. WriterSerializer serializer = JsonSerializer .create() .timeZone(TimeZone.GMT) .build();

      See Also:
      Overrides:
      timeZone in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • typeName

      public HtmlDocSerializer.Builder typeName(Class<?> on, String value)
      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.. WriterSerializer serializer = JsonSerializer .create() .typeName(MyBean.class, "mybean") .build(); // Produces: {"_type":"mybean",...} String json = serializer.serialize(new MyBean());

      Notes:
      See Also:
      Overrides:
      typeName in class HtmlStrippedDocSerializer.Builder
      Parameters:
      on - The class the type name is being defined on.
      value - The new value for this setting.
      Returns:
      This object.

    • typePropertyName

      public HtmlDocSerializer.Builder typePropertyName(String value)
      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. WriterSerializer serializer = JsonSerializer .create() .typePropertyName("t") .dictionary(Foo.class, Bar.class) .build(); // Create a serializer that uses 't' instead of '_type' for dictionary names. ReaderParser parser = JsonParser .create() .typePropertyName("t") .dictionary(Foo.class, Bar.class) .build(); // A bean with a field with an indeterminate type. public class MyBean { public Object mySimpleField; } // Produces "{mySimpleField:{t:'foo',...}}". String json = serializer.serialize(new MyBean()); // Parse bean. MyBean bean = parser.parse(json, MyBean.class);

      See Also:
      Overrides:
      typePropertyName in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is "_type".
      Returns:
      This object.

    • typePropertyName

      public HtmlDocSerializer.Builder typePropertyName(Class<?> on, String value)
      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 Object mySimpleField; } // Create a serializer that uses 't' instead of '_type' for dictionary names. WriterSerializer serializer = JsonSerializer .create() .typePropertyName(MyBean.class, "t") .dictionary(Foo.class, Bar.class) .build(); // Produces "{mySimpleField:{t:'foo',...}}". String json = serializer.serialize(new MyBean());

      See Also:
      Overrides:
      typePropertyName in class HtmlStrippedDocSerializer.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

      public HtmlDocSerializer.Builder 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. WriterSerializer serializer = 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 class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • useJavaBeanIntrospector

      public HtmlDocSerializer.Builder 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. WriterSerializer serializer = JsonSerializer .create() .useJavaBeanIntrospector() .build();

      See Also:
      Overrides:
      useJavaBeanIntrospector in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • detectRecursions

      public HtmlDocSerializer.Builder detectRecursions()
      Description copied from class: BeanTraverseContext.Builder
      Automatically detect POJO recursions.

      When enabled, specifies that recursions should be checked for during traversal.

      Recursions can occur when traversing models that aren't true trees but rather contain loops.
      In general, unchecked recursions cause stack-overflow-errors.
      These show up as BeanRecursionException with the message "Depth too deep. Stack overflow occurred.".

      Notes:
      • Checking for recursion can cause a small performance penalty.
      Example:

      // Create a serializer that automatically checks for recursions. WriterSerializer serializer = JsonSerializer .create() .detectRecursions() .build(); // Create a POJO model with a recursive loop. public class MyBean { public Object f; } MyBean bean = new MyBean(); bean.f = bean; // Throws a SerializeException and not a StackOverflowError String json = serializer.serialize(bean);

      Overrides:
      detectRecursions in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • detectRecursions

      public HtmlDocSerializer.Builder detectRecursions(boolean value)
      Description copied from class: BeanTraverseContext.Builder
      Same as BeanTraverseContext.Builder.detectRecursions() but allows you to explicitly specify the value.
      Overrides:
      detectRecursions in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • ignoreRecursions

      public HtmlDocSerializer.Builder ignoreRecursions()
      Description copied from class: BeanTraverseContext.Builder
      Ignore recursion errors.

      When enabled, when we encounter the same object when traversing a tree, we set the value to null.

      For example, if a model contains the links A->B->C->A, then the JSON generated will look like the following when this setting is true...

      {A:{B:{C:null}}}

      Notes:
      • Checking for recursion can cause a small performance penalty.
      Example:

      // Create a serializer ignores recursions. WriterSerializer serializer = JsonSerializer .create() .ignoreRecursions() .build(); // Create a POJO model with a recursive loop. public class MyBean { public Object f; } MyBean bean = new MyBean(); bean.f = bean; // Produces "{f:null}" String json = serializer.serialize(bean);

      Overrides:
      ignoreRecursions in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • ignoreRecursions

      public HtmlDocSerializer.Builder ignoreRecursions(boolean value)
      Description copied from class: BeanTraverseContext.Builder
      Same as BeanTraverseContext.Builder.ignoreRecursions() but allows you to explicitly specify the value.
      Overrides:
      ignoreRecursions in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • initialDepth

      public HtmlDocSerializer.Builder initialDepth(int value)
      Description copied from class: BeanTraverseContext.Builder
      Initial depth.

      The initial indentation level at the root.

      Useful when constructing document fragments that need to be indented at a certain level when whitespace is enabled.

      Example:

      // Create a serializer with whitespace enabled and an initial depth of 2. WriterSerializer serializer = JsonSerializer .create() .ws() .initialDepth(2) .build(); // Produces "\t\t{\n\t\t\t'foo':'bar'\n\t\t}\n" String json = serializer.serialize(new MyBean());

      Overrides:
      initialDepth in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is 0.
      Returns:
      This object.

    • maxDepth

      public HtmlDocSerializer.Builder maxDepth(int value)
      Description copied from class: BeanTraverseContext.Builder
      Max traversal depth.

      When enabled, abort traversal if specified depth is reached in the POJO tree.

      If this depth is exceeded, an exception is thrown.

      This prevents stack overflows from occurring when trying to traverse models with recursive references.

      Example:

      // Create a serializer that throws an exception if the depth reaches greater than 20. WriterSerializer serializer = JsonSerializer .create() .maxDepth(20) .build();

      See Also:
      Overrides:
      maxDepth in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this setting.
      The default is 100.
      Returns:
      This object.

    • accept

      public HtmlDocSerializer.Builder accept(String value)
      Description copied from class: Serializer.Builder
      Specifies the accept media types that the serializer can handle.

      Can contain meta-characters per the media-type specification of RFC2616/14.1

      If empty, then assumes the only media type supported is produces.

      For example, if this serializer produces "application/json" but should handle media types of "application/json" and "text/json", then the arguments should be:

      builder.produces("application/json"); builder.accept("application/json,text/json");

      The accept value can also contain q-values.

      Overrides:
      accept in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • addBeanTypes

      public HtmlDocSerializer.Builder addBeanTypes()
      Description copied from class: Serializer.Builder
      Add "_type" properties when needed.

      When enabled, "_type" properties will be added to beans if their type cannot be inferred through reflection.

      This is used to recreate the correct objects during parsing if the object types cannot be inferred.
      For example, when serializing a Map<String,Object> field where the bean class cannot be determined from the type of the values.

      Note the differences between the following settings:

      Example:

      // Create a serializer that adds _type to nodes. WriterSerializer serializer = JsonSerializer .create() .addBeanTypes() .build(); // Our map of beans to serialize. @Bean(typeName="mybean") public class MyBean { public String foo = "bar"; } JsonMap myMap = JsonMap.of("foo", new MyBean()); // Will contain: {"foo":{"_type":"mybean","foo":"bar"}} String json = serializer.serialize(myMap);

      Overrides:
      addBeanTypes in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addBeanTypes

      public HtmlDocSerializer.Builder addBeanTypes(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.addBeanTypes() but allows you to explicitly specify the value.
      Overrides:
      addBeanTypes in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • addRootType

      public HtmlDocSerializer.Builder addRootType()
      Description copied from class: Serializer.Builder
      Add type attribute to root nodes.

      When enabled, "_type" properties will be added to top-level beans.

      When disabled, it is assumed that the parser knows the exact Java POJO type being parsed, and therefore top-level type information that might normally be included to determine the data type will not be serialized.

      For example, when serializing a top-level POJO with a @Bean(typeName) value, a '_type' attribute will only be added when this setting is enabled.

      Note the differences between the following settings:

      Example:

      // Create a serializer that adds _type to root node. WriterSerializer serializer= JsonSerializer .create() .addRootType() .build(); // Our bean to serialize. @Bean(typeName="mybean") public class MyBean { public String foo = "bar"; } // Will contain: {"_type":"mybean","foo":"bar"} String json = serializer.serialize(new MyBean());

      Overrides:
      addRootType in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addRootType

      public HtmlDocSerializer.Builder addRootType(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.addRootType() but allows you to explicitly specify the value.
      Overrides:
      addRootType in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • keepNullProperties

      public HtmlDocSerializer.Builder keepNullProperties()
      Description copied from class: Serializer.Builder
      Don't trim null bean property values.

      When enabled, null bean values will be serialized to the output.

      Notes:
      • Not enabling this setting will cause Maps with null values to be lost during parsing.
      Example:

      // Create a serializer that serializes null properties. WriterSerializer serializer = JsonSerializer .create() .keepNullProperties() .build(); // Our bean to serialize. public class MyBean { public String foo = null; } // Will contain "{foo:null}". String json = serializer.serialize(new MyBean());

      Overrides:
      keepNullProperties in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • keepNullProperties

      public HtmlDocSerializer.Builder keepNullProperties(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.keepNullProperties() but allows you to explicitly specify the value.
      Overrides:
      keepNullProperties in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • listener

      public HtmlDocSerializer.Builder listener(Class<? extends SerializerListener> value)
      Description copied from class: Serializer.Builder
      Serializer listener.

      Class used to listen for errors and warnings that occur during serialization.

      Example:

      // Define our serializer listener. // Simply captures all errors. public class MySerializerListener extends SerializerListener { // A simple property to store our events. public List<String> events = new LinkedList<>(); @Override public <T> void onError(SerializerSession session, Throwable throwable, String msg) { events.add(session.getLastLocation() + "," + msg + "," + throwable); } } // Create a serializer using our listener. WriterSerializer serializer = JsonSerializer .create() .listener(MySerializerListener.class) .build(); // Create a session object. // Needed because listeners are created per-session. try (WriterSerializerSession session = serializer.createSession()) { // Serialize a bean. String json = session.serialize(new MyBean()); // Get the listener. MySerializerListener listener = session.getListener(MySerializerListener.class); // Dump the results to the console. Json5.DEFAULT.println(listener.events); }

      Overrides:
      listener in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • produces

      public HtmlDocSerializer.Builder produces(String value)
      Description copied from class: Serializer.Builder
      Specifies the media type that this serializer produces.
      Overrides:
      produces in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • sortCollections

      public HtmlDocSerializer.Builder sortCollections()
      Description copied from class: Serializer.Builder
      Sort arrays and collections alphabetically.

      When enabled, copies and sorts the contents of arrays and collections before serializing them.

      Note that this introduces a performance penalty since it requires copying the existing collection.

      Example:

      // Create a serializer that sorts arrays and collections before serialization. WriterSerializer serializer = JsonSerializer .create() .sortCollections() .build(); // An unsorted array String[] myArray = {"foo","bar","baz"}; // Produces ["bar","baz","foo"] String json = serializer.serialize(myArray);

      Overrides:
      sortCollections in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • sortCollections

      public HtmlDocSerializer.Builder sortCollections(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.sortCollections() but allows you to explicitly specify the value.
      Overrides:
      sortCollections in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • sortMaps

      public HtmlDocSerializer.Builder sortMaps()
      Description copied from class: Serializer.Builder
      Sort maps alphabetically.

      When enabled, copies and sorts the contents of maps by their keys before serializing them.

      Note that this introduces a performance penalty.

      Example:

      // Create a serializer that sorts maps before serialization. WriterSerializer serializer = JsonSerializer .create() .sortMaps() .build(); // An unsorted map. JsonMap myMap = JsonMap.of("foo",1,"bar",2,"baz",3); // Produces {"bar":2,"baz":3,"foo":1} String json = serializer.serialize(myMap);

      Overrides:
      sortMaps in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • sortMaps

      public HtmlDocSerializer.Builder sortMaps(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.sortMaps() but allows you to explicitly specify the value.
      Overrides:
      sortMaps in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • trimEmptyCollections

      public HtmlDocSerializer.Builder trimEmptyCollections()
      Description copied from class: Serializer.Builder
      Trim empty lists and arrays.

      When enabled, empty lists and arrays will not be serialized.

      Note that enabling this setting has the following effects on parsing:

      • Map entries with empty list values will be lost.
      • Bean properties with empty list values will not be set.
      Example:

      // Create a serializer that skips empty arrays and collections. WriterSerializer serializer = JsonSerializer .create() .trimEmptyCollections() .build(); // A bean with a field with an empty array. public class MyBean { public String[] foo = {}; } // Produces {} String json = serializer.serialize(new MyBean());

      Overrides:
      trimEmptyCollections in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • trimEmptyCollections

      public HtmlDocSerializer.Builder trimEmptyCollections(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.trimEmptyCollections() but allows you to explicitly specify the value.
      Overrides:
      trimEmptyCollections in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • trimEmptyMaps

      public HtmlDocSerializer.Builder trimEmptyMaps()
      Description copied from class: Serializer.Builder
      Trim empty maps.

      When enabled, empty map values will not be serialized to the output.

      Note that enabling this setting has the following effects on parsing:

      • Bean properties with empty map values will not be set.
      Example:

      // Create a serializer that skips empty maps. WriterSerializer serializer = JsonSerializer .create() .trimEmptyMaps() .build(); // A bean with a field with an empty map. public class MyBean { public JsonMap foo = JsonMap.of(); } // Produces {} String json = serializer.serialize(new MyBean());

      Overrides:
      trimEmptyMaps in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • trimEmptyMaps

      public HtmlDocSerializer.Builder trimEmptyMaps(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.trimEmptyMaps() but allows you to explicitly specify the value.
      Overrides:
      trimEmptyMaps in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • trimStrings

      public HtmlDocSerializer.Builder trimStrings()
      Description copied from class: Serializer.Builder
      Trim strings.

      When enabled, string values will be trimmed of whitespace using String.trim() before being serialized.

      Example:

      // Create a serializer that trims strings before serialization. WriterSerializer serializer = JsonSerializer .create() .trimStrings() .build(); // A map with space-padded keys/values JsonMap myMap = JsonMap.of(" foo ", " bar "); // Produces "{foo:'bar'}" String json = serializer.toString(myMap);

      Overrides:
      trimStrings in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • trimStrings

      public HtmlDocSerializer.Builder trimStrings(boolean value)
      Description copied from class: Serializer.Builder
      Same as Serializer.Builder.trimStrings() but allows you to explicitly specify the value.
      Overrides:
      trimStrings in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • uriContext

      public HtmlDocSerializer.Builder uriContext(UriContext value)
      Description copied from class: Serializer.Builder
      URI context bean.

      Bean used for resolution of URIs to absolute or root-relative form.

      Example:

      // Our URI contextual information. String authority = "http://localhost:10000"; String contextRoot = "/myContext"; String servletPath = "/myServlet"; String pathInfo = "/foo"; // Create a UriContext object. UriContext uriContext = new UriContext(authority, contextRoot, servletPath, pathInfo); // Associate it with our serializer. WriterSerializer serializer = JsonSerializer .create() .uriContext(uriContext) .uriRelativity(RESOURCE) // Assume relative paths are relative to servlet. .uriResolution(ABSOLUTE) // Serialize URLs as absolute paths. .build(); // A relative URL URL myUrl = new URL("bar"); // Produces "http://localhost:10000/myContext/myServlet/foo/bar" String json = serializer.toString(myUrl);

      See Also:
      Overrides:
      uriContext in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      Returns:
      This object.

    • uriRelativity

      public HtmlDocSerializer.Builder uriRelativity(UriRelativity value)
      Description copied from class: Serializer.Builder
      URI relativity.

      Defines what relative URIs are relative to when serializing any of the following:

      • URI
      • URL
      • Properties and classes annotated with @Uri

      See Serializer.Builder.uriContext(UriContext) for examples.

      See Also:
      Overrides:
      uriRelativity in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is UriRelativity.RESOURCE
      Returns:
      This object.

    • uriResolution

      public HtmlDocSerializer.Builder uriResolution(UriResolution value)
      Description copied from class: Serializer.Builder
      URI resolution.

      Defines the resolution level for URIs when serializing any of the following:

      • URI
      • URL
      • Properties and classes annotated with @Uri

      See Serializer.Builder.uriContext(UriContext) for examples.

      See Also:
      Overrides:
      uriResolution in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is UriResolution.NONE
      Returns:
      This object.

    • fileCharset

      public HtmlDocSerializer.Builder fileCharset(Charset value)
      Description copied from class: WriterSerializer.Builder
      File charset.

      The character set to use for writing Files to the file system.

      Used when passing in files to Serializer.serialize(Object, Object).

      Example:

      // Create a serializer that writes UTF-8 files. WriterSerializer serializer = JsonSerializer .create() .fileCharset(Charset.forName("UTF-8")) .build(); // Use it to read a UTF-8 encoded file. serializer.serialize(new File("MyBean.txt"), myBean);

      Overrides:
      fileCharset in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is the system JVM setting.
      Returns:
      This object.

    • maxIndent

      public HtmlDocSerializer.Builder maxIndent(int value)
      Description copied from class: WriterSerializer.Builder
      Maximum indentation.

      Specifies the maximum indentation level in the serialized document.

      Notes:
      • This setting does not apply to the RDF serializers.
      Example:

      // Create a serializer that indents a maximum of 20 tabs. WriterSerializer serializer = JsonSerializer .create() .ws() // Enable whitespace .maxIndent(20) .build();

      Overrides:
      maxIndent in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is 100.
      Returns:
      This object.

    • quoteChar

      public HtmlDocSerializer.Builder quoteChar(char value)
      Description copied from class: WriterSerializer.Builder
      Quote character.

      Specifies the character to use for quoting attributes and values.

      Notes:
      • This setting does not apply to the RDF serializers.
      Example:

      // Create a serializer that uses single quotes. WriterSerializer serializer = JsonSerializer .create() .quoteChar('\'') .build(); // A bean with a single property public class MyBean { public String foo = "bar"; } // Produces {'foo':'bar'} String json = serializer.toString(new MyBean());

      Overrides:
      quoteChar in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is '"'.
      Returns:
      This object.

    • quoteCharOverride

      public HtmlDocSerializer.Builder quoteCharOverride(char value)
      Description copied from class: WriterSerializer.Builder
      Quote character override.

      Similar to WriterSerializer.Builder.quoteChar(char) but takes precedence over that setting.

      Allows you to override the quote character even if it's set by a subclass such as Json5Serializer.

      Overrides:
      quoteCharOverride in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is null.
      Returns:
      This object.

    • sq

      public HtmlDocSerializer.Builder sq()
      Description copied from class: WriterSerializer.Builder
      Quote character.

      Specifies to use single quotes for quoting attributes and values.

      Notes:
      • This setting does not apply to the RDF serializers.
      Example:

      // Create a serializer that uses single quotes. WriterSerializer serializer = JsonSerializer .create() .sq() .build(); // A bean with a single property public class MyBean { public String foo = "bar"; } // Produces {'foo':'bar'} String json = serializer.toString(new MyBean());

      Overrides:
      sq in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • streamCharset

      public HtmlDocSerializer.Builder streamCharset(Charset value)
      Description copied from class: WriterSerializer.Builder
      Output stream charset.

      The character set to use when writing to OutputStreams.

      Used when passing in output streams and byte arrays to Serializer.serialize(Object, Object).

      Example:

      // Create a serializer that writes UTF-8 files. WriterSerializer serializer = JsonSerializer .create() .streamCharset(Charset.forName("UTF-8")) .build(); // Use it to write to a UTF-8 encoded output stream. serializer.serializer(new FileOutputStreamStream("MyBean.txt"), myBean);

      Overrides:
      streamCharset in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is the system JVM setting.
      Returns:
      This object.

    • useWhitespace

      public HtmlDocSerializer.Builder useWhitespace()
      Description copied from class: WriterSerializer.Builder
      Use whitespace.

      When enabled, whitespace is added to the output to improve readability.

      Example:

      // Create a serializer with whitespace enabled. WriterSerializer serializer = JsonSerializer .create() .useWhitespace() .build(); // A bean with a single property public class MyBean { public String foo = "bar"; } // Produces "\{\n\t"foo": "bar"\n\}\n" String json = serializer.serialize(new MyBean());

      Overrides:
      useWhitespace in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • useWhitespace

      public HtmlDocSerializer.Builder useWhitespace(boolean value)
      Description copied from class: WriterSerializer.Builder
      Same as WriterSerializer.Builder.useWhitespace() but allows you to explicitly specify the value.
      Overrides:
      useWhitespace in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • ws

      public HtmlDocSerializer.Builder ws()
      Description copied from class: WriterSerializer.Builder
      Use whitespace.

      When enabled, whitespace is added to the output to improve readability.

      Example:

      // Create a serializer with whitespace enabled. WriterSerializer serializer = JsonSerializer .create() .ws() .build(); // A bean with a single property public class MyBean { public String foo = "bar"; } // Produces "\{\n\t"foo": "bar"\n\}\n" String json = serializer.serialize(new MyBean());

      Overrides:
      ws in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addBeanTypesXml

      public HtmlDocSerializer.Builder addBeanTypesXml()
      Description copied from class: XmlSerializer.Builder
      Add "_type" properties when needed.

      If true, then "_type" properties will be added to beans if their type cannot be inferred through reflection.

      When present, this value overrides the Serializer.Builder.addBeanTypes() setting and is provided to customize the behavior of specific serializers in a SerializerSet.

      Overrides:
      addBeanTypesXml in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addBeanTypesXml

      public HtmlDocSerializer.Builder addBeanTypesXml(boolean value)
      Description copied from class: XmlSerializer.Builder
      Same as XmlSerializer.Builder.addBeanTypesXml() but allows you to explicitly specify the value.
      Overrides:
      addBeanTypesXml in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • addNamespaceUrisToRoot

      public HtmlDocSerializer.Builder addNamespaceUrisToRoot()
      Description copied from class: XmlSerializer.Builder
      Add namespace URLs to the root element.

      Use this setting to add xmlns:x attributes to the root element for the default and all mapped namespaces.

      This setting is ignored if XmlSerializer.Builder.enableNamespaces() is not enabled.

      See Also:
      Overrides:
      addNamespaceUrisToRoot in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addNamespaceUrisToRoot

      public HtmlDocSerializer.Builder addNamespaceUrisToRoot(boolean value)
      Description copied from class: XmlSerializer.Builder
      Same as XmlSerializer.Builder.addNamespaceUrisToRoot() but allows you to explicitly specify the value.
      Overrides:
      addNamespaceUrisToRoot in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • defaultNamespace

      public HtmlDocSerializer.Builder defaultNamespace(Namespace value)
      Description copied from class: XmlSerializer.Builder
      Default namespace.

      Specifies the default namespace URI for this document.

      See Also:
      Overrides:
      defaultNamespace in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is "juneau: http://www.apache.org/2013/Juneau".
      Returns:
      This object.

    • disableAutoDetectNamespaces

      public HtmlDocSerializer.Builder disableAutoDetectNamespaces()
      Description copied from class: XmlSerializer.Builder
      Don't auto-detect namespace usage.

      Don't detect namespace usage before serialization.

      Used in conjunction with XmlSerializer.Builder.addNamespaceUrisToRoot() to reduce the list of namespace URLs appended to the root element to only those that will be used in the resulting document.

      If disabled, then the data structure will first be crawled looking for namespaces that will be encountered before the root element is serialized.

      This setting is ignored if XmlSerializer.Builder.enableNamespaces() is not enabled.

      Notes:
      • Auto-detection of namespaces can be costly performance-wise.
        In high-performance environments, it's recommended that namespace detection be disabled, and that namespaces be manually defined through the XmlSerializer.Builder.namespaces(Namespace...) property.
      See Also:
      Overrides:
      disableAutoDetectNamespaces in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableAutoDetectNamespaces

      public HtmlDocSerializer.Builder disableAutoDetectNamespaces(boolean value)
      Description copied from class: XmlSerializer.Builder
      Same as XmlSerializer.Builder.disableAutoDetectNamespaces() but allows you to explicitly specify the value.
      Overrides:
      disableAutoDetectNamespaces in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • enableNamespaces

      public HtmlDocSerializer.Builder enableNamespaces()
      Description copied from class: XmlSerializer.Builder
      Enable support for XML namespaces.

      If not enabled, XML output will not contain any namespaces regardless of any other settings.

      See Also:
      Overrides:
      enableNamespaces in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • enableNamespaces

      public HtmlDocSerializer.Builder enableNamespaces(boolean value)
      Description copied from class: XmlSerializer.Builder
      Same as XmlSerializer.Builder.enableNamespaces() but allows you to explicitly specify the value.
      Overrides:
      enableNamespaces in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • namespaces

      public HtmlDocSerializer.Builder namespaces(Namespace... values)
      Description copied from class: XmlSerializer.Builder
      Default namespaces.

      The default list of namespaces associated with this serializer.

      Overrides:
      namespaces in class HtmlStrippedDocSerializer.Builder
      Parameters:
      values - The new value for this property.
      Returns:
      This object.

    • ns

      public HtmlDocSerializer.Builder ns()
      Description copied from class: XmlSerializer.Builder
      Enable support for XML namespaces.

      Shortcut for calling enableNamespaces(true).

      Overrides:
      ns in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addBeanTypesHtml

      public HtmlDocSerializer.Builder addBeanTypesHtml()
      Description copied from class: HtmlSerializer.Builder
      Add "_type" properties when needed.

      If true, then "_type" properties will be added to beans if their type cannot be inferred through reflection.

      When present, this value overrides the Serializer.Builder.addBeanTypes() setting and is provided to customize the behavior of specific serializers in a SerializerSet.

      Overrides:
      addBeanTypesHtml in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addBeanTypesHtml

      public HtmlDocSerializer.Builder addBeanTypesHtml(boolean value)
      Description copied from class: HtmlSerializer.Builder
      Same as HtmlSerializer.Builder.addBeanTypesHtml() but allows you to explicitly specify the value.
      Overrides:
      addBeanTypesHtml in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • addKeyValueTableHeaders

      public HtmlDocSerializer.Builder addKeyValueTableHeaders()
      Description copied from class: HtmlSerializer.Builder
      HtmlSerializer configuration property:  Add key/value headers on bean/map tables.

      When enabled, key and value column headers are added to tables.

      Example:

      // Our bean class. public class MyBean { public String f1 = "foo"; public String f2 = "bar"; } // Serializer without headers. WriterSerializer serializer1 = HtmlSerializer.DEFAULT; // Serializer with headers. WriterSerializer serializer2 = HtmlSerializer .create() .addKeyValueTableHeaders() .build(); String withoutHeaders = serializer1.serialize(new MyBean()); String withHeaders = serializer2.serialize(new MyBean());

      The following shows the difference between the two generated outputs:

      withoutHeaders withHeaders
      f1foo
      f2bar
      keyvalue
      f1foo
      f2bar
      Overrides:
      addKeyValueTableHeaders in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • addKeyValueTableHeaders

      public HtmlDocSerializer.Builder addKeyValueTableHeaders(boolean value)
      Description copied from class: HtmlSerializer.Builder
      Same as HtmlSerializer.Builder.addKeyValueTableHeaders() but allows you to explicitly specify the value.
      Overrides:
      addKeyValueTableHeaders in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • disableDetectLabelParameters

      public HtmlDocSerializer.Builder disableDetectLabelParameters()
      Description copied from class: HtmlSerializer.Builder
      HtmlSerializer configuration property:  Dont look for link labels in URIs.

      Disables the feature where if the URL has a label parameter (e.g. "?label=foobar"), then use that as the anchor text of the link.

      The parameter name can be changed via the HtmlSerializer.Builder.labelParameter(String) property.

      Example:

      // Our bean class with a property containing what looks like a URL. public class MyBean { public URI f1 = URI.create("http://www.apache.org?label=Apache%20Foundation"); } // Serializer with label detection. WriterSerializer serializer1 = HtmlSerializer .create() .addKeyValueTableHeaders() .build(); // Serializer without label detection. WriterSerializer serializer2 = HtmlSerializer .create() .addKeyValueTableHeaders() .disableDetectLabelParameters() .build(); String withLabels = serializer1.serialize(new MyBean()); String withoutLabels = serializer2.serialize(new MyBean());

      The following shows the difference between the two generated outputs.
      Note that they're both hyperlinks, but the anchor text differs:

      withLabels withoutLabels
      keyvalue
      f1Apache Foundation
      keyvalue
      f1http://www.apache.org?label=Apache%20Foundation
      Overrides:
      disableDetectLabelParameters in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableDetectLabelParameters

      public HtmlDocSerializer.Builder disableDetectLabelParameters(boolean value)
      Description copied from class: HtmlSerializer.Builder
      Same as HtmlSerializer.Builder.disableDetectLabelParameters() but allows you to explicitly specify the value.
      Overrides:
      disableDetectLabelParameters in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • disableDetectLinksInStrings

      public HtmlDocSerializer.Builder disableDetectLinksInStrings()
      Description copied from class: HtmlSerializer.Builder
      HtmlSerializer configuration property:  Don't look for URLs in Strings.

      Disables the feature where if a string looks like a URL (i.e. starts with "http://" or "https://", then treat it like a URL and make it into a hyperlink based on the rules specified by HtmlSerializer.Builder.uriAnchorText(AnchorText).

      Example:

      // Our bean class with a property containing what looks like a URL. public class MyBean { public String f1 = "http://www.apache.org"; } // Serializer with link detection. WriterSerializer serializer1 = HtmlSerializer .create() .addKeyValueTableHeaders() .build(); // Serializer without link detection. WriterSerializer serializer2 = HtmlSerializer .create() .addKeyValueTableHeaders() .disableDetectLinksInStrings() .build(); String withLinks = serializer1.serialize(new MyBean()); String withoutLinks = serializer2.serialize(new MyBean());

      The following shows the difference between the two generated outputs:

      withLinks withoutLinks
      keyvalue
      f1http://www.apache.org
      keyvalue
      f1http://www.apache.org
      Overrides:
      disableDetectLinksInStrings in class HtmlStrippedDocSerializer.Builder
      Returns:
      This object.

    • disableDetectLinksInStrings

      public HtmlDocSerializer.Builder disableDetectLinksInStrings(boolean value)
      Description copied from class: HtmlSerializer.Builder
      Same as HtmlSerializer.Builder.disableDetectLinksInStrings() but allows you to explicitly specify the value.
      Overrides:
      disableDetectLinksInStrings in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • labelParameter

      public HtmlDocSerializer.Builder labelParameter(String value)
      Description copied from class: HtmlSerializer.Builder
      HtmlSerializer configuration property:  Link label parameter name.

      The parameter name to look for when resolving link labels}.

      Overrides:
      labelParameter in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is "label".
      Returns:
      This object.

    • uriAnchorText

      public HtmlDocSerializer.Builder uriAnchorText(AnchorText value)
      Description copied from class: HtmlSerializer.Builder
      HtmlSerializer configuration property:  Anchor text source.

      When creating anchor tags (e.g. <a href='...' >text</a>) in HTML, this setting defines what to set the inner text to.

      The possible values are:

      • AnchorText
        • TO_STRING (default) - Set to whatever is returned by Object.toString() on the object.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("http://www.apache.org?foo=bar#myAnchor"); } // Serializer with TO_STRING anchor text. WriterSerializer serializer1 = HtmlSerializer.create().anchorText(TO_STRING).build(); // Produces: <a href='http://www.apache.org?foo=bar#myAnchor'>http://www.apache.org?foo=bar#myAnchor</a> String html = serializer1.serialize(new MyBean());

        • PROPERTY_NAME - Set to the bean property name.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("http://www.apache.org?foo=bar#myAnchor"); } // Serializer with PROPERTY_NAME anchor text. WriterSerializer serializer1 = HtmlSerializer.create().anchorText(PROPERTY_NAME).build(); // Produces: <a href='http://www.apache.org?foo=bar#myAnchor'>f1</a> String html = serializer1.serialize(new MyBean());

        • URI - Set to the URI value.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("http://www.apache.org?foo=bar#myAnchor"); } // Serializer with URI anchor text. WriterSerializer serializer1 = HtmlSerializer.create().anchorText(URI).build(); // Produces: <a href='http://www.apache.org?foo=bar#myAnchor'>http://www.apache.org?foo=bar</a> String html = serializer1.serialize(new MyBean());

        • LAST_TOKEN - Set to the last token of the URI value.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("http://www.apache.org/foo/bar?baz=qux#myAnchor"); } // Serializer with LAST_TOKEN anchor text. WriterSerializer serializer1 = HtmlSerializer.create().anchorText(LAST_TOKEN).build(); // Produces: <a href='http://www.apache.org/foo/bar?baz=qux#myAnchor'>bar</a> String html = serializer1.serialize(new MyBean());

        • URI_ANCHOR - Set to the anchor of the URL.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("http://www.apache.org/foo/bar?baz=qux#myAnchor"); } // Serializer with URI_ANCHOR anchor text. WriterSerializer serializer1 = HtmlSerializer.create().anchorText(URI_ANCHOR).build(); // Produces: <a href='http://www.apache.org/foo/bar?baz=qux#myAnchor'>myAnchor</a> String html = serializer1.serialize(new MyBean());

        • CONTEXT_RELATIVE - Same as TO_STRING but assumes it's a context-relative path.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("bar/baz"); } // Serializer with CONTEXT_RELATIVE anchor text. WriterSerializer serializer1 = HtmlSerializer .create() .anchorText(CONTEXT_RELATIVE) .uriResolution(ROOT_RELATIVE) .uriRelativity(RESOURCE) .uriContext("{authority:'http://localhost:10000',contextRoot:'/myContext',servletPath:'/myServlet',pathInfo:'/foo'}") .build(); // Produces: <a href='/myContext/myServlet/bar/baz'>myServlet/bar/baz</a> String html = serializer1.serialize(new MyBean());

        • SERVLET_RELATIVE - Same as TO_STRING but assumes it's a servlet-relative path.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("bar/baz"); } // Serializer with SERVLET_RELATIVE anchor text. WriterSerializer serializer1 = HtmlSerializer .create() .anchorText(SERVLET_RELATIVE) .uriResolution(ROOT_RELATIVE) .uriRelativity(RESOURCE) .uriContext("{authority:'http://localhost:10000',contextRoot:'/myContext',servletPath:'/myServlet',pathInfo:'/foo'}") .build(); // Produces: <a href='/myContext/myServlet/bar/baz'>bar/baz</a> String html = serializer1.serialize(new MyBean());

        • PATH_RELATIVE - Same as TO_STRING but assumes it's a path-relative path.
          Example:

          // Our bean class with a URI property. public class MyBean { public URI f1 = URI.create("bar/baz"); } // Serializer with PATH_RELATIVE anchor text. WriterSerializer serializer1 = HtmlSerializer .create() .anchorText(PATH_RELATIVE) .uriResolution(ROOT_RELATIVE) .uriRelativity(PATH_INFO) .uriContext("{authority:'http://localhost:10000',contextRoot:'/myContext',servletPath:'/myServlet',pathInfo:'/foo'}") .build(); // Produces: <a href='/myContext/myServlet/foo/bar/baz'>bar/baz</a> String html = serializer1.serialize(new MyBean());

      Overrides:
      uriAnchorText in class HtmlStrippedDocSerializer.Builder
      Parameters:
      value - The new value for this property.
      The default is AnchorText.TO_STRING.
      Returns:
      This object.