Package org.apache.juneau

Class Context.Builder

java.lang.Object
org.apache.juneau.Context.Builder
Direct Known Subclasses:
BeanContext.Builder, BeanContextable.Builder, Config.Builder, ConfigStore.Builder, RestContext.Builder, RestOpContext.Builder
Enclosing class:
Context
public abstract static class Context.Builder extends Object
Builder class.

  • Constructor Details

    • Builder

      protected Builder()
      Constructor. Default settings.

    • Builder

      protected Builder(Context copyFrom)
      Copy constructor.
      Parameters:
      copyFrom - The bean to copy from.

    • Builder

      protected Builder(Context.Builder copyFrom)
      Copy constructor.
      Parameters:
      copyFrom - The builder to copy from.

  • Method Details

    • copy

      public abstract Context.Builder copy()
      Copy creator.
      Returns:
      A new mutable copy of this builder.

    • build

      public Context build()
      Build the object.
      Returns:
      The built object.

    • hashKey

      public HashKey hashKey()
      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.

      Returns:
      The hashkey of this builder.

    • cache

      public Context.Builder cache(Cache<HashKey,? extends Context> value)
      Specifies a cache to use for hashkey-based caching.
      Parameters:
      value - The cache.
      Returns:
      This object.

    • build

      public final <T extends Context> T build(Class<T> c)
      Convenience method for calling build() while avoiding a cast.
      Type Parameters:
      T - The type to cast the built object to.
      Parameters:
      c - The type to cast the built object to.
      Returns:
      The built context bean.

    • apply

      public <T extends Context.Builder> Context.Builder apply(Class<T> subtype, Consumer<T> consumer)
      Apply a consumer to this builder.
      Type Parameters:
      T - The builder subtype that this consumer can be applied to.
      Parameters:
      subtype - The builder subtype that this consumer can be applied to.
      consumer - The consumer.
      Returns:
      This object.

    • type

      public Context.Builder type(Class<? extends Context> value)
      Associates a context class with this builder.

      This is the type of object that this builder creates when the build() method is called.

      By default, it's the outer class of where the builder class is defined.

      Parameters:
      value - The context class that this builder should create.
      Returns:
      This object.

    • getType

      public Optional<Class<?>> getType()
      Returns the context class that this builder should create.
      Returns:
      The context class if it was specified.

    • impl

      public Context.Builder impl(Context value)
      Specifies a pre-instantiated bean for the build() method to return.
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • canApply

      public boolean canApply(AnnotationWorkList work)
      Returns true if any of the annotations/appliers can be applied to this builder.
      Parameters:
      work - The work to check.
      Returns:
      true if any of the annotations/appliers can be applied to this builder.

    • apply

      public Context.Builder apply(AnnotationWorkList work)
      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();

      Parameters:
      work - The list of annotations and appliers to apply to this builder.
      Returns:
      This object.

    • getApplied

      public AnnotationWorkList getApplied()
      Returns all the annotations that have been applied to this builder.
      Returns:
      All the annotations that have been applied to this builder.

    • registerBuilders

      protected void registerBuilders(Object... builders)
      Registers the specified secondary builders with this context builder.

      When apply(AnnotationWorkList) is called, it gets called on all registered builders.

      Parameters:
      builders - The builders to add to the list of builders.

    • applyAnnotations

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

      Parameters:
      fromClasses - The classes on which the annotations are defined.
      Returns:
      This object.

    • applyAnnotations

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

      Parameters:
      fromMethods - The methods on which the annotations are defined.
      Returns:
      This object.

    • annotations

      public Context.Builder annotations(Annotation... values)
      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:
      Parameters:
      values - The annotations to register with the context.
      Returns:
      This object.

    • debug

      public Context.Builder debug()
      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:
      Returns:
      This object.

    • debug

      public Context.Builder debug(boolean value)
      Same as debug() but allows you to explicitly specify the value.
      Parameters:
      value - The value for this setting.
      Returns:
      This object.

    • isDebug

      public boolean isDebug()
      Returns true if debug is enabled.
      Returns:
      true if debug is enabled.

    • env

      protected <T> T env(String name, T def)
      Looks up a system property or environment variable.

      First looks in system properties. Then converts the name to env-safe and looks in the system environment. Then returns the default if it can't be found.

      Type Parameters:
      T - The type to convert to.
      Parameters:
      name - The property name.
      def - The default value if not found.
      Returns:
      The default value.

    • env

      protected Optional<String> env(String name)
      Looks up a system property or environment variable.

      First looks in system properties. Then converts the name to env-safe and looks in the system environment. Then returns the default if it can't be found.

      Parameters:
      name - The property name.
      Returns:
      The value if found.