com.opensymphony.xwork2

## Class ObjectFactory

- java.lang.Object
- - com.opensymphony.xwork2.ObjectFactory

- All Implemented Interfaces:
    Serializable
  Direct Known Subclasses:
    SpringObjectFactory

      public class ObjectFactory
      extends Object
      implements Serializable

  ObjectFactory is responsible for building the core framework objects. Users may register their own implementation of the ObjectFactory to control instantiation of these Objects.

  This default implementation uses the `buildBean` method to create all classes (interceptors, actions, results, etc).

  Author:
    Jason Carreira
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ObjectFactory()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `buildAction(String actionName, String namespace, ActionConfig config, Map<String,Object> extraContext)` Build an instance of the action class to handle a particular request (eg.
    `Object` | `buildBean(Class clazz, Map<String,Object> extraContext)` Build a generic Java object of the given type.
    `Object` | `buildBean(String className, Map<String,Object> extraContext)` Build a generic Java object of the given type.
    `Object` | `buildBean(String className, Map<String,Object> extraContext, boolean injectInternal)` Build a generic Java object of the given type.
    `TypeConverter` | `buildConverter(Class<? extends TypeConverter> converterClass, Map<String,Object> extraContext)` Build converter of given type
    `Interceptor` | `buildInterceptor(InterceptorConfig interceptorConfig, Map<String,String> interceptorRefParams)` Builds an Interceptor from the InterceptorConfig and the Map of parameters from the interceptor reference.
    `Result` | `buildResult(ResultConfig resultConfig, Map<String,Object> extraContext)` Build a Result using the type in the ResultConfig and set the parameters in the ResultConfig.
    `UnknownHandler` | `buildUnknownHandler(String unknownHandlerName, Map<String,Object> extraContext)` Builds unknown handler
    `Validator` | `buildValidator(String className, Map<String,Object> params, Map<String,Object> extraContext)` Build a Validator of the given type and set the parameters on it
    `Class` | `getClassInstance(String className)` Utility method to obtain the class matched to className.
    `protected Object` | `injectInternalBeans(Object obj)`
    `boolean` | `isNoArgConstructorRequired()` Allows for ObjectFactory implementations that support Actions without no-arg constructors.
    `void` | `setActionFactory(ActionFactory actionFactory)`
    `void` | `setClassLoader(ClassLoader cl)`
    `void` | `setContainer(Container container)`
    `void` | `setConverterFactory(ConverterFactory converterFactory)`
    `void` | `setInterceptorFactory(InterceptorFactory interceptorFactory)`
    `void` | `setResultFactory(ResultFactory resultFactory)`
    `void` | `setUnknownHandlerFactory(UnknownHandlerFactory unknownHandlerFactory)`
    `void` | `setValidatorFactory(ValidatorFactory validatorFactory)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ObjectFactory

          public ObjectFactory()

  - ### Method Detail

    - #### setContainer

          public void setContainer(Container container)

    - #### setClassLoader

          public void setClassLoader(ClassLoader cl)

    - #### setActionFactory

          public void setActionFactory(ActionFactory actionFactory)

    - #### setResultFactory

          public void setResultFactory(ResultFactory resultFactory)

    - #### setInterceptorFactory

          public void setInterceptorFactory(InterceptorFactory interceptorFactory)

    - #### setValidatorFactory

          public void setValidatorFactory(ValidatorFactory validatorFactory)

    - #### setConverterFactory

          public void setConverterFactory(ConverterFactory converterFactory)

    - #### setUnknownHandlerFactory

          public void setUnknownHandlerFactory(UnknownHandlerFactory unknownHandlerFactory)

    - #### isNoArgConstructorRequired

          public boolean isNoArgConstructorRequired()

      Allows for ObjectFactory implementations that support Actions without no-arg constructors.
      Returns:
        true if no-arg constructor is required, false otherwise

    - #### getClassInstance

          public Class getClassInstance(String className)
                                 throws ClassNotFoundException

      Utility method to obtain the class matched to className. Caches look ups so that subsequent lookups will be faster.
      Parameters:
        `className` - The fully qualified name of the class to return
      Returns:
        The class itself
      Throws:
        `ClassNotFoundException` - if class not found in classpath

    - #### buildAction

          public Object buildAction(String actionName,
                                    String namespace,
                                    ActionConfig config,
                                    Map<String,Object> extraContext)
                             throws Exception

      Build an instance of the action class to handle a particular request (eg. web request)
      Parameters:
        `actionName` - the name the action configuration is set up with in the configuration
        `namespace` - the namespace the action is configured in
        `config` - the action configuration found in the config for the actionName / namespace
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
      Returns:
        instance of the action class to handle a web request
      Throws:
        `Exception` - in case of any error

    - #### buildBean

          public Object buildBean(Class clazz,
                                  Map<String,Object> extraContext)
                           throws Exception

      Build a generic Java object of the given type.
      Parameters:
        `clazz` - the type of Object to build
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
      Returns:
        object for the given type
      Throws:
        `Exception` - in case of any error

    - #### injectInternalBeans

          protected Object injectInternalBeans(Object obj)

      Parameters:
        `obj` - object to inject internal
      Returns:
        the object

    - #### buildBean

          public Object buildBean(String className,
                                  Map<String,Object> extraContext)
                           throws Exception

      Build a generic Java object of the given type.
      Parameters:
        `className` - the type of Object to build
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
      Returns:
        object for the given type
      Throws:
        `Exception` - in case of any error

    - #### buildBean

          public Object buildBean(String className,
                                  Map<String,Object> extraContext,
                                  boolean injectInternal)
                           throws Exception

      Build a generic Java object of the given type.
      Parameters:
        `className` - the type of Object to build
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
        `injectInternal` - true if inject internal beans
      Returns:
        object for the given type
      Throws:
        `Exception` - in case of any error

    - #### buildInterceptor

          public Interceptor buildInterceptor(InterceptorConfig interceptorConfig,
                                              Map<String,String> interceptorRefParams)
                                       throws ConfigurationException

      Builds an Interceptor from the InterceptorConfig and the Map of parameters from the interceptor reference. Implementations of this method should ensure that the Interceptor is parametrized with both the parameters from the Interceptor config and the interceptor ref Map (the interceptor ref params take precedence), and that the Interceptor.init() method is called on the Interceptor instance before it is returned.
      Parameters:
        `interceptorConfig` - the InterceptorConfig from the configuration
        `interceptorRefParams` - a Map of params provided in the Interceptor reference in the Action mapping or InterceptorStack definition
      Returns:
        interceptor
      Throws:
        `ConfigurationException`

    - #### buildResult

          public Result buildResult(ResultConfig resultConfig,
                                    Map<String,Object> extraContext)
                             throws Exception

      Build a Result using the type in the ResultConfig and set the parameters in the ResultConfig.
      Parameters:
        `resultConfig` - the ResultConfig found for the action with the result code returned
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
      Returns:
        result
      Throws:
        `Exception` - in case of any error

    - #### buildValidator

          public Validator buildValidator(String className,
                                          Map<String,Object> params,
                                          Map<String,Object> extraContext)
                                   throws Exception

      Build a Validator of the given type and set the parameters on it
      Parameters:
        `className` - the type of Validator to build
        `params` - property name -> value Map to set onto the Validator instance
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
      Returns:
        validator of the given type
      Throws:
        `Exception` - in case of any error

    - #### buildConverter

          public TypeConverter buildConverter(Class<? extends TypeConverter> converterClass,
                                              Map<String,Object> extraContext)
                                       throws Exception

      Build converter of given type
      Parameters:
        `converterClass` - to instantiate
        `extraContext` - a Map of extra context which uses the same keys as the `ActionContext`
      Returns:
        instance of converterClass with inject dependencies
      Throws:
        `Exception` - in case of any error

    - #### buildUnknownHandler

          public UnknownHandler buildUnknownHandler(String unknownHandlerName,
                                                    Map<String,Object> extraContext)
                                             throws Exception

      Builds unknown handler
      Parameters:
        `unknownHandlerName` - the unknown handler name
        `extraContext` - extra context
      Returns:
        a unknown handler
      Throws:
        `Exception` - in case of any error

Copyright © 2000–2023 Apache Software Foundation. All rights reserved.