org.apache.sling.models.factory

Interface ModelFactory

@ProviderType
public interface ModelFactory

The ModelFactory instantiates Sling Model classes similar to #adaptTo but will throw an exception in case instantiation fails for some reason.

Method Summary

Modifier and Type	Method and Description
boolean	canCreateFromAdaptable(Object adaptable, Class<?> type)
<ModelType> ModelType	createModel(Object adaptable, Class<ModelType> type) Instantiates the given Sling Model class from the given adaptable.
<T> T	exportModel(Object model, String exporterName, Class<T> targetClass, Map<String,String> options) Export the model object using the defined target class using the named exporter.
<T> T	exportModelForRequest(SlingHttpServletRequest request, String exporterName, Class<T> targetClass, Map<String,String> options) Export the model object registered to the request's resource's type using the defined target class using the named exporter.
<T> T	exportModelForResource(Resource resource, String exporterName, Class<T> targetClass, Map<String,String> options) Export the model object registered to the resource's type using the defined target class using the named exporter.
Object	getModelFromRequest(SlingHttpServletRequest request) Obtain an adapted model class based on the resource type of the request's resource.
Object	getModelFromResource(Resource resource) Obtain an adapted model class based on the resource type of the provided resource.
boolean	isModelAvailableForRequest(SlingHttpServletRequest request) Determine is a model class is available for the request's resource's resource type.
boolean	isModelAvailableForResource(Resource resource) Determine is a model class is available for the resource's resource type.
boolean	isModelClass(Class<?> type) Checks if a given type can be instantiated though Sling Models.
boolean	isModelClass(Object adaptable, Class<?> type) Deprecated. Use isModelClass(Class) instead!

Method Detail

createModel

@Nonnull
<ModelType> ModelType createModel(@Nonnull
                                           Object adaptable,
                                           @Nonnull
                                           Class<ModelType> type)
                                    throws MissingElementsException,
                                           InvalidAdaptableException,
                                           ModelClassException,
                                           PostConstructException,
                                           ValidationException,
                                           InvalidModelException

Instantiates the given Sling Model class from the given adaptable.

Parameters:

adaptable - the adaptable to use to instantiate the Sling Model Class

type - the class to instantiate

Returns:

a new instance for the required model (never null)

Throws:

MissingElementsException - in case no injector was able to inject some required values with the given types

InvalidAdaptableException - in case the given class cannot be instantiated from the given adaptable (different adaptable on the model annotation)

ModelClassException - in case the model could not be instantiated because model annotation was missing, reflection failed, no valid constructor was found, model was not registered as adapter factory yet, or post-construct could not be called

PostConstructException - in case the post-construct method has thrown an exception itself

ValidationException - in case validation could not be performed for some reason (e.g. no validation information available)

InvalidModelException - in case the given model type could not be validated through the model validation

canCreateFromAdaptable

boolean canCreateFromAdaptable(@Nonnull
                               Object adaptable,
                               @Nonnull
                               Class<?> type)

Parameters:

adaptable - the adaptable to check

type - the class to check

Returns:

true in case the given class can be created from the given adaptable, otherwise false

isModelClass

@Deprecated
boolean isModelClass(@Nonnull
                                 Object adaptable,
                                 @Nonnull
                                 Class<?> type)

Deprecated. Use isModelClass(Class) instead!

Parameters:

adaptable - the adaptable to check

type - the class to check

Returns:

false in case no class with the Model annotation adapts to the requested type

See Also:

Model

isModelClass

boolean isModelClass(@Nonnull
                     Class<?> type)

Checks if a given type can be instantiated though Sling Models. This checks that

• there is a class annotated with Model which adapts to the given type
• this class is registered as Sling Model (i.e. the package is listed in the "Sling-Model-Packages" header from the bundles manifest and has been picked up already by the bundle listener)

Only if both conditions are fulfilled this method will return true.

Parameters:

type - the class to check

Returns:

true in case the given type can be instantiated though Sling Models.

isModelAvailableForResource

boolean isModelAvailableForResource(@Nonnull
                                    Resource resource)

Determine is a model class is available for the resource's resource type.

Parameters:

resource - a resource

Returns:

true if a model class is mapped to the resource type

isModelAvailableForRequest

boolean isModelAvailableForRequest(@Nonnull
                                   SlingHttpServletRequest request)

Determine is a model class is available for the request's resource's resource type.

Parameters:

request - a request

Returns:

true if a model class is mapped to the resource type

getModelFromResource

Object getModelFromResource(@Nonnull
                            Resource resource)
                     throws MissingElementsException,
                            InvalidAdaptableException,
                            ModelClassException,
                            PostConstructException,
                            ValidationException,
                            InvalidModelException

Obtain an adapted model class based on the resource type of the provided resource.

Parameters:

resource - a resource

Returns:

an adapted model object

Throws:

MissingElementsException - in case no injector was able to inject some required values with the given types

InvalidAdaptableException - in case the given class cannot be instantiated from the given adaptable (different adaptable on the model annotation)

ModelClassException - in case the model could not be instantiated because model annotation was missing, reflection failed, no valid constructor was found, model was not registered as adapter factory yet, or post-construct could not be called

PostConstructException - in case the post-construct method has thrown an exception itself

ValidationException - in case validation could not be performed for some reason (e.g. no validation information available)

InvalidModelException - in case the given model type could not be validated through the model validation

getModelFromRequest

Object getModelFromRequest(@Nonnull
                           SlingHttpServletRequest request)
                    throws MissingElementsException,
                           InvalidAdaptableException,
                           ModelClassException,
                           PostConstructException,
                           ValidationException,
                           InvalidModelException

Obtain an adapted model class based on the resource type of the request's resource.

Parameters:

request - a request

Returns:

an adapted model object

Throws:

MissingElementsException - in case no injector was able to inject some required values with the given types

InvalidAdaptableException - in case the given class cannot be instantiated from the given adaptable (different adaptable on the model annotation)

ModelClassException - in case the model could not be instantiated because model annotation was missing, reflection failed, no valid constructor was found, model was not registered as adapter factory yet, or post-construct could not be called

PostConstructException - in case the post-construct method has thrown an exception itself

ValidationException - in case validation could not be performed for some reason (e.g. no validation information available)

InvalidModelException - in case the given model type could not be validated through the model validation

exportModel

<T> T exportModel(Object model,
                  String exporterName,
                  Class<T> targetClass,
                  Map<String,String> options)
           throws ExportException,
                  MissingExporterException

Export the model object using the defined target class using the named exporter.

Type Parameters:

T - the target class

Parameters:

model - the model object

exporterName - the exporter name

targetClass - the target class

options - any exporter options

Returns:

an instance of the target class

Throws:

ExportException - if the export fails

MissingExporterException - if the named exporter can't be found

exportModelForResource

<T> T exportModelForResource(Resource resource,
                             String exporterName,
                             Class<T> targetClass,
                             Map<String,String> options)
                      throws MissingElementsException,
                             InvalidAdaptableException,
                             ModelClassException,
                             PostConstructException,
                             ValidationException,
                             InvalidModelException,
                             ExportException,
                             MissingExporterException

Export the model object registered to the resource's type using the defined target class using the named exporter.

Type Parameters:

T - the target class

Parameters:

resource - the resource

exporterName - the exporter name

targetClass - the target class

options - any exporter options

Returns:

an instance of the target class

Throws:

MissingElementsException - in case no injector was able to inject some required values with the given types

InvalidAdaptableException - in case the given class cannot be instantiated from the given adaptable (different adaptable on the model annotation)

ModelClassException - in case the model could not be instantiated because model annotation was missing, reflection failed, no valid constructor was found, model was not registered as adapter factory yet, or post-construct could not be called

PostConstructException - in case the post-construct method has thrown an exception itself

ValidationException - in case validation could not be performed for some reason (e.g. no validation information available)

InvalidModelException - in case the given model type could not be validated through the model validation

ExportException - if the export fails

MissingExporterException - if the named exporter can't be found

exportModelForRequest

<T> T exportModelForRequest(SlingHttpServletRequest request,
                            String exporterName,
                            Class<T> targetClass,
                            Map<String,String> options)
                     throws MissingElementsException,
                            InvalidAdaptableException,
                            ModelClassException,
                            PostConstructException,
                            ValidationException,
                            InvalidModelException,
                            ExportException,
                            MissingExporterException

Export the model object registered to the request's resource's type using the defined target class using the named exporter.

Type Parameters:

T - the target class

Parameters:

request - the request

exporterName - the exporter name

targetClass - the target class

options - any exporter options

Returns:

an instance of the target class

Throws:

MissingElementsException - in case no injector was able to inject some required values with the given types

InvalidAdaptableException - in case the given class cannot be instantiated from the given adaptable (different adaptable on the model annotation)

ModelClassException - in case the model could not be instantiated because model annotation was missing, reflection failed, no valid constructor was found, model was not registered as adapter factory yet, or post-construct could not be called

PostConstructException - in case the post-construct method has thrown an exception itself

ValidationException - in case validation could not be performed for some reason (e.g. no validation information available)

InvalidModelException - in case the given model type could not be validated through the model validation

ExportException - if the export fails

MissingExporterException - if the named exporter can't be found