Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

Page 1   2  
org.springframework.web.bind.* (8)org.springframework.web.context.* (21)
org.springframework.web.filter.* (3)org.springframework.web.jsf.* (2)
org.springframework.web.multipart.* (14)org.springframework.web.servlet.* (116)
org.springframework.web.struts.* (10)org.springframework.web.util.* (12)
org.springframework.webflow.access.* (9)org.springframework.webflow.action.* (11)

Package Samples:

org.springframework.web.context.support: Contains the application context subinterface for web applications, and the ContextLoaderListener that bootstraps the root web application context.  
org.springframework.web.servlet.view: Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.  
org.springframework.web.servlet.view.xslt: Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.  
org.springframework.web.servlet.handler.metadata: Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.  
org.springframework.web.servlet.mvc.throwaway: Standard controller implementations for the MVC framework that comes with Spring.  
org.springframework.webflow.action: Contains core interfaces and classes for dealing with web flows.  
org.springframework.web.multipart.support: Multipart resolution framework for handling file uploads.  
org.springframework.web.bind
org.springframework.web.context
org.springframework.web.filter
org.springframework.web.jsf
org.springframework.web.multipart.commons
org.springframework.web.multipart.cos
org.springframework.web.multipart
org.springframework.web.servlet.handler
org.springframework.web.servlet.i18n
org.springframework.web.servlet.mvc.multiaction
org.springframework.web.servlet.mvc
org.springframework.web.servlet.support
org.springframework.web.servlet.tags

Classes:

FormAction: Multi-action that implements common logic dealing with input forms. Several action execution methods are provided: exposeFormObject(RequestContext) 55 - Loads the backing form object and exposes it and an empty errors instance in the model of the executing flow in the correct scope. Any custom property editors for formatting form object values will also be installed. This action method will return success() if the form object was loaded successfully, error() otherwise. setupForm(RequestContext) 55 - Prepares the backing form object for display on a form. This method behaves exactly like exposeFormObject ...
AbstractFormController: Form controller that autopopulates a form bean from the request. This, either using a new bean instance per request, or using the same bean when the sessionForm property has been set to true . This class is the base class for both framework subclasses like SimpleFormController and AbstractWizardFormController , and custom form controllers you can provide yourself. Both form-input views and after-submission views have to be provided programmatically. To provide those views using configuration properties, use the SimpleFormController . Subclasses need to override showForm to prepare the form view, ...
BaseCommandController: Controller implementation which creates an object (the command object) on receipt of a request and attempts to populate this object with request parameters. This controller is the base for all controllers wishing to populate JavaBeans based on request parameters, validate the content of such JavaBeans using Validators and use custom editors (in the form of PropertyEditors ) to transform objects into strings and vice versa, for example. Three notions are mentioned here: Command class: An instance of the command class will be created for each request and populated with request parameters. A command ...
SimpleFormController: Concrete FormController implementation that provides configurable form and success views, and an onSubmit chain for convenient overriding. Automatically resubmits to the form view in case of validation errors, and renders the success view in case of a valid submission. The workflow of this Controller does not differ much from the one described in the AbstractFormController . The difference is that you do not need to implement showForm 55 and processFormSubmission 55 : A form view and a success view can be configured declaratively. Workflow ( in addition to the superclass ): Call to processFormSubmission ...
AbstractFlowBuilder: Base class for flow builders that programmatically build flows in Java configuration code. To give you an example of what a simple Java-based web flow builder definition might look like, the following example defines the 'dynamic' web flow roughly equivalent to the work flow statically implemented in Spring MVC's simple form controller: public class CustomerDetailFlowBuilder extends AbstractFlowBuilder { protected String flowId() { return "customerDetails"; } public void buildStates() { // get customer information addActionState("getDetails", action(GetCustomerAction.class, ...
Controller: Base Controller interface, representing a component that receives HttpServletRequest and HttpServletResponse like a HttpServlet but is able to participate in an MVC workflow. Comparable to the notion of a Struts Action . Any implementation of the Controller interface should be a reusable, thread-safe class, capable of handling multiple HTTP requests throughout the lifecycle of an application. To be able to configure Controller in an easy, Controllers are usually JavaBeans. Workflow After the DispatcherServlet has received a request and has done its work to resolve locales, themes and things a like, ...
Log4jWebConfigurer: Convenience class that performs custom Log4J initialization for web environments, allowing for log file paths within the web application, with the option to perform automatic refresh checks (for runtime changes in logging configuration). WARNING: Assumes an expanded WAR file , both for loading the configuration file and for writing the log files. If you want to keep your WAR unexpanded or don't need application-specific log files within the WAR directory, don't use Log4J setup within the application (thus, don't use Log4jConfigListener or Log4jConfigServlet). Instead, use a global, VM-wide Log4J ...
ParameterizableFlowAttributeMapper: Generic flow attribute mapper implementation that allows mappings to be configured in a declarative fashion. Exposed configuration properties: name default description inputAttribute(s) null Sets the name of input attributes in flow scope to map to the subflow. inputMapper null The AttributeMapper strategy responsible for mapping starting subflow input attributes from a suspending parent flow. inputMapping(s) empty Mappings executed when mapping input data from the parent flow to a newly spawned sub flow. Each list item must be a String, a Map or a List. If the list item is a simple String value, ...
RandomGuid: Globally unique identifier generator. In the multitude of java GUID generators, I found none that guaranteed randomness. GUIDs are guaranteed to be globally unique by using ethernet MACs, IP addresses, time elements, and sequential numbers. GUIDs are not expected to be random and most often are easy/possible to guess given a sample from a given generator. SQL Server, for example generates GUID that are unique but sequencial within a given instance. GUIDs can be used as security devices to hide things such as files within a filesystem where listings are unavailable (e.g. files that are served up ...
DispatcherServlet: Central dispatcher for use within the web MVC framework, e.g. for web UI controllers or HTTP-based remote service exporters. Dispatches to registered handlers for processing a web request. This servlet is very flexible: It can be used with just about any workflow, with the installation of the appropriate adapter classes. It offers the following functionality that distinguishes it from other request-driven web MVC frameworks: It is based around a JavaBeans configuration mechanism. It can use any HandlerMapping implementation - whether standard, or provided as part of an application - to control ...
FlowAction: Struts Action that acts a front controller entry point into the web flow system. A single FlowAction manages all flow executions by parameterization with the appropriate flowId in views that start new flow executions. Requests are managed by and delegated to a org.springframework.webflow.execution.FlowExecutionManager , allowing reuse of common front flow controller logic in other environments. Consult the JavaDoc of that class for more information on how requests are processed. On each request received by this action, a StrutsEvent object is created as input to the web flow system. This external ...
ServletWrappingController: Spring Controller implementation that wraps a servlet instance which it manages internally. Such a wrapped servlet is not known outside of this controller; its entire lifecycle is covered here (in contrast to ServletForwardingController). Useful to invoke an existing servlet via Spring's dispatching infrastructure, for example to apply Spring HandlerInterceptors to its requests. This will work even in a Servlet 2.2 container that does not support Servlet filters. In particular, the main intent of this controller is to allow for applying Spring's OpenSessionInViewInterceptor or OpenPersistenceManagerInViewInterceptor ...
AbstractController: Convenient superclass for controller implementations, using the Template Method design pattern. As stated in the Controller interface, a lot of functionality is already provided by certain abstract base controllers. The AbstractController is one of the most important abstract base controller providing basic features such as the generation of caching headers and the enabling or disabling of supported methods (GET/POST). Workflow ( and that defined by interface ): handleRequest() 55 will be called by the DispatcherServlet Inspection of supported methods (ServletException if request method is not ...
ResourceServlet: Simple servlet that can expose an internal resource, including a default URL if the specified resource is not found. An alternative, for example, to trying and catching exceptions when using JSP include. A further usage of this servlet is the ability to apply last-modified timestamps to quasi-static resources (typically JSPs). This can happen as bridge to parameter-specified resources, or as proxy for a specific target resource (or a list of specific target resources to combine). A typical usage would map a URL like "/ResourceServlet" onto an instance of this servlet, and use the "JSP include" ...
ServletForwardingController: Spring Controller implementation that forwards to a named servlet, i.e. the "servlet-name" in web.xml rather than a URL path mapping. A target servlet doesn't even need a "servlet-mapping" in web.xml in the first place: A "servlet" declaration is sufficient. Useful to invoke an existing servlet via Spring's dispatching infrastructure, for example to apply Spring HandlerInterceptors to its requests. This will work even in a Servlet 2.2 container that does not support Servlet filters. In particular, the main intent of this controller is to allow for applying Spring's OpenSessionInViewInterceptor ...
AbstractJasperReportsView: Base class for all JasperReports views. Applies on-the-fly compilation of report designs as required and coordinates the rendering process. The resource path of the main report needs to be specified as url . This class is responsible for getting report data from the model that has been provided to the view. The default implementation checks for a model object under the specified reportDataKey first, then falls back to looking for a value of type JRDataSource , java.util.Collection , object array (in that order). If no JRDataSource can be found in the model, then reports will be filled using the ...
ActionState: A transitionable state that executes one or more actions when entered. When the action(s) are executed, this state responds to their result(s) to decide where to go next. If more than one action is configured, they are executed in an ordered chain until one returns a result event that matches a valid state transition out of this state. This is a form of the Chain of Responsibility (CoR) pattern. The result of an action's execution is treated as a contributing criterion for a state transition. In addition, anything else in the Flow's RequestContext may be tested as part of custom transitional criteria, ...
ContextLoaderPlugIn: Struts 1.1 PlugIn that loads a Spring application context for the Struts ActionServlet. This context will automatically refer to the root WebApplicationContext (loaded by ContextLoaderListener/Servlet) as parent. The default namespace of the WebApplicationContext is the name of the Struts ActionServlet, suffixed with "-servlet" (e.g. "action-servlet"). The default location of the XmlWebApplicationContext configuration file is therefore "/WEB-INF/action-servlet.xml". <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"/> The location of the context configuration files can ...
DelegatingActionProxy: Proxy for a Spring-managed Struts 1.1 Action that's defined in ContextLoaderPlugIn's WebApplicationContext. The proxy is defined in the Struts config file, specifying this class as action class. It will delegate to a Struts Action bean in the ContextLoaderPlugIn context. <action path="/login" type="org.springframework.web.struts.DelegatingActionProxy"/> The name of the Action bean in the WebApplicationContext will be determined from the mapping path and module prefix. This can be customized by overriding the determineActionBeanName method. Example: mapping path "/login" -> bean name "/login" ...
DelegatingRequestProcessor: Subclass of Struts' default RequestProcessor that looks up Spring-managed Struts 1.1 Actions defined in ContextLoaderPlugIn's WebApplicationContext. In the Struts config file, you can either specify the original Action class (as when generated by XDoclet), or no Action class at all. In any case, Struts will delegate to an Action bean in the ContextLoaderPlugIn context. <action path="/login" type="myapp.MyAction"/> or <action path="/login"/> The name of the Action bean in the WebApplicationContext will be determined from the mapping path and module prefix. This can be customized by overriding ...
ParameterMethodNameResolver: Implementation of MethodNameResolver which supports several strategies for mapping parameter values to the names of methods to invoke. The simplest strategy looks for a specific named parameter, whose value is considered the name of the method to invoke. The name of the parameter may be specified as a JavaBean property, if the default action is not acceptable. The second strategy uses the very existence of a request parameter (i.e. a request parameter with a certain name is found) as an indication that a method with the same name should be dispatched to. In this case, the actual request parameter ...
FlowAttributeMapper: A service interface that maps attributes between two flows. An attribute mapper may map attributes of a parent flow down to a child flow as input when the child is spawned as a subflow. In addition, a mapper may map attributes of a child flow scope back up to a resuming parent flow, as output when the child session ends and control is returned to the parent flow. For example, say you have the following parent flow session: Parent Flow Session 1 --------------------- - flowId=myFlow - flowScope=[map:attr1=value1, attr2=value2, attr3=value3] For "Parent Flow Session 1" above, there are 3 attributes ...
FlowExecutionManager: A manager for the executing flows of the application. This object is responsible for creating new flow executions as requested by the client, as well as signaling events for processing by existing, paused executions (that are waiting to be resumed in response to a user event). The onEvent(Event) 55 method implements the following algorithm: Look for a flow execution id in the event (in a parameter named "_flowExecutionId"). If no flow execution id is found, a new flow execution is created. The top-level flow for which the execution is created is determined by first looking for a flow id specified ...
MultiAction: Action implementation that bundles two or more action execution methods into a single class. Action execution methods defined by subclasses must adhere to the following signature: public Event ${method}(RequestContext context) throws Exception; When this action is invoked, by default the id of the calling action state state is treated as the action execution method name. Alternatively, the execution method name may be explicitly specified as a property of the calling action state. For example, the following action state definition: <action-state id="search"> <action bean="my.search.action"/> ...
ClientContinuationFlowExecutionStorage: Flow execution storage implementation that will store a flow execution as a continuation on the client side. It will actually encode the state of the flow execution in the unique id that is returned from the save 55 method. The load method just decodes the incoming id and restores the FlowExecution object. Note that all clients in a web flow based application need to include the unique flow execution id in each event they signal to the system. For HTTP based clients, the flow execution id is sent using a request parameter. If you're using client side continuations, you should make sure to use the ...

Home | Contact Us | Privacy Policy | Terms of Service