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

Quick Search    Search Deep

Page 1   2   3  
org.springframework.aop.* (108)org.springframework.beans.* (125)org.springframework.cache.* (2)
org.springframework.context.* (46)org.springframework.core.* (27)org.springframework.dao.* (18)
org.springframework.ejb.* (13)org.springframework.jca.* (25)org.springframework.jdbc.* (110)
org.springframework.jms.* (37)

Package Samples:

org.springframework.context.support: This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.  
org.springframework.aop.framework.autoproxy.target: Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.  
org.springframework.aop.framework.autoproxy: Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.  
org.springframework.core.io: Basic classes facilitating exception handling, and providing core interfaces that are not specific to any part of the framework.  
org.springframework.jca.cci.object: This package contains Spring's support for the Common Client Interface (CCI), as defined by the J2EE Connector Architecture.  
org.springframework.jdbc.core.support: Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.  
org.springframework.dao.support: Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.  
org.springframework.jms.support.destination: This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.  
org.springframework.jdbc.support.rowset: Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.  
org.springframework.jca.cci.core.support: Provides the core JCA CCI support, based on CciTemplate and its associated callback interfaces.  
org.springframework.jdbc.support: The classes in this package make JDBC easier to use and reduce the likelihood of common errors.  
org.springframework.jms.support: This package contains integration classes for JMS, allowing for Spring-style JMS access.  
org.springframework.beans.factory.xml: The core package implementing Spring's lightweight Inversion of Control (IoC) container.  
org.springframework.aop.target: Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.  
org.springframework.core.io.support: Generic abstraction for (file-based) resources, used throughout the framework.  
org.springframework.beans.support: This package contains interfaces and classes for manipulating Java beans.  
org.springframework.jms.core.support: Core package of the JMS support.  
org.springframework.aop.framework.adapter
org.springframework.aop.framework.autoproxy.metadata
org.springframework.aop.framework

Classes:

SingletonBeanFactoryLocator: Keyed-singleton implementation of BeanFactoryLocator, which leverages existing Spring constructs. This is normally accessed through DefaultLocatorFactory, but may also be used directly. Please see the warning in BeanFactoryLocator's javadoc about appropriate usage of singleton style BeanFactoryLocator implementations. It is the opinion of the Spring team that the use of this class and similar classes is unnecessary except (sometimes) for a small amount of glue code. Excessive usage will lead to code that is more tightly coupled, and harder to modify or test. In this implementation, a BeanFactory ...
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, ...
JtaTransactionManager: PlatformTransactionManager implementation for JTA, i.e. J2EE container transactions. Can also work with a locally configured JTA implementation. This transaction manager is appropriate for handling distributed transactions, i.e. transactions that span multiple resources, and for managing transactions on a J2EE Connector (e.g. a persistence toolkit registered as JCA Connector). For a single JDBC DataSource, DataSourceTransactionManager is perfectly sufficient, and for accessing a single resource with Hibernate (including transactional cache), HibernateTransactionManager is appropriate. Transaction ...
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, ...
MethodInvokingFactoryBean: FactoryBean which returns a value which is the result of a static or instance method invocation. For most use cases it is better to just use the container's built-in factory-method support for the same purpose, since that is smarter at converting arguments. This factory bean is still useful though when you need to call a method which doesn't return any value (for example, a static class method to force some sort of initialization to happen). This use case is not supported by factory-methods, since a return value is needed to become the bean. Note that as it is expected to be used mostly for accessing ...
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 ...
HibernateTransactionManager: PlatformTransactionManager implementation for a single Hibernate SessionFactory. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread Session per factory. SessionFactoryUtils and HibernateTemplate are aware of thread-bound Sessions and participate in such transactions automatically. Using either is required for Hibernate access code that needs to support this transaction handling mechanism. Supports custom isolation levels, and timeouts that get applied as appropriate Hibernate query timeouts. To support the latter, application code must either ...
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 ...
HibernateTransactionManager: PlatformTransactionManager implementation for a single Hibernate SessionFactory. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread Session per factory. SessionFactoryUtils and HibernateTemplate are aware of thread-bound Sessions and participate in such transactions automatically. Using either is required for Hibernate access code that needs to support this transaction handling mechanism. Supports custom isolation levels, and timeouts that get applied as appropriate Hibernate query timeouts. To support the latter, application code must either ...
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 ...
HibernateTemplate: Helper class that simplifies Hibernate data access code, and converts checked HibernateExceptions into unchecked DataAccessExceptions, following the org.springframework.dao exception hierarchy. Uses the same SQLExceptionTranslator mechanism as JdbcTemplate. Typically used to implement data access or business logic services that use Hibernate within their implementation but are Hibernate-agnostic in their interface. The latter or code calling the latter only have to deal with domain objects, query objects, and org.springframework.dao exceptions. The central method is "execute", supporting Hibernate ...
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 ...
HibernateTemplate: Helper class that simplifies Hibernate data access code, and converts checked HibernateExceptions into unchecked DataAccessExceptions, following the org.springframework.dao exception hierarchy. Uses the same SQLExceptionTranslator mechanism as JdbcTemplate. Typically used to implement data access or business logic services that use Hibernate within their implementation but are Hibernate-agnostic in their interface. The latter or code calling the latter only have to deal with domain objects, query objects, and org.springframework.dao exceptions. The central method is "execute", supporting Hibernate ...
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 ...
BeanFactory: The root interface for accessing a Spring IoC container. This interface is implemented by objects that hold a number of bean definitions, each uniquely identified by a String name. Depending on the bean definition, the factory will return either an independent instance of a contained object (the Prototype design pattern), or a single shared instance (a superior alternative to the Singleton design pattern, in which the instance is a singleton in the scope of the factory). Which type of instance will be returned depends on the bean factory configuration - the API is the same. The Singleton approach ...
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, ...

Home | Contact Us | Privacy Policy | Terms of Service