All Classes and Interfaces
Class
Description
AbstractAdapterElement extends the abstract Node type and implements
the DOM Element interface.
AbstractAdapterNode is the base for childAdapters that expose a read-only view
of a Java object as a DOM Node.
Abstract class to link a correct evaluation of an attribute, by evaluating
Attribute.getValue() and then Attribute.getExpressionObject().Base implementation of
BeanSelectionProvider that provides bean aliasing functionality.Base class for "client" requests, i.e. requests that come unchanged by the
container, such as ServletRequest and PortletRequest.
AbstractCRUDAction.
AbstractDao.
Renderable that provides a default implementation of Renderable#toString()
and allows access to parameters and context objects.
Provides default implementations of optional lifecycle methods
Matches patterns against pre-compiled wildcard expressions pulled from
target objects.
Base class for ActionError and ActionMessage
Base class for the abstraction of the body.
Abstract class with some helper methods, it should be used
when starting development of another implementation of
MultiPartRequestA pattern definition resolver that stores
DefinitionPatternMatcher
separated by customization key.Base request.
A base template class generator.
A base template suite generator.
Abstract Factory that creates instances of
TilesContainer.Default Tiles initialization delegate implementation under a servlet
environment.
Listener for the initialization of the Tiles container.
Abstract base class for all UI tags.
Describes properties supported by the AbstractUITag - base class for all UI tags
This bases on HtmlTagSupportBeanInfo class from StripesFramework - thanks!
Base class for "view" requests, i.e. requests created into view technologies,
such as JSP, Velocity and Freemarker.
Used across different interceptors to check if given string matches one of the accepted patterns.
Resolves locale by first checking the request-only parameter and then falling back
to the browser's
Accept-Language header.All actions may implement this interface, which exposes the
execute() method.TODO: Give a description of the Interceptor.
This result invokes an entire other action, complete with it's own interceptor stack and result.
Contains everything needed to configure and execute an action:
methodName - the method name to execute on the action.
The builder for this object.
This interface defines how the action configurations for the current
web application can be constructed.
Matches paths against pre-compiled wildcard expressions pulled from
action configs.
The ActionContext is the context in which an
Action is executed.Render action errors if they exists the specific layout of the rendering depends on
the theme itself.
ActionError Tag.
Provides hooks for handling key action events
Used by
ObjectFactory to build actions
Interceptor that is based off of
MultiPartRequestWrapper, which is automatically applied for any request that
includes a file when the support for multi-part request is enabled,
see Disabling file upload.An
ActionInvocation represents the execution state of an Action.Simple class that holds the action mapping information used to invoke a
Struts action.
Render action messages if they exists, specific rendering layout depends on the
theme itself.
ActionMessage Tag.
This interface defines the method that is used to create action
names based on the name of a class.
ActionNamesAction
ActionProxy is an extra layer between XWork and the action so that different proxies are possible.
The
ActionProxyFactory is used to create ActionProxys to be executed.Provides a default implementation for the most common actions.
ActionValidatorManager is the main interface for validation managers (regular and annotation based).
AdapterFactory produces Node adapters for Java object types.
Allows to get and set attributes.
Exposes an
HasAddableKeys object as a put/get (no remove) map.
Add an element to the surrounding list.
Add an element to the surrounding list.
Add an element to the surrounding list.
Add an element to the surrounding list.
Declare a list that will be pass as an attribute.
Declare a list that will be pass as an attribute.
Declare a list that will be pass as an attribute.
Declare a list that will be pass as an attribute.
Marks a action method that needs to be called after the main action method and the result was
executed.
Example Action that shows how forms can be validated and submitted via AJAX
only.
The aim of this Interceptor is to alias a named parameter to a different named parameter.
Use this annotation to limit with what http method action or action's method can be called
AnnotationActionValidatorManager is the entry point into XWork's annotations-based validator framework.
AnnotationUtilsAnnotationValidationConfigurationBuilderExtends the xwork validation interceptor to also check for a @SkipValidation
annotation, and if found, don't validate this action method
Accesses attributes in any scope.
A bean that takes several iterators and outputs them in sequence
Append a list of iterators.
Entry point to get information about the application.
Actions that want to be aware of the application Map object should implement this interface.
Defines a set of methods which tiles use to communicate to
the tiles container and runtime environment.
It represents an object that can have a reference to the
ApplicationContext.A simple implementation of the
Map interface to handle a collection of attributes and
init parameters in a ServletContext object.A (localized) resource accessible through the ApplicationContext.
Extract attributes from application scope.
Filters async actions directly to Struts servlet
Adds support for invoke async actions.
Common implementation of attribute definition.
Encapsulation of the current state of execution.
It represents an object able to manipulate a
AttributeContext.It represents an object that resolves a string to return an object.
Creates an attribute evaluator using the language or an attribute.
It represents an object that can use an
AttributeEvaluatorFactory.Allows to get, put and remove Object-type attributes.
A Map that holds 4 levels of scope.
Resolves an attribute, depending on the given parameters.
Map of tag attributes, used for rendering the tags
Marker interface for
ContentTypeHandler implementations that respect the
ParameterAuthorizationContext ThreadLocal during deserialization, enforcing
@StrutsParameter authorization per-property.A
SettableBeanProperty.Delegating that authorizes each property against the
ParameterAuthorizationContext before delegating to the underlying property's
deserializeAndSet.Builder interface for creating requests.
Generic exception for Autotag.
Interface used to create a background process which will be executed by
ExecuteAndWaitInterceptorBase abstract class for a DAO that is based on URLs and locale as a
customization key.
Base class for template engines.
Basic implementation for
AttributeContext.Basic implementation of
AttributeEvaluatorFactory.A pattern definition resolver that stores
DefinitionPatternMatcher
separated by customization key.Default implementation of the
PreparerFactory.Basic renderer factory implementation.
Basic implementation of the tiles container interface.
Factory that builds a standard Tiles container using only Java code.
This class is the most general type of adapter, utilizing reflective introspection to present a DOM view of all of
the public properties of its value.
A proxy interface to be used with Struts DI mechanism
A
ConfigurationProvider that selects and aliases bean implementations.Marks a action method that needs to be executed before the main action method.
Marks a action method that needs to be executed before the result.
Helper class for building/generating the classes and resources used in the
plugin.
A definitions DAO (loading URLs and using Locale as a customization key) that
caches definitions that have been loaded in a raw way (i.e. with inheritance
that is not resolved).
Manages custom and configured definitions, so they can be used by the
container, instead of using a simple
DefinitionsFactory.Indicates that an object cannot be instantiated.
Indicates that something went wrong during the rendering process.
CdiObjectFactory allows Struts 2 managed objects, like Actions, Interceptors or Results, to be injected by a Contexts
and Dependency Injection container (JSR299 / WebBeans).
Renders an attribute that has no associated renderer using delegation to other renderers.
Authenticate showcase chat example, make sure everyone have a username.
Example to illustrate the
async plugin.Renders an HTML input element of type checkbox, populated by the specified property from the ValueStack.
Creates a series of checkboxes from a list.
ClassFinder searches the classpath of the specified ClassLoaderInterface for
packages, classes, constructors, methods, or fields with specific annotations.
Allows create different ClassFinders which should help support different Java versions
Classes implementing this interface can find resources and load classes, usually delegating to a class
loader
Default implementation of ClassLoaderInterface, which delegates to an actual ClassLoader
This class is extremely useful for loading resources and classes in a fault tolerant manner
that works across different applications servers.
Xwork will only reload configurations, if one ContainerProvider needs reloading, that's all this class does
This class is an utility class that will search through the classpath
for files whose names match the given pattern.
This class is a configuration provider for the XWork configuration
system.
Same as DefaultListableBeanFactory, but it doesn't use the constructor and class cached in RootBeanDefinition
Same as SimpleInstantiationStrategy, but constructor is not cached
This class can be used instead of XmlWebApplicationContext, and it will watch jar files and directories for changes
and reload then changed classes.
Utilities to work with dynamic class loading and instantiation.
ValueStacks implementing this interface provide a way to remove values from
their contexts.
ClosingUIBean is the standard superclass for UI components such as div etc.
Interceptor that implements Cross-Origin Embedder Policy on incoming requests used to protect a
document from loading any non-same-origin resources which don't explicitly grant the document
permission to be loaded.
Utilities for requests.
Contains the bean infos about one or more classes.
Adds attributes from common-attributes.ftl
Base class to extend for UI components.
Clears
Component's static standard attributes cache to prevent
classloader leaks on hot redeploy.Default implementation of UrlProvider
Various static methods used with components
Utilities to work with compose stacks.
A composite action mapper that is capable of delegating to a series of
ActionMapper if the former
failed to obtained a valid ActionMapping or uri.This is a composite
TextProvider that takes in an array or List of TextProviders, it will
consult each of them in order to get a composite result.A Stack that is implemented using a List.
A stack that is able to call methods on objects in the stack.
Used to compress HTML output.
A marking interface, when implemented allows to conditionally execute a given interceptor
within the current action invocation.
The ConditionalVisitorFieldValidator will forward validation to the VisitorFieldValidator
only if the expression will evaluate to true.
XWork configuration.
ConfigurationException
ConfigurationHelper
ConfigurationManager - central for XWork Configuration management, including
its ConfigurationProvider.
Interface to be implemented by all forms of XWork configuration classes.
ConfigurationUtil
Injects dependencies into constructors, methods and fields annotated with
Inject.Builds a dependency injection
Container.Implemented by classes which participate in building a container.
Provides beans and constants/properties for the Container
ContainUtil will check if object 1 contains object 2.Handles transferring content to and from objects for a specific content type
Manages content type handlers
Uses the content handler to apply the request body to the action.
Matches content type of uploaded files, similar to
PatternMatcherContext of the current injection.
Extension of
InternalDestroyable for components that require
ServletContext during cleanup (e.g. clearing servlet-scoped caches).Base class for control and data tags
An object that holds the current state of Velocity in a Servlet environment.
Value Stack's Context related Utilities.
Constants used to extend the Convention plugin
This interface defines the conventions that are used by the convention plugin.
This class is the implementation of the
ConventionsService
interface and provides all of the defaults and annotation handling.
This class is the default unknown handler for all of the Convention
plugin integration with XWork.
A marker annotation for type conversions at Type level.
Used to process
TypeConversion
annotation to read defined ConvertersThis validator checks if there are any conversion errors for a field and applies them if they exist.
Field Validator that checks if a conversion error occurred for this field.
ConversionErrorInterceptor adds conversion errors from the ActionContext to the Action's field errors.
Used to process <clazz>-conversion.properties file to read defined Converters
Used to read converters from Properties file
ConversionRuleConversionTypeDedicated interface used by
ObjectFactory to build TypeConverterAction can create cookies which will be stored in response
Allows actions to send cookies to client, action must implement
CookieProvider
You must reference this interceptor in your default stack or in action's stack, see example below.Actions implementing the CookiesAware interface will receive
a Map of filtered cookies via the setCookiesMap method.
Interceptor that implements Cross-Origin Opener Policy on incoming requests.
A bean that can be used to keep track of a counter.
CreateException.
This validator checks that a field is a valid credit card.
CreditCardFieldValidator checks that a given String/Array/Collection field,
if not empty, is a valid credit card number.
Interceptor that implements Content Security Policy on incoming requests used to protect against
common XSS and data injection attacks.
Reads the nonce value using the ValueStack,
StrutsCspNonceReader is the default implementationSource of the nonce value
An abstract Action that can be extended to process the incoming CSP violation reports.
CspSettings interface used by the
CspInterceptor to add the CSP header to the response.Implement this interface by an action to provide a custom
CspSettings,
see CspInterceptor for more details
This is an example of a custom FreemarkerManager, mean to be
instantiated through Spring.
This class is just a simple util that gets injected into
CustomFreemarkerManager through Spring's constructor
injection, serving as a simple example in Struts' Showcase.This annotation can be used for custom validators.
Dao.
DateActionDateDirectiveAllows defines a wrapper around different formatting APIs, like old SimpleDateFormat
and new DateTimeFormatter introduced in Java 8 Date/Time API
DateModelThis validator checks that a date field has a value within a specified range.
Field Validator that checks if the date supplied is within a specific range.
Clears
DebugUtils's static logged-keys cache to prevent memory leaks
during hot redeployment.Default implementation
The Default ActionInvocation implementation
This class strips the word Action from the end of the class name
and possibly lowercases the name as well depending on the value of the
constant struts.convention.action.name.lowercase.
The Default ActionProxy implementation
Default factory for
ActionProxyFactory.A simple action support class that sets properties to be able to serve
This is the entry point into XWork's rule-based validation framework.
Implements
AsyncManager to add support for invoke async actions via Servlet 3's API.The default implementation of AttributeResolver.
DefaultConfiguration
Manages
ContentTypeHandler instances and uses them to
process resultsDefault implementation of
ConversionAnnotationProcessorDefault implementation of
ConversionFileProcessorThe default implementation of
CspReportAction that simply logs the JSON object
that contains the details of the CSP violation.Default implementation of
CspSettings.Default implementation of
DispatcherErrorHandler
which sends Error Report in devMode or HttpServletResponse.sendError(int, java.lang.String) otherwise.Default implementation of
FileManagerDefault implementation
Default implementation of rest info that uses fluent-style construction
Default implementation
Builds interceptor mappings from annotations.
Defines the default interceptor for all actions
in this package
Default implementation of
LocaleProviderDefault implementation of
It tries to take the locale from the session-scoped attribute
LocaleResolverIt tries to take the locale from the session-scoped attribute
DefaultLocaleResolver.LOCALE_KEY.This
ObjectTypeDeterminer looks at the Class-conversion.properties for entries that indicated what
objects are contained within Maps and Collections.Default OGNL Cache factory implementation.
Default OGNL Cache factory implementation.
Default OGNL Expression Cache factory implementation.
Loads the default properties, separate from the usual struts.properties loading
This class implements the ResultMapBuilder and traverses the web
application content directory looking for reasonably named JSPs and
other result types as well as annotations.
DefaultSettings implements optional methods of Settings.
Default implementation to server static content
Default implementation of TagHandlerFactory
The default Struts tag library
DefaultTextProvider gets texts from only the default resource bundles associated with the default bundles.
Default implementation of the theme
Default type conversion.
Default implementation
Default implementation of UnknownHandlerManager
Default implementation of UrlHelper
Default implementation
Default validator factory
Parse the validation file.
A definition, i.e. a template with (completely or not) filled attributes.
It represents an object that provides definitions, depending on a
customization key.
Create a definition at runtime.
Create a definition at runtime.
Create a definition at runtime.
Matches a definition name to a definition, through pattern-matching.
Creates a new definition pattern matcher for the given pattern and the given
base definition with pattern expressions.
Renders an attribute that contains a reference to a definition.
Interface for creating a
Definitions and managing their contents.Exception thrown when an error occurs while the impl tries to
create a new instance mapper.
Interface for reading
Definition
Create a definition at runtime.
Uses a
PropertyAccessorDelegateFactory to delegate the methods to
another PropertyAccessor.A default implementation of the
ValidatorContext interface.DeleteException.
Thrown when a dependency is misconfigured.
Reads
Definition objects from
an XML InputStream using Digester.Indicates that something went wrong during the use of
DigesterDefinitionsReader.Resolves a string and returns the string itself.
A utility class the actual dispatcher delegates most of its tasks to.
Provide an accessor class for static XWork utility.
Implementation of this interface is used to handle internal errors or missing resources.
A interface to tag those that want to execute code on the init and
destory of a Dispatcher.
Renders an attribute that contains a reference to a template.
Encapsulation of request information.
Delegate for ease of customization.
Helper class to create and retrieve information from location-enabled
DOM-trees.
The
DOMBuilder is a utility class that will generate a W3C
DOM Document from SAX events.
DoubleListUIBean is the standard superclass of all Struts double list handling components.
This validator checks that a double field has a value within a specified range.
Field Validator that checks if the double specified is within a certain range.
Renders two HTML select elements with second one changing displayed values depending on selected entry of first one.
DuplicateKeyException.
Adds dynamic attributes
Demonstrates dynamic file upload validation using WithLazyParams.
Configuration holder for dynamic file upload validation rules.
A marking interface that will tell CI to initialise the bean when instating the whole objects' graph
EditPersonEvaluates string expression with typical EL syntax.
You can use normal EL syntax, knowing the root objects are
You can use normal EL syntax, knowing the root objects are
Request, ApplicationContext and beans
contained in request, session and application scope.Implementation of ELContext.
Copied from Apache Tomcat 6.0.16 source code.
Copied from Apache Tomcat 6.0.16 source code.
This validator checks that a field is a valid e-mail address if it contains a non-empty String.
EmailValidator checks that a given String field, if not empty, is a valid email address.
Employee.
JsfEmployeeAction.
EmployeeDao.
Allows to get values from multi-valued attributes.
Extract attributes from
Environment objects as a scope.Helper class to build error messages.
Exception raised when an expression language evaluation fails.
A simple wrapper around an exception, providing an easy way to print out the stack trace of the exception as well as
a way to get a handle on the exception itself.
Configuration for exception mapping.
The builder for this object.
Used across different interceptors to check if given string matches one of the excluded patterns.
Contains execution operations for filters
Interface mimics
ExecutorService to be used with
ExecuteAndWaitInterceptor
to execute BackgroundProcessIt is an expression, along with the expression language (e.g.
A proxy interface to be used with Struts DI mechanism
Interface to define a factory of
ExpressionFactory.This non-field level validator validates a supplied regular expression.
A Non-Field Level validator that validates based on regular expression supplied.
Wraps an HTTP response and overrides its print writer.
A custom factory.
A speedy implementation of ByteArrayOutputStream.
Interceptor that implements Fetch Metadata policy on incoming requests used to protect against
CSRF, XSSI, and cross-origin information leaks.
User: maurizio.cucchiara
Date: Oct 28, 2010
Time: 12:06:13 AM
Render field errors if they exists.
FieldError Tag.
This validator uses an OGNL expression to perform its validator.
Validates a field using an OGNL expression.
The FieldValidator interface defines the methods to be implemented by FieldValidators.
Base class for field validators.
Renders an HTML file input element.
Demonstrates file resource download.
Basic interface to access file on the File System and to monitor changes
Factory that creates FileManager, default to
DefaultFileManagerAllows to specify custom
FileManagerFactoryAllows to specify custom
FileManager by userReads a class from disk
class taken from Apache JCI
Represents file resource revision, used for file://* resources
Show case File Upload example's action.
Host configuration that wraps FilterConfig
Phantom reference with a
finalizeReferent() method which a
background thread invokes after the garbage collector reclaims the
referent.Starts a background thread that cleans up after reclaimed referents.
Adapter that exposes
FinalizableReferenceQueue.stopAndClear() as an
InternalDestroyable bean.Soft reference with a
finalizeReferent() method which a background
thread invokes after the garbage collector reclaims the referent.Weak reference with a
finalizeReferent() method which a background
thread invokes after the garbage collector reclaims the referent.Generates a single Freemarker directive model, given a template class.
Generates the model repository, given the template suite.
Creates a template generator that generates code for Freemarker.
Wrap field validator, add visitor's field prefix to the field name.
FormButton.
Handles the default content type for requests that originate from a browser's HTML form
content-type: application/x-www-form-urlencoded
This handler is intended for requests only, not for responses
Thrown when a Freemarker problem under Autotag runtime part happens.
A Runtime for implementing a Freemarker Template Directive.
WW-5537: Clears FreeMarker's template and class introspection caches
stored in
ServletContext during application undeploy, preventing
classloader leaks.
Static Configuration Manager for the FreemarkerResult's configuration
Body implementation of a Freemarker model body.
The FreeMarker-specific request context.
Thrown when a Freemarker request fails.
Utilities to work with Freemarker requests.
Renders a view using the Freemarker template engine.
Freemarker based template engine.
When loading a template, if sees theme token in path, does a template search through
theme hierarchy for template, starting at the theme name after the token.
Utilities for FreeMarker usage in Tiles.
A Function provides a transformation on an object and returns the resulting
object.
A model class to be used by the simple Model-Driven example.
Render the value of the specified template attribute to the current Writer
Render the value of the specified template attribute to the current Writer
Render the value of the specified template attribute to the current
Writer
Render the value of the specified template attribute to the current Writer
Provides support for localization in the framework, it can be used to read only default bundles.
Allows to get and set attributes.
Allows to get attributes.
Allows to get and remove attributes.
Renders parts of the HEAD section for an HTML file.
Extract header values from an HTTP request.
Exposes an
EnumeratedValuesExtractor object as a read-only map.Renders an HTML input element of type hidden, populated by the specified property from the ValueStack.
Abstraction for host configuration information such as init params or the servlet context.
Handles HTML content, usually just a simple passthrough to the framework
Use this annotation to allow call action or action's method via DELETE request only
Use this annotation to allow call action or action's method via GET request only
Use this annotation to allow call action or action's method via GET or POST request only
Type-safe rest-related information to apply to a response
Enum represents possible http request types
Action when implements this interface is notified about what method was used to perform request,
it works in connection with
HttpMethodInterceptor
Another function of this interface is to return result, which should be returned when action
was called with wrong http methodInterceptor is used to control with what http methods action can be called,
if request with not allowed method was performed,
HttpMethodInterceptor.badRequestResultName
will be returned or if action implements HttpMethodAware
and HttpMethodAware.getBadRequestResultName() returns non-null result name,
thus value will be used instead.Use this annotation to allow call action or action's method via POST request only
Use this annotation to allow call action or action's method via PUT request only
Gets a resource bundle and place it on the value stack.
An interceptor that handles setting the locale specified in a session as the locale for the current action request.
Deprecated, for removal: This API element is subject to removal in a future version.
IdEntity.
Import attribute(s) in specified context.
Import attribute(s) in specified context.
Import attribute(s) in specified context.
Import attribute(s) in specified context.
Beans marked with this interface will be always initialised
after the internal DI mechanism will be created.
Contains initialization operations
Extract initialization parameters from the servlet context.
Annotates members and parameters which should have their value[s]
injected.
Marks a action method that if it's not validated by ValidationInterceptor then execute input method or input result.
InputTransferSelect jsp tag.
Inserts the value of an attribute into the page.
Inserts the value of an attribute into the page.
Inserts the value of an attribute into the page.
Inserts the value of an attribute into the page.
Insert a definition.
Insert a definition.
Insert a definition.
Insert a definition.
Insert a template.
Insert a template.
Insert a template.
Insert a template.
Builds a list of interceptors referenced by the refName in the supplied PackageConfig.
Configuration for Interceptors.
The builder for this object.
Dedicated interface used by
ObjectFactory to build InterceptorInterceptorListHolder
Defines an object that can be used to retrieve interceptor configuration
This interface defines how interceptors are built from
annotations.
InterceptorMappingConfiguration for InterceptorStack.
The builder for this object.
Internal framework interface for components that hold static state
(caches, daemon threads, etc.) requiring cleanup during application
undeploy to prevent classloader leaks.
This validator checks that a numeric field has a value within a specified range.
Field Validator that checks if the integer specified is within a certain range.
An invalid template has been identified.
InvocationSessionStore
A base class for iterator filters
A bean that generates an iterator filled with a given object depending on the count,
separator and converter defined.
Interface for converting each separated token into an Object of choice.
NOTE: JSP-TAG
The iterator tag can export an IteratorStatus object so that
one can get information about the status of the iteration, such as:
index: current iteration index, starts on 0 and increments in one on every iteration
count: iterations so far, starts on 1. count is always index + 1
first: true if index == 0
even: true if (index + 1) % 2 == 0
last: true if current iteration is the last iteration
odd: true if (index + 1) % 2 == 1
Handles JSON content using jackson-lib
Handles XML content using Jackson
Multipart form data request adapter for Jakarta Commons FileUpload package.
Multipart form data request adapter for Jakarta Commons FileUpload package that
leverages the streaming API rather than the traditional non-streaming API.
Represents jar resource revision, used for jar://* resource
Read resources from a jar file
JasperReport7ExporterProvider<T extends net.sf.jasperreports.engine.JRAbstractExporter<? extends net.sf.jasperreports.export.ReportExportConfiguration,? extends net.sf.jasperreports.export.ExporterConfiguration,? extends net.sf.jasperreports.export.ExporterOutput,? extends net.sf.jasperreports.engine.export.JRExporterContext>>
Template engine that renders tags using java implementations
FileManager implementation used with JBoss AS
Specialized form of
ServletActionRedirectResult which takes care of
situation that browser has a JS/AJAX context, there are no validation errors
and action is executed.WW-5537: Clears JSON plugin's static BeanInfo caches when the Dispatcher is
destroyed, preventing classloader leaks during hot redeployment.
Isolate the process of cleaning JSON data from the Interceptor class
itself.
Class consisting of various constant values being used controlling
JSON plugin behaviour
Wrap exceptions throwed by the JSON serializer
Populates an action from a JSON string
User: maurizio.cucchiara
Date: Oct 28, 2010
Time: 2:16:44 AM
key/value parameter pattern
Isolate the process of populating JSON objects from the Interceptor class
itself.
Deserializes an object from a JSON string.
Wrapper for JSONWriter with some utility methods.
Realizes the visit(Class) method called by vistInterfaces for all
encountered classes/interfaces
Serializes validation and action errors into JSON.
Should serialize an object into JavaScript Object Notation (JSON).
A Runtime for implementing JSP tag libraries.
Will only work on containers that unzip war files
Uses the JSP 2.1
ExpressionFactory to be used in Tiles.The body abstraction in a JSP tag.
Context implementation used for executing tiles within a jsp tag library.
JSP based template engine.
Creates a template generator to build JSP code around template models.
JSP utilities for JSP requests and related.
Handles XML content using Apache Juneau
http://juneau.apache.org/#marshall.html
Exposes keys of a
HasKeys object as a set.
Add nonce propagation feature to implement CSP in link tags
An attribute as a
List.Host configuration that just holds a ServletContext
Entry in a list.
DoubleListUIBean is the standard superclass of all Struts list handling components.
ListValidatorsAction loads the validations for a given class and context
Strategy used by
I18nInterceptor to resolve and optionally persist the current request locale.Indicates that the implementing class can provide its own
Locale.Allows delegate creation of
LocaleProvider to another implementation provided
by a user.It represents an object able to resolve the current locale for the current
request, where its strategy depends on its implementation.
Utilities for locale manipulation.
A interface that should be implemented by objects knowning their location (i.e. where they
have been created from).
Factory that remembers where a constant came from
Attaches location information to the factory.
Properties implementation that remembers the location of each property.
Base class for location aware objects
A location in a resource.
A class to handle location information stored in attributes.
A SAX filter that adds the information available from the
Locator as attributes.A simple immutable and serializable implementation of
Location.Location-related utility methods.
An finder or object locations
Simple AOP interceptor that wraps actions in a Spring proxy.
Example to illustrate the
execAndWait interceptor.This validator checks that a numeric field has a value within a specified range.
Field Validator that checks if the long specified is within a certain range.
MakeIterator.
MapAdapter adapters a java.util.Map type to an XML DOM with the following
structure:
Map.Entry implementation that can be constructed to either be read-only
or not.
Multi-valued map entry.
ValueStacks implementing this interface provide a way to remove block or allow access
to properties using regular expressions
MemoryStorage.
A bean that takes several iterators and outputs the merge of them.
Append a list of iterators.
This listener is used by
MessageStoreInterceptor to store messages in HttpSession
just before result will be executed.Utility class contains common methods used by
MethodFilterInterceptor.Mock for an
ActionInvocation.Mock for an
ActionProxy.Simple configuration used for unit testing
Mock implementation to be used in unittests
Mock for an
Interceptor.Mocks the function of an ObjectTypeDeterminer for testing purposes.
Mock for a
Result.Abstracts a tag/directive body.
ModelDriven Actions provide a model object to be pushed onto the ValueStack
in addition to the Action itself, allowing a FormBean type approach like Struts.
Action to demonstrate simple model-driven feature of the framework.
Watches for
ModelDriven actions and adds the action's model on to the value stack.Refreshes the model instance on the value stack, if it has changed
Handles the default content type for requests that originate from a browser's HTML form
with a file upload and multipart/from-data encoding
content-type: multipart/form-data
This handler is intended for requests only, not for responses
Abstract wrapper class HTTP requests to handle multi-part data.
Parse a multipart request and provide a wrapper around the request.
Showcase action - multiple file upload using array.
Showcase action - multiple file upload using List
Just as the CheckboxInterceptor checks that if only the hidden field is present, so too does this interceptor.
Defines a mutable version of the TilesContainer.
An implementation of a pattern matcher that uses simple named wildcards.
Stores the compiled pattern and the variable names matches will correspond to.
Represents a match from a namespace pattern matching.
Matches namespace strings against a wildcard pattern matcher
Uses a
PropertyAccessor as a delegate, but passing a nested object as
target.Extracts an object using another object as a basis.
Interceptor that does nothing, used in the "empty" stack
This marker interface should be implemented by actions that do not want any parameters set on
them automatically.
Indicates that a named attribute has not been found.
Indicates that a keyed container has not been found.
Exception thrown when a definition is not found.
Thrown when the named preparerInstance can not be found.
It is raised when a named renderer has not been found with that name.
Exception that indicates that a resource could not be used because it is not
in a servlet environment.
Exception that indicates that a feature could not be used since it is not available.
Thrown when the Freemarker servlet is not available.
Used across different places to check if given string is not excluded and is accepted
Interface for handling null results from Chains.
Null result to get around annotation defaults that can't be null
FIXME: ????
A writer that does not write anything.
ObjectFactory is responsible for building the core framework objects.
An interface to be implemented by any ObjectFactory implementation
if it requires shutdown hook whenever an ObjectFactory is to be
destroyed.
An Object to use within OGNL to proxy other Objects
usually Collections that you set in a different place
on the ValueStack but want to retain the context information
about where they previously were.
Is able to access (set/get) properties on a given object.
Determines what the key and and element class of a Map or Collection should be.
Evaluates attribute expressions and expressions with OGNL language.
A basic cache interface for use with OGNL processing (such as Expression, BeanInfo).
Clears OGNL runtime caches and JDK introspection caches that hold
Class<?> references, preventing classloader leaks on hot redeploy.Used by
OgnlUtil to create appropriate OGNL
caches based on configuration.This OGNL Cache implementation is backed by
Caffeine which uses the Window TinyLfu algorithm.Basic OGNL cache implementation.
Guards all expressions parsed by Struts Core.
A basic OGNL LRU cache implementation.
Default
ParameterAllowlister.Deprecated, for removal: This API element is subject to removal in a future version.
OGNL implementation of
TextParserWraps an XWork type conversion class for as an OGNL TypeConverter
Utility class that provides common access to the Ognl APIs for
setting and getting properties from objects (usually Actions).
Ognl implementation of a value stack that allows for dynamic Ognl expressions to be evaluated against it.
Creates an Ognl value stack
OptGroup velocity directive.
Freemarker's TransformModel for OptGroup component.
OptionTransferSelect jsp tag.
This class implements the ActionConfigBuilder interface.
Configuration for Package.
The builder for this object.
Provides configuration packages.
Tags can implement this to support nested param tags without the name attribute.
Specifies behaviour for a parameter of the "execute" method of a template class.
Defines a parameter action prefix.
Primes channel-specific runtime state required for an already-authorized parameter path to be walked by the
value-stack — for example, registering the path's classes into the OGNL
ThreadAllowlist
so OGNL may traverse them.ThreadLocal holder for per-request parameter authorization state, used by deserializer-level
authorization (e.g. the REST plugin's
ContentTypeInterceptor).Service for determining whether a given parameter name is authorized for injection into a target object, based on
StrutsParameter annotation presence and depth.Jackson
SimpleModule that wraps every SettableBeanProperty on every bean type
with an AuthorizingSettableBeanProperty, enforcing @StrutsParameter authorization
during deserialization via the ParameterAuthorizationContext
ThreadLocal.Extract parameters from the request.
User: maurizio.cucchiara
Date: Oct 28, 2010
Time: 2:32:08 AM
This interface is implemented by actions that want to declare acceptable parameters.
This is a simple XWork interceptor that allows parameters (matching
one of the paramNames attribute csv value) to be
removed from the parameter map if they match a certain value
(matching one of the paramValues attribute csv value), before they
are set on the action.
This interface gives actions an alternative way of receiving input parameters.
This interceptor sets all parameters on the value stack.
This interface is implemented by actions that want to declare acceptable parameter values.
Accept parameter name/value to be set on
ResultThis class supports
com.atlassian.confluence.stateless.webdriver.selenium3.security.StrutsParametersTest
which prevents critical security regressions.Resolves a definition starting from patterns stored in definition maps.
It indicates an object that uses a
PatternDefinitionResolver.Compiles and matches a pattern against a value
Checks if a pattern (or a candidate one) is recognized as a pattern.
Utilities for pattern matching and substitution.
This result can only be used in code, as a result of action's method, eg.:
A result that send the content out as plain text.
An ApplicationResource whose localization is managed by postfixing the file name.
This resolver allows the use of multiple pattern matching languages.
A utility class for invoking prefixed methods in action class.
Quickly matches a prefix to an object.
Preparable Actions will have their
prepare() method called if the
PrepareInterceptor is applied to the ActionConfig.This interceptor calls
prepare() on actions which implement
Preparable.Contains preparation operations for a request before execution
Thrown when an exception occurs while processing
a prepare request.
Factory interface used to create/retrieve instances of
the
ViewPreparer interface.PreResultListeners may be registered with an
ActionInvocation to get a callback after the
Action has been executed but before the Result
is executed.Actions that want access to the Principal information from HttpServletRequest object
should implement this interface.
Proxy interface used together with PrincipalAware interface.
This class is used to read properties lines.
Decides a
PropertyAccessor depending on the property name and the
object to evaluate.Allows registration of classes that should be allowed to be used in OGNL expressions, using a key to identify the
source of the allowlist.
ProxyAttrAdapter is a pass-through adapter for objects which already
implement the Attr interface.
A proxy interface to be used with Struts DI mechanism for proxy detection caching.
ProxyElementAdapter is a pass-through adapter for objects which already
implement the Element interface.
A NamedNodeMap that wraps the Nodes returned in their proxies.
ProxyNodeAdapter is a read-only delegating adapter for objects which already
implement the Node interface.
Service interface for proxy detection and resolution operations.
ProxyTextNodeAdapter is a pass-through adapter for objects which already
implement the Text interface.
Deprecated.
since 7.2, inject
ProxyService instead.
Put an attribute in enclosing attribute container tag.
Put an attribute in enclosing attribute container tag.
Put an attribute in enclosing attribute container tag.
Put an attribute in enclosing attribute container tag.
Declare a list that will be pass as attribute to tile.
Declare a list that will be pass as attribute to tile.
Declare a list that will be pass as attribute to tile.
Declare a list that will be pass as attribute to tile.
A builder used to create a proper Query String out of a set of parameters
Used to parse Http Query String into a map of parameters with support for fragment
Represents result of parsing query string by implementation of
QueryStringParserBase class for range based validators.
Wraps an
HasKeys object into a read-only map.Marking interface for results which perform browser redirection
Extends
ReferenceMap to support lazy loading values by overriding
ReferenceCache.create(Object).Concurrent hash map that wraps keys and/or values in soft or weak
references.
Reference type.
Deprecated, for removal: This API element is subject to removal in a future version.
since 6.8.0, avoid using this interface and any of its implementation, it's going to be removed soon
Manages variables in the reflection context and returns values
to be used by the application.
Declares a class that wants to handle its own reflection exceptions
This class has some reflection helpers.
Implementing this interface means that the object monitors the sources it
uses to check when they change.
Validates a string field using a regular expression.
Validates a string field using a regular expression.
Allows regular expressions to be used in action names.
Holds a compiled expression to match URLs
Matches regular expression patterns in definitions.
Creates instances of
RegexpDefinitionPatternMatcher.
The ReloadingClassLoader uses a delegation mechanism to allow
classes to be reloaded.
Wraps
HasRemovableKeys keys as a set.An object that can render a path, depending on the request passed as a parameter.
Factory interface used to create/retrieve instances of the
Renderer interface.Thrown when rendering fails.
An abstract base class that adds in the capability to populate the stack with
a fake parameter map when a conversion error has occurred and the 'repopulateField'
property is set to "true".
Encapsulation of request information.
Thrown when something related to a request fails.
Resolves locale from a request-only parameter (not persisted to session or cookie).
A simple implementation of the
Map interface to handle a collection of request attributes.Extracts attributes from request scope.
Request handling utility class.
Delegate for ease of customization.
This validator checks that a field is non-null.
RequiredFieldValidator checks if the specified field is not null.
This validator checks that a String field is not empty (i.e. non-null with a length > 0).
RequiredStringValidator checks that a String field is non-null and has a length > 0.
Render a reset button.
ResolverUtil is used to locate classes that are available in the/a class path and meet
arbitrary conditions.
A Test that checks to see if each class is annotated with a specific annotation.
A Test that checks to see if each class is assignable to the provided class.
A Test that checks to see if each class name ends with the provided suffix.
A simple interface that specifies how to test classes to determine if they
are to be included in the results produced by the ResolverUtil.
A definitions DAO (loading URLs and using Locale as a customization key) that
caches definitions that have been loaded and resolves inheritances.
Extension Interface for TextProvider to help supporting ResourceBundles.
Interface for the resource isolation policies to be used for fetch metadata checks.
*interface taken from Apache JCI
class taken from Apache JCI
Extends the usual
ActionInvocation to add support for processing the object returned
from the action execution.This Restful action mapper enforces Ruby-On-Rails Rest-style mappings.
Factory that creates the
RestActionInvocationExtends
ActionSupport to provides a default implementation of the index method that can be invoked for
unknown actions by the UnknownHandler.Extended version of
RestfulActionMapper, see documentation for more details
Restful2ActionMapperSimple Restfull Action Mapper to support REST application
See docs for more information
RestfulActionMapper
An interceptor that makes sure there are not validation errors before allowing the interceptor chain to continue.
All results (except for
Action.NONE) of an Action are mapped to a View implementation.Configuration for Result.
The builder for this object.
Used by
ObjectFactory to build Result
This interface defines how results are constructed for an Action.
Configuration class for result types.
The builder for this object.
Class represents common revision resource, should be used as default class when no other option exists
Class that will be serialized as a response to an RPC call
RuntimeConfiguration
Scope of an injected objects.
Pluggable scoping strategy.
Annotates a scoped implementation class.
Adds the ability to set a model, probably retrieved from a given state.
An interceptor that enables scoped model-driven actions.
Resolves beans in request, session and application scope.
Extracts attributes from a numbered scope from
JspContext.Clears
ScopeInterceptor's static locks map to prevent classloader
leaks on hot redeploy.Exposes a scope context as a <String, Object> map.
Accesses a scope.
Simple Hash model that also searches other scopes.
Add nonce propagation feature to implement CSP in script tags
Adds attributes from scripting-event.ftl
Allows access decisions to be made on the basis of whether a member is static or not.
Render an HTML input tag of type select.
This class converts the class name into a SEO friendly name by recognizing
camel casing and inserting dashes.
Web-specific context information for actions.
Servlet-based implementation of the TilesApplicationContext interface.
For components that have a dependence on the Servlet context.
Dedicated interface to allow inject
ServletContext and perform initialisation based in itHost configuration that wraps a ServletConfig
PrincipalProxy implementation for using HttpServletRequest Principal related methods.
Calls the
sendRedirect
method to the location specified.Servlet-based implementation of the TilesApplicationContext interface.
All Actions that want to have access to the servlet request object must implement this interface.
All Actions that want to have access to the servlet response object must implement this interface.
ServletURIResolver is a URIResolver that can retrieve resources from the servlet context using the scheme "response".
Implementation of the
UrlRenderer interface that creates URLs suitable in a servlet environment.Utilities for Tiles request servlet support.
Actions that want access to the user's HTTP session attributes should implement this interface.
A simple implementation of the
Map interface to handle a collection of HTTP session
attributes.Extracts attributes from session scope from
PageContext.Extract attributes from session scope.
Selects a container to be used as the "current" container.
Selects a container to be used as the "current" container.
Selects a container to be used as the "current" container.
Selects a container to be used as the "current" container.
It is an object that can create a shared variable, as a template model.
This interface should be implemented by validators that can short-circuit the validator queue
that it is in.
This validator checks that a numeric field has a value within a specified range.
Field Validator that checks if the short specified is within a certain range.
Shows the beans loaded by the internal Guice container.
ShowConfigAction
Shows all constants as loaded by Struts
Shows all constants as loaded by Struts
ShowValidatorAction
SimpleAdapterDocument adapted a Java object and presents it as
a Document.
Skill.
SkillAction.
SkillDao.
Marks an Action method to not be validated
A bean that takes a source and comparator then attempt to sort the source
utilizing the comparator.
NOTE: JSP-TAG
Simple implementation of the ObjectFactory that makes use of Spring's application context if one has been configured,
before falling back on the default mechanism of instantiating a new class using the class name.
SpringProxyableObjectFactory.
Showcase action for freemarker templates.
Interface for loading static resources, based on a path.
This interceptor populates the action with the static parameters defined in the action configuration.
Storage.
StorageException.
A custom Result type for sending raw data (via an InputStream) directly to the
HttpServletResponse.
StringAdapter adapts a Java String value to a DOM Element with the specified
property name containing the String's text.
User: maurizio.cucchiara
Date: Oct 28, 2010
Time: 12:46:16 AM
This validator checks that a String field is of the right length.
StringLengthFieldValidator checks that a String field is of a certain length.
Renders an attribute that contains a string.
A Velocity tools to manipulate strings.
This class is a String helper.
Background thread to be executed by the ExecuteAndWaitInterceptor.
Selects the implementations of key framework extension points, using the loaded
property constants.
Contains common functionalities for Struts JSP Tags.
This class provides a central location for framework configuration keys
used to retrieve and store Struts configuration settings.
Default implementation
Reads nonce value from session or request attribute.
A generic runtime exception that optionally contains Location information
Executes the discovered request information.
Deserializes an object from a JSON string with configurable limits
to prevent denial-of-service attacks via malicious payloads.
Serializes an object into JavaScript Object Notation (JSON).
Servlet listener for Struts.
Provides support for localization in the framework, it can be used to read only default bundles,
or it can search the class hierarchy to find proper bundles.
Provides @s.tag access for various tags.
The default implementation of
OgnlGuard.Used to annotate public getter/setter methods or fields on
Action classes that are
intended for parameter injection by the ParametersInterceptor.Default implementation of
ParameterAuthorizer that checks StrutsParameter annotations on the target
object's members to determine whether a parameter is authorized for injection.Handles both the preparation and execution phases of the Struts dispatching process.
Prepares the request for execution by a later
StrutsExecuteFilter filter instance.This is a basic ViewPreparer factory that uses
ObjectFactory to create the ViewPreparerStruts proxy cache factory implementation.
Default implementation of
ProxyService.Provides a specialized request context for Struts applications,
extending the Jakarta Servlet request context to add custom handling
for multipart-related requests.
All Struts requests are wrapped with this class, which provides simple JSTL accessibility.
Default resource isolation policy used in
FetchMetadataInterceptor that
implements the ResourceIsolationPolicy interface.Loads resource from the Thread's context ClassLoader.
Default implementation which uses
ParamNameAwareResult to accept or throw away parametersServlet dispatcher for Struts.
User: mcucchiara
Date: 04/08/11
Time: 16.50
Struts object factory that integrates with Spring.
Base class for Spring JUnit actions
Constants used internally by Struts.
An annotation to document a Struts jsp/freemarker/velocity tag
Documents an attribute to a Struts tag
Marks a class as the top class in the class hierarchy scanned for tag annotations
FIXME: use it or remove
Base test case for JUnit testing Struts.
Generic test setup methods to be used with any unit testing framework.
This factory enables users to provide and correctly initialize a custom TextProvider.
Processes tiles annotations to create
Definitions and
Attributes in a way as close to tiles.xml as possible.Dedicated Struts factory to build Tiles container with support for:
- Freemarker
- I18N using Struts resource bundles
- S2 ro access Struts' ValueStack
- OGNL
- EL
Listener used to automatically tie Tiles support into Struts
Default implementation of
TypeConverterCreatorDefault implementation of
TypeConverterHolderStruts base utility class, for use in Velocity and Freemarker templates
Manages the environment for Velocity result types
Override Xwork class so we can use an arbitrary config file
Render a submit button.
A bean that takes an iterator and outputs a subset of it.
A decider determines if the given element should be added to the list or not.
NOTE: JSP-TAG
A bean that helps implement a tabbed pane
FIXME: use it remove
Generates a tag class using a template class.
Provides Velocity implementation classes for a tag library
Provides Freemarker implementation classes for a tag library
Implementations of this class build the html representation of the tag
A template is used as a model for rendering output.
It represents a parsed template class.
Generates code from a parsed class.
Any template language which wants to support UI tag templating needs to provide an implementation of this interface
to handle rendering the template
The TemplateEngineManager will return a template engine for the template
Generates all the code for a template suite.
Builds a TemplateGenerator.
Creates a new template generator.
It represents a parsed method in a parsed template class.
It represents a parameter in a method in a parsed template class.
Context used when rendering templates.
It represents a suite of template classes.
Generates code from a template suite.
This is the testing interface that is used to accept or reject resources.
TestDataProvider.
Base test class for TestNG unit tests.
Base test class for TestNG unit tests.
Utility methods for test classes
Used to parse expressions like ${foo.bar} or %{bar.foo} but it is up tp the TextParser's
implementation what kind of opening char to use (#, $, %, etc)
Utility class for text parsing.
A parsed value evaluator for
TextParseUtil.Provides access to
ResourceBundles and their underlying text messages.Helper methods to access text from TextProviders
Default TextProvider implementation.
Allows any bean to allowlist a class for use in OGNL expressions, for the current thread only.
Provides static access to the Tiles container.
Represents a
<add-attribute> element in tiles.xml.Represents a
<add-list-attribute> element in tiles.xml.Extracts the application context from a Tiles request.
An encapsulation of the Tiles framework.
Indicates that something went wrong in
AbstractTilesContainerFactory use.Wraps a Tiles container to allow easy decoration.
Resolves beans in request, session and application scope.
Resolves properties of
Request and
ApplicationContext.Decides the appropriate
PropertyAccessor for the given property name
and Request.Represents a
<definition> element in tiles.xml.An array of
TilesDefinitions.Tiles dispatching servlet.
Root class for all Tiles-exceptions.
This tag library provides Tiles tags.
Tiles initialization delegate.
Represents a
<put-attribute> element in tiles.xml.Represents a
<put-list-attribute> element in tiles.xml.Renders a view using struts-tiles.
Exception connected to the usage of Velocity and Tiles.
A bean that can be used to time execution of pages
FIXME: remove?
Generates the TLD file, using a template suite.
Example to illustrate the
token and tokenSession interceptor.TokenHelper
TypeConversionException should be thrown by any TypeConverters which fail to convert values
Interface for accessing the type conversion facilities within a context.
Instantiate converter classes, if cannot create TypeConverter throws exception
Holds all mappings related to
TypeConverters
UIBean is the standard superclass of all Struts UI components.
Simple marker interface to indicate an object should not have its properties copied during chaining.
Handles cases when the result or action is unknown.
Dedicated interface used by
ObjectFactory to build UnknownHandlerAn unknown handler manager contains a list of UnknownHandler and iterates on them by order
DefinitionsFactory implementation that manages
Definitions configuration data from URLs, without resolving definition
inheritance when a definition is returned.UpdateException.
Virtual representation of an uploaded file used by
MultiPartRequestActions that want to be aware of all the uploaded file should implement this interface.
A
PostfixedApplicationResource that can be accessed through a URL.A bean that can generate a URL.
URL Decoder used internally by Struts
URL Encoder used internally by Struts
Helper class used to build Urls or parse request params
Implementations of this interface can be used to build a URL
Implementations of this interface are responsible for rendering/creating URLs for a specific
environment (e.g.
Use with ClassFinder to filter the Urls to be scanned, example:
This validator checks that a field is a valid URL.
URLValidator checks that a given field is a String and a valid URL
Exposes am attribute as a scripting variable within the page.
Implementation of TagExtraInfo which identifies the scripting object(s) to be
made visible.
Represends a user in the Chat example.
Late initialization processor for user conversion properties.
Interface for processors that support late initialization of user conversion properties.
Provides an interface in which a call for a validation check can be done.
ValidationAware classes can accept Action (class level) or field level error messages.
Provides a default implementation of ValidationAware.
ValidationErrorAware classes can be notified about validation errors
before
DefaultWorkflowInterceptor will return 'inputResultName' result
to allow change or not the result name
This interface can be only applied to action which already implements ValidationAware interface!ValidationException.
The ValidationParameter annotation is used as a parameter for CustomValidators.
ValidationWorkflowAware classes can programmatically change result name when errors occurred
This interface can be only applied to action which already implements
ValidationAware interface!Holds the necessary information for configuring an instance of a Validator.
Builds a ValidatorConfig
The context for validation.
Dedicated interface used by
ObjectFactory to build ValidatorValidatorFactory
This class serves 2 purpose :
Parse the validation config file.
Abstract implementation of the Validator interface suitable for subclassing.
ValidatorTypeValueStack allows multiple beans to be pushed in and dynamic EL expressions to be evaluated against it.
Ported to Struts.
Factory that creates a value stack, defaulting to the OgnlValueStackFactory
Ported to Struts:
Please see
StrutsBeanSelectionProvider for more details.Generates a Velocity directive using a template class.
Generates a Velocity properties containing the list of generated user directives for future use.
The implementation of the Tiles request context specific for Velocity.
Using the Servlet container's
JspFactory, this result mocks a JSP
execution environment and then displays a Velocity template that will be
streamed directly to the servlet output.Struts velocity related util.
Tiles Tool to be used "the classic way".
Velocity based template engine.
Creates a template generator that generates code to build Velocity code
around template classes.
Executed prior to rendering a view.
Processes configuration, page, and action class paths to create snippets
of the files for display.
The validator allows you to forward validator to object properties of your action
using the objects own validator files.
Delegates loading templates using a
WebappTemplateLoader and, if not
found, a ClassTemplateLoader.Matches wildcard patterns in definitions.
Creates instances of
WildcardDefinitionPatternMatcher.This class is an utility class that perform wilcard-patterns matching and
isolation taken from Apache Cocoon.
This class is an utility class that perform wilcard-patterns matching and
isolation taken from Apache Struts that is taken, in turn, from Apache
Struts.
Helper class to convert wildcard expression to regular expression
Interceptors marked with this interface support dynamic parameter evaluation at action invocation time.
Write tags as XHTML
Looks in the classpath for an XML file, "struts.xml" by default,
and uses it for the XWork configuration.
This is a base Struts
ConfigurationProvider for loading configuration from a parsed
XML document.XML utilities.
XSLTResult uses XSLT to transform an action object to XML.
Deprecated, for removal: This API element is subject to removal in a future version.
since 7.2.0, scheduled for removal in a future major version.
An interface to be implemented by an action to create/provide an instance
of XStream - it allows customisation per action
XWorkConverter is a singleton used by many of the Struts 2's Ognl extension points,
such as InstantiatingNullHandler, XWorkListPropertyAccessor etc to do object
conversion.
A simple list that guarantees that inserting and retrieving objects will always work regardless
of the current size of the list.
Overrides the list property accessor so in the case of trying
to add properties of a given bean and the JavaBean is not present,
this class will create the necessary blank JavaBeans.
Implementation of PropertyAccessor that sets and gets properties by storing and looking
up values in Maps.
Allows methods to be executed under normal cirumstances, except when
ReflectionContextState.DENY_METHOD_EXECUTION
is in the action context with a value of true.Base JUnit TestCase to extend for XWork specific JUnit tests.
Generic test setup methods to be used with any unit testing framework.
Wraps an OGNL TypeConverter as an XWork TypeConverter
ReflectionContextFactory