| Package Name | Comment |
| org.springframework.aop |
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
Any AOP Alliance MethodInterceptor is usable in Spring.
Spring AOP also offers:
- Introduction support
- A Pointcut abstraction, supporting "static" pointcuts
(class and method-based) and "dynamic" pointcuts (also considering method arguments).
There are currently no AOP Alliance interfaces for pointcuts.
- A full range of advice types, including around, before, after returning and throws advice.
- Extensibility allowing arbitrary custom advice types to
be plugged in without modifying the core framework.
Spring AOP can be used programmatically or (preferably)
integrated with the Spring IoC container.
|
| org.springframework.aop.aspectj |
AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5
annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut
implementation that allows use of the AspectJ pointcut expression language with the Spring AOP
runtime framework.
Note that use of this package does not require the use of the ajc compiler
or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ
functionality, with consistent semantics, with the proxy-based Spring AOP framework.
|
| org.springframework.aop.aspectj.annotation |
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
Normally to be used through an AspectJAutoProxyCreator rather than directly.
|
| org.springframework.aop.aspectj.autoproxy |
Base classes enabling auto-proxying based on AspectJ.
Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
|
| org.springframework.aop.config |
Support package for declarative AOP configuration,
with XML schema being the primary configuration format.
|
| org.springframework.aop.framework |
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
Spring AOP supports proxying interfaces or classes, introductions, and offers
static and dynamic pointcuts.
Any Spring AOP proxy can be cast to the ProxyConfig AOP configuration interface
in this package to add or remove interceptors.
The ProxyFactoryBean is a convenient way to create AOP proxies in a BeanFactory
or ApplicationContext. However, proxies can be created programmatically using the
ProxyFactory class.
|
| org.springframework.aop.framework.adapter |
SPI package allowing Spring AOP framework to handle arbitrary advice types.
Users who want merely to use the Spring AOP framework, rather than extend
its capabilities, don't need to concern themselves with this package.
You may wish to use these adapters to wrap Spring-specific advices, such as MethodBeforeAdvice,
in MethodInterceptor, to allow their use in another AOP framework supporting the AOP Alliance interfaces.
These adapters do not depend on any other Spring framework classes to allow such usage.
|
| org.springframework.aop.framework.autoproxy |
Bean post-processors for use in ApplicationContexts to simplify AOP usage
by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
The various post-processors in this package need only be added to an ApplicationContext
(typically in an XML bean definition document) to automatically proxy selected beans.
NB: Automatic auto-proxying is not supported for BeanFactory implementations,
as post-processors beans are only automatically detected in application contexts.
Post-processors can be explicitly registered on a ConfigurableBeanFactory instead.
|
| org.springframework.aop.framework.autoproxy.target |
Generic support classes for target source creation.
|
| org.springframework.aop.interceptor |
Provides miscellaneous interceptor implementations.
More specific interceptors can be found in corresponding
functionality packages, like "transaction" and "orm".
|
| org.springframework.aop.scope |
Support for AOP-based scoping of target objects, with configurable backend.
|
| org.springframework.aop.support |
Convenience classes for using Spring's AOP API.
|
| org.springframework.aop.support.annotation |
Annotation support for AOP pointcuts.
|
| org.springframework.aop.target |
This package contains implementations of the org.springframework.aop.TargetSource interface.
The simplest implementation is the SingletonTargetSource, used by default in the AOP framework
to wrap a single target instance. This is normally appropriate.
Other provided implementations include pooling implementations, that provide a target
from a pool for each request, ensuring a single threaded programming model; and a
"prototype" implementation, that uses a new target instance for each invocation.
|
| org.springframework.aop.target.dynamic |
Support for AOP-based refreshing of target objects.
|
| org.springframework.beans |
This package contains interfaces and classes for manipulating Java beans.
It is used by most other Spring packages.
A BeanWrapper object may be used to set and get bean properties,
singly or in bulk.
The classes in this package are discussed in Chapter 11 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
|
| org.springframework.beans.annotation |
Support package for beans-style handling of Java 5 annotations.
|
| org.springframework.beans.factory |
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Provides an alternative to the Singleton and Prototype design
patterns, including a consistent approach to configuration management.
Builds on the org.springframework.beans package.
This package and related packages are discussed in Chapter 11 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
|
| org.springframework.beans.factory.access |
Helper infrastructure to locate and access bean factories.
Note: This package is only relevant for special sharing of bean
factories, for example behind EJB facades. It is not used in a
typical web application or standalone application.
|
| org.springframework.beans.factory.annotation |
Support package for annotation-driven bean configuration.
|
| org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
| org.springframework.beans.factory.generic |
Support package for generic BeanFactory access,
leveraging Java 5 generics in the accessor API.
|
| org.springframework.beans.factory.parsing |
Support infrastructure for bean definition parsing.
|
| org.springframework.beans.factory.serviceloader |
Support package for the JDK 1.6 ServiceLoader facility.
|
| org.springframework.beans.factory.support |
Classes supporting the org.springframework.beans.factory package.
Contains abstract base classes for BeanFactory implementations.
|
| org.springframework.beans.factory.wiring |
Mechanism to determine bean wiring metadata from a bean instance.
Foundation for aspect-driven bean configuration.
|
| org.springframework.beans.factory.xml |
Contains an abstract XML-based BeanFactory implementation,
including a standard "spring-beans" DTD.
|
| org.springframework.beans.propertyeditors |
Properties editors used to convert from String values to object
types such as java.util.Properties.
Some of these editors are registered automatically by BeanWrapperImpl.
"CustomXxxEditor" classes are intended for manual registration in
specific binding processes, as they are localized or the like.
|
| org.springframework.beans.support |
Classes supporting the org.springframework.beans package,
such as utility classes for sorting and holding lists of beans.
|
| org.springframework.cache.ehcache |
Support classes for the open source cache
EHCache,
allowing to set up an EHCache CacheManager and Caches
as beans in a Spring context.
|
| org.springframework.context |
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.
There is no necessity for Spring applications to depend
on ApplicationContext or even BeanFactory functionality
explicitly. One of the strengths of the Spring architecture
is that application objects can often be configured without
any dependency on Spring-specific APIs.
|
| org.springframework.context.access |
Helper infrastructure to locate and access shared application contexts.
Note: This package is only relevant for special sharing of application
contexts, for example behind EJB facades. It is not used in a typical
web application or standalone application.
|
| org.springframework.context.annotation |
Annotation support for context configuration,
including classpath scanning for autowire candidates.
|
| org.springframework.context.config |
Support package for advanced application context configuration,
with XML schema being the primary configuration format.
|
| org.springframework.context.event |
Support classes for application events, like standard context events.
To be supported by all major application context implementations.
|
| org.springframework.context.i18n |
Abstraction for determining the current Locale,
plus global holder that exposes a thread-bound Locale.
|
| org.springframework.context.support |
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
|
| org.springframework.context.weaving |
Load-time weaving support for a Spring application context, building on Spring's
{@link org.springframework.instrument.classloading.LoadTimeWeaver} abstraction.
|
| org.springframework.core |
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
|
| org.springframework.core.annotation |
Core support package for Java 5 annotations.
|
| org.springframework.core.enums |
Interfaces and classes for type-safe enum support on JDK >= 1.3.
This enum abstraction support codes and labels.
|
| org.springframework.core.io |
Generic abstraction for (file-based) resources, used throughout the framework.
|
| org.springframework.core.io.support |
Support classes for Spring's resource abstraction.
Includes a ResourcePatternResolver mechanism.
|
| org.springframework.core.style |
Support for styling values as Strings, with ToStringCreator as central class.
|
| org.springframework.core.task |
This package defines Spring's core TaskExecutor abstraction,
and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
|
| org.springframework.core.task.support |
Support classes for Spring's TaskExecutor abstraction.
Includes an adapter for the JDK 1.5 Executor interface.
|
| org.springframework.core.type |
Core support package for type introspection.
|
| org.springframework.core.type.classreading |
Core support package for type introspection through ASM-based class reading.
|
| org.springframework.core.type.filter |
Core support package for type filtering (e.g. for classpath scanning).
|
| org.springframework.dao |
Exception hierarchy enabling sophisticated error handling independent
of the data access approach in use. For example, when DAOs and data
access frameworks use the exceptions in this package (and custom
subclasses), calling code can detect and handle common problems such
as deadlocks without being tied to a particular data access strategy,
such as JDBC.
All these exceptions are unchecked, meaning that calling code can
leave them uncaught and treat all data access exceptions as fatal.
The classes in this package are discussed in Chapter 9 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
|
| org.springframework.dao.annotation |
Annotation support for DAOs. Contains a bean post-processor for translating
persistence exceptions based on a repository stereotype annotation.
|
| org.springframework.dao.support |
Support classes for DAO implementations,
providing miscellaneous utility methods.
|
| org.springframework.ejb.access |
This package contains classes that allow easy access to EJBs.
The basis are AOP interceptors run before and after the EJB invocation.
In particular, the classes in this package allow transparent access
to stateless session beans (SLSBs) with local interfaces, avoiding
the need for application code using them to use EJB-specific APIs
and JNDI lookups, and work with business interfaces that could be
implemented without using EJB. This provides a valuable decoupling
of client (such as web components) and business objects (which may
or may not be EJBs). This gives us the choice of introducing EJB
into an application (or removing EJB from an application) without
affecting code using business objects.
The motivation for the classes in this package are discussed in Chapter 11 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
However, the implementation and naming of classes in this package has changed.
It now uses FactoryBeans and AOP, rather than the custom bean definitions described in
Expert One-on-One J2EE.
|
| org.springframework.ejb.config |
Support package for EJB/J2EE-related configuration,
with XML schema being the primary configuration format.
|
| org.springframework.ejb.support |
Superclasses to make implementing EJBs simpler and less error-prone,
as well as guaranteeing a Spring BeanFactory is available to EJBs.
This promotes good practice, with EJB services used for transaction
management, thread management, and (possibly) remoting, while
business logic is implemented in easily testable POJOs.
In this model, the EJB is a facade, with as many POJO helpers
behind the BeanFactory as required.
The classes in this package are discussed in Chapter 11 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
The present version has changed somewhat, but has the same goals.
Note that the default behavior is to look for an EJB enviroment variable
with name ejb/BeanFactoryPath that specifies the
location on the classpath of an XML bean factory definition
file (such as /com/mycom/mypackage/mybeans.xml).
If this JNDI key is missing, your EJB subclass won't successfully
initialize in the container.
|
| org.springframework.instrument |
Support package for class instrumentation.
See subpackages for specific adapters.
|
| org.springframework.instrument.classloading |
Support package for load time weaving based on class loaders,
as required by JPA providers (but not JPA-specific).
|
| org.springframework.instrument.classloading.glassfish |
Support for class instrumentation on GlassFish / Sun Application Server.
|
| org.springframework.instrument.classloading.oc4j |
Support for class instrumentation on Oracle OC4J.
|
| org.springframework.instrument.classloading.tomcat |
Support for class instrumentation on Apache Tomcat.
|
| org.springframework.instrument.classloading.weblogic |
Support for class instrumentation on BEA WebLogic 10.
|
| org.springframework.jca.cci |
This package contains Spring's support for the Common Client Interface (CCI),
as defined by the J2EE Connector Architecture. It is conceptually similar
to the org.springframework.jdbc package, providing the same
levels of data access abstraction.
|
| org.springframework.jca.cci.connection |
Provides a utility class for easy ConnectionFactory access,
a PlatformTransactionManager for local CCI transactions,
and various simple ConnectionFactory proxies/adapters.
|
| org.springframework.jca.cci.core |
Provides the core JCA CCI support, based on CciTemplate
and its associated callback interfaces.
|
| org.springframework.jca.cci.core.support |
Classes supporting the org.springframework.jca.cci.core package.
Contains a DAO base class for CciTemplate usage.
|
| org.springframework.jca.cci.object |
The classes in this package represent EIS operations as threadsafe,
reusable objects. This higher level of CCI abstraction depends on the
lower-level abstraction in the org.springframework.jca.cci.core package.
Exceptions thrown are as in the org.springframework.dao package,
meaning that code using this package does not need to worry about error handling.
|
| org.springframework.jca.context |
Integration package that allows for deploying a Spring application context
as a JCA 1.5 compliant RAR file.
|
| org.springframework.jca.endpoint |
This package provides a facility for generic JCA message endpoint management.
|
| org.springframework.jca.support |
Provides generic support classes for JCA usage within Spring,
mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
|
| org.springframework.jca.work |
Convenience classes for scheduling based on the JCA 1.5 WorkManager facility,
as supported within JCA 1.5 ResourceAdapters.
|
| org.springframework.jdbc |
The classes in this package make JDBC easier to use and
reduce the likelihood of common errors. In particular, they:
- Simplify error handling, avoiding the need for try/catch/final
blocks in application code.
- Present exceptions to application code in a generic hierarchy of
unchecked exceptions, enabling applications to catch data access
exceptions without being dependent on JDBC, and to ignore fatal
exceptions there is no value in catching.
- Allow the implementation of error handling to be modified
to target different RDBMSes without introducing proprietary
dependencies into application code.
This package and related packages are discussed in Chapter 9 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
|
| org.springframework.jdbc.core |
Provides the core JDBC framework, based on JdbcTemplate
and its associated callback interfaces and helper objects.
|
| org.springframework.jdbc.core.metadata |
Context metadata abstraction for the configuration and execution of a stored procedure call.
|
| org.springframework.jdbc.core.namedparam |
JdbcTemplate variant with named parameter support.
NamedParameterJdbcTemplate is a wrapper around JdbcTemplate that adds
support for named parameter parsing. It does not implement the JdbcOperations
interface or extend JdbcTemplate, but implements the dedicated
NamedParameterJdbcOperations interface.
If you need the full power of Spring JDBC for less common operations, use
the getJdbcOperations() method of NamedParameterJdbcTemplate and
work with the returned classic template, or use a JdbcTemplate instance directly.
|
| org.springframework.jdbc.core.simple |
Simplification layer over JdbcTemplate for Java 5 and above.
SimpleJdbcTemplate is a wrapper around JdbcTemplate that takes advantage
of varargs and autoboxing. It also offers only a subset of the methods
available on JdbcTemplate: Hence, it does not implement the JdbcOperations
interface or extend JdbcTemplate, but implements the dedicated
SimpleJdbcOperations interface.
If you need the full power of Spring JDBC for less common operations,
use the getJdbcOperations() method of SimpleJdbcTemplate and work
with the returned classic template, or use a JdbcTemplate instance directly.
|
| org.springframework.jdbc.core.support |
Classes supporting the org.springframework.jdbc.core package.
Contains a DAO base class for JdbcTemplate usage.
|
| org.springframework.jdbc.datasource |
Provides a utility class for easy DataSource access,
a PlatformTransactionManager for a single DataSource,
and various simple DataSource implementations.
|
| org.springframework.jdbc.datasource.lookup |
Provides a strategy for looking up JDBC DataSources by name.
|
| org.springframework.jdbc.object |
The classes in this package represent RDBMS queries, updates,
and stored procedures as threadsafe, reusable objects. This approach
is modelled by JDO, although of course objects returned by queries
are "disconnected" from the database.
This higher level of JDBC abstraction depends on the lower-level
abstraction in the org.springframework.jdbc.core package.
Exceptions thrown are as in the org.springframework.dao package,
meaning that code using this package does not need to implement JDBC or
RDBMS-specific error handling.
This package and related packages are discussed in Chapter 9 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
|
| org.springframework.jdbc.support |
Support classes for the JDBC framework, used by the classes in the
jdbc.core and jdbc.object packages. Provides a translator from
SQLExceptions Spring's generic DataAccessExceptions.
Can be used independently, for example in custom JDBC access code,
or in JDBC-based O/R mapping layers.
|
| org.springframework.jdbc.support.incrementer |
Provides a support framework for incrementing database table values
via sequences, with implementations for various databases.
Can be used independently, for example in custom JDBC access code.
|
| org.springframework.jdbc.support.lob |
Provides a stategy interface for Large OBject handling,
with implementations for various databases.
Can be used independently from jdbc.core and jdbc.object,
for example in custom JDBC access code.
|
| org.springframework.jdbc.support.nativejdbc |
Provides a mechanism for extracting native implementations of JDBC
interfaces from wrapper objects that got returned from connection pools.
Can be used independently, for example in custom JDBC access code.
|
| org.springframework.jdbc.support.rowset |
Provides a convenient holder for disconnected result sets.
Supported by JdbcTemplate, but can be used independently too.
|
| org.springframework.jms |
This package contains integration classes for JMS,
allowing for Spring-style JMS access.
|
| org.springframework.jms.config |
Support package for declarative messaging configuration,
with XML schema being the primary configuration format.
|
| org.springframework.jms.connection |
Provides a PlatformTransactionManager implementation for a single
JMS ConnectionFactory, and a SingleConnectionFactory adapter.
|
| org.springframework.jms.core |
Core package of the JMS support.
Provides a JmsTemplate class and various callback interfaces.
|
| org.springframework.jms.core.support |
Classes supporting the org.springframework.jms.core package.
Contains a base class for JmsTemplate usage.
|
| org.springframework.jms.listener |
This package contains the base message listener container facility.
It also offers the DefaultMessageListenerContainer and SimpleMessageListenerContainer
implementations, based on the plain JMS client API.
|
| org.springframework.jms.listener.adapter |
Message listener adapter mechanism that delegates to target listener
methods, converting messages to appropriate message content types
(such as String or byte array) that get passed into listener methods.
|
| org.springframework.jms.listener.endpoint |
This package provides JCA-based endpoint management for JMS message listeners.
|
| org.springframework.jms.listener.serversession |
This package contains the ServerSessionMessageListenerContainer implementation,
based on the standard JMS ServerSessionPool API.
|
| org.springframework.jms.remoting |
Remoting classes for transparent Java-to-Java remoting via a JMS provider.
Allows the target service to be load-balanced across a number of queue
receivers, and provides a level of indirection between the client and the
service: They only need to agree on a queue name and a service interface.
|
| org.springframework.jms.support |
This package provides generic JMS support classes,
to be used by higher-level classes like JmsTemplate.
|
| org.springframework.jms.support.converter |
Provides a MessageConverter abstraction to convert
between Java objects and JMS messages.
|
| org.springframework.jms.support.destination |
Support classes for Spring's JMS framework.
|
| org.springframework.jmx |
This package contains Spring's JMX support, which includes registration of
Spring-managed beans as JMX MBeans as well as access to remote JMX MBeans.
|
| org.springframework.jmx.access |
Provides proxy support for accessing MBean resources through standard Java interfaces.
|
| org.springframework.jmx.export |
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
|
| org.springframework.jmx.export.annotation |
JDK 1.5+ annotations for MBean exposure.
Hooked into Spring's JMX export infrastructure
via a special JmxAttributeSource implementation.
|
| org.springframework.jmx.export.assembler |
Provides a strategy for MBeanInfo assembly. Used by MBeanExporter to
determine the attributes and operations to expose for Spring-managed beans.
|
| org.springframework.jmx.export.metadata |
Provides generic JMX metadata classes and basic support for reading
JMX metadata in a provider-agnostic manner.
|
| org.springframework.jmx.export.naming |
Provides a strategy for ObjectName creation. Used by MBeanExporter
to determine the JMX names to use for exported Spring-managed beans.
|
| org.springframework.jmx.export.notification |
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
|
| org.springframework.jmx.support |
Contains support classes for connecting to local and remote MBeanServers
and for exposing an MBeanServer to remote clients.
|
| org.springframework.jndi |
The classes in this package make JNDI easier to use,
facilitating the accessing of configuration stored in JNDI,
and provide useful superclasses for JNDI access classes.
The classes in this package are discussed in Chapter 11 of
Expert One-On-One J2EE Design and Development
by Rod Johnson (Wrox, 2002).
|
| org.springframework.jndi.support |
Support classes for JNDI usage,
including a JNDI-based BeanFactory implementation.
|
| org.springframework.mail |
Spring's generic mail infrastructure.
Concrete implementations are provided in the subpackages.
|
| org.springframework.mail.javamail |
JavaMail support for Spring's mail infrastructure.
Provides an extended JavaMailSender interface and a MimeMessageHelper
class for convenient population of a JavaMail MimeMessage.
|
| org.springframework.metadata |
Package defining a facade for accessing source-level
metadata attributes at runtime.
|
| org.springframework.metadata.commons |
Attributes wrapper for
Commons Attributes.
|
| org.springframework.orm |
Root package for Spring's O/R Mapping integration classes.
Contains generic DataAccessExceptions related to O/R Mapping.
|
| org.springframework.orm.hibernate3 |
Package providing integration of
Hibernate3
with Spring concepts.
Contains SessionFactory helper classes, a template plus callback
for Hibernate access, and an implementation of Spring's transaction SPI
for local Hibernate transactions.
This package supports Hibernate 3.x only.
See the org.springframework.orm.hibernate package for Hibernate 2.1 support.
|
| org.springframework.orm.hibernate3.annotation |
Support package for the Hibernate3 Annotation add-on,
which supports EJB3-compliant JDK 1.5+ annotations for mappings.
|
| org.springframework.orm.hibernate3.support |
Classes supporting the org.springframework.orm.hibernate3 package.
Contains a DAO base class for HibernateTemplate usage.
|
| org.springframework.orm.ibatis |
Package providing integration of
iBATIS Database Layer
with Spring concepts.
Contains resource helper classes and template classes for
data access with the iBATIS SqlMapClient API.
|
| org.springframework.orm.ibatis.support |
Classes supporting the org.springframework.orm.ibatis package.
Contains a DAO base class for SqlMapClientTemplate usage.
|
| org.springframework.orm.jdo |
Package providing integration of JDO (Java Date Objects) with Spring concepts.
Contains PersistenceManagerFactory helper classes, a template plus callback for JDO
access, and an implementation of Spring's transaction SPI for local JDO transactions.
|
| org.springframework.orm.jdo.support |
Classes supporting the org.springframework.orm.jdo package.
Contains a DAO base class for JdoTemplate usage.
|
| org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
Contains EntityManagerFactory helper classes, a template plus callback for JPA access,
and an implementation of Spring's transaction SPI for local JPA transactions.
|
| org.springframework.orm.jpa.persistenceunit |
Internal support for managing JPA persistence units.
|
| org.springframework.orm.jpa.support |
Classes supporting the org.springframework.orm.jpa package.
Contains a DAO base class for JpaTemplate usage.
|
| org.springframework.orm.jpa.vendor |
Support classes for adapting to specific JPA vendors.
|
| org.springframework.orm.toplink |
Package providing integration of
Oracle TopLink
with Spring concepts.
Contains SessionFactory helper classes, a template plus callback
for TopLink access, and an implementation of Spring's transaction SPI
for local TopLink transactions.
|
| org.springframework.orm.toplink.support |
Classes supporting the org.springframework.orm.toplink package.
Contains a DAO base class for TopLinkTemplate usage.
|
| org.springframework.remoting |
Exception hierarchy for Spring's remoting infrastructure,
independent of any specific remote method invocation system.
|
| org.springframework.remoting.caucho |
This package provides remoting classes for Caucho's Hessian and Burlap
protocols: a proxy factory for accessing Hessian/Burlap services,
and an exporter for making beans available to Hessian/Burlap clients.
Hessian is a slim, binary RPC protocol over HTTP.
For information on Hessian, see the
Hessian website
Burlap is a slim, XML-based RPC protocol over HTTP.
For information on Burlap, see the
Burlap website
|
| org.springframework.remoting.httpinvoker |
Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
Uses Java serialization just like RMI, but provides the same ease of setup
as Caucho's HTTP-based Hessian and Burlap protocols.
HTTP invoker is the recommended protocol for Java-to-Java remoting.
It is more powerful and more extensible than Hessian and Burlap, at the
expense of being tied to Java. Neverthelesss, it is as easy to set up as
Hessian and Burlap, which is its main advantage compared to RMI.
|
| org.springframework.remoting.jaxrpc |
Remoting classes for Web Services via JAX-RPC.
This package provides proxy factories for accessing JAX-RPC
services and ports, and a support class for implementing
JAX-RPC Servlet endpoints.
|
| org.springframework.remoting.jaxrpc.support |
Support for specific JAX-RPC providers. Contains an Axis-specific
JaxRpcServicePostProcessor for declaratively registering bean mappings.
|
| org.springframework.remoting.jaxws |
Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC),
as included in Java 6 and Java EE 5. This package provides proxy
factories for accessing JAX-WS services and ports.
|
| org.springframework.remoting.rmi |
Remoting classes for conventional RMI and transparent remoting via
RMI invokers. Provides a proxy factory for accessing RMI services,
and an exporter for making beans available to RMI clients.
|
| org.springframework.remoting.soap |
SOAP-specific exceptions and support classes for Spring's remoting subsystem.
|
| org.springframework.remoting.support |
Generic support classes for remoting implementations.
Provides abstract base classes for remote proxy factories.
|
| org.springframework.scheduling |
General exceptions for Spring's scheduling support,
independent of any specific scheduling system.
|
| org.springframework.scheduling.backportconcurrent |
Scheduling convenience classes for the
JSR-166 backport
Executor mechanism, allowing to set up a ThreadPoolExecutor or
ScheduledThreadPoolExecutor as bean in a Spring context.
|
| org.springframework.scheduling.commonj |
Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager
facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.
|
| org.springframework.scheduling.concurrent |
Scheduling convenience classes for the JDK 1.5+ Executor mechanism
in the java.util.concurrent package, allowing to set
up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as bean in
a Spring context.
|
| org.springframework.scheduling.quartz |
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context. Also provides
convenience classes for implementing Quartz Jobs.
|
| org.springframework.scheduling.support |
Generic support classes for scheduling.
Provides a Runnable adapter for Spring's MethodInvoker.
|
| org.springframework.scheduling.timer |
Scheduling convenience classes for the JDK Timer,
allowing to set up Timers and ScheduledTimerTasks
as beans in a Spring context.
|
| org.springframework.scripting |
Core interfaces for Spring's scripting support.
|
| org.springframework.scripting.bsh |
Package providing integration of
BeanShell
into Spring's scripting infrastructure.
|
| org.springframework.scripting.config |
Support package for Spring's dynamic language machinery,
with XML schema being the primary configuration format.
|
| org.springframework.scripting.groovy |
Package providing integration of
Groovy
into Spring's scripting infrastructure.
|
| org.springframework.scripting.jruby |
Package providing integration of
JRuby
into Spring's scripting infrastructure.
|
| org.springframework.scripting.support |
Support classes for Spring's scripting package.
Provides a ScriptFactoryPostProcessor for turning ScriptFactory
definitions into scripted objects.
|
| org.springframework.stereotype |
Annotations denoting the roles of types or methods in the overall architecture
(at a conceptual, rather than implementation, level).
Intended for use by tools and aspects (making an ideal target for pointcuts).
|
| org.springframework.transaction |
Exception hierarchy for Spring's transaction infrastructure,
independent of any specific transaction management system.
Contains transaction manager, definition, and status interfaces.
|
| org.springframework.transaction.annotation |
JDK 1.5+ annotation for transaction demarcation.
Hooked into Spring's transaction interception infrastructure
via a special TransactionAttributeSource implementation.
|
| org.springframework.transaction.config |
Support package for declarative transaction configuration,
with XML schema being the primary configuration format.
|
| org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
Builds on the AOP infrastructure in org.springframework.aop.framework.
Any POJO can be transactionally advised with Spring.
The TransactionFactoryProxyBean can be used to create transactional
AOP proxies transparently to code that uses them.
The TransactionInterceptor is the AOP Alliance MethodInterceptor that
delivers transactional advice, based on the Spring transaction abstraction.
This allows declarative transaction management in any environment,
even without JTA if an application uses only a single database.
|
| org.springframework.transaction.jta |
Transaction SPI implementation for JTA.
|
| org.springframework.transaction.support |
Support classes for the org.springframework.transaction package.
Provides an abstract base class for transaction manager implementations,
and a template plus callback for transaction demarcation.
|
| org.springframework.ui |
Generic support for UI layer concepts.
Provides a generic ModelMap for model holding.
|
| org.springframework.ui.context |
Contains classes defining the application context subinterface
for UI applications. The theme feature is added here.
- If no
UiApplicationContextUtils.THEME_SOURCE_BEAN_NAME
bean is available in the context or parent context, a default ResourceBundleThemeSource
will be created for requested themes. In this case, the base name of the property file will match
with the theme name.
- If the bean is available in the context or parent context, a
basenamePrefix can be
set before the theme name for locating the property files like this:
<bean id="themeSource" class="org.springframework.ui.context.support.ResourceBundleThemeSource">
<property name="basenamePrefix"><value>theme.</value></property>
</bean>
in this case, the themes resource bundles will be named theme.<theme_name>XXX.properties.
- This can be defined at application level and/or at servlet level for web applications.
- Normal i18n features of Resource Bundles are available. So a theme message can be dependant
of both theme and locale.
- If messages in the resource bundles are in fact paths to resources(css, images, ...), make sure these resources
are directly available for the user and not, for example, under the WEB-INF directory.
Web packages add the resolution and the setting of the user current theme.
|
| org.springframework.ui.context.support |
Classes supporting the org.springframework.ui.context package.
Provides support classes for specialized UI contexts, e.g. for web UIs.
|
| org.springframework.ui.freemarker |
Support classes for setting up
FreeMarker
within a Spring application context.
|
| org.springframework.ui.jasperreports |
Support classes for
JasperReports.
|
| org.springframework.ui.velocity |
Support classes for setting up
Velocity
within a Spring application context.
|
| org.springframework.util |
Miscellaneous utility classes, such as String manipulation utilities,
a Log4J configurer, and a state holder for paged lists of objects.
|
| org.springframework.util.comparator |
Useful generic java.util.Comparator implementations,
such as an invertible comparator and a compound comparator.
|
| org.springframework.util.xml |
Miscellaneous utility classes for XML parsing and transformation,
such as error handlers that log warnings via Commons Logging.
|
| org.springframework.validation |
Provides data binding and validation functionality,
for usage in business and/or UI layers.
|
| org.springframework.web |
Common, generic interfaces that define minimal boundary points
between Spring's web infrastructure and other framework modules.
|
| org.springframework.web.bind |
Provides web-specific data binding functionality.
|
| org.springframework.web.bind.annotation |
Annotations for binding requests to controllers and handler methods
as well as for binding request parameters to method arguments.
|
| org.springframework.web.bind.support |
Support classes for web data binding.
|
| org.springframework.web.context |
Contains a variant of the application context interface for web applications,
and the ContextLoaderListener that bootstraps a root web application context.
|
| org.springframework.web.context.request |
Support for generic request context holding, in particular for
scoping of application objects per HTTP request or HTTP session.
|
| org.springframework.web.context.support |
Classes supporting the org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes.
|
| org.springframework.web.filter |
Provides generic filter base classes allowing for bean-style configuration.
|
| org.springframework.web.jsf |
Support classes for integrating a JSF web tier with a Spring middle tier
which is hosted in a Spring root WebApplicationContext.
Supports easy access to beans in the Spring root WebApplicationContext
from JSF EL expressions, for example in property values of JSF-managed beans.
|
| org.springframework.web.jsf.el |
Support classes for integrating a JSF 1.2 web tier with a Spring middle tier
which is hosted in a Spring root WebApplicationContext.
Supports JSF 1.2's ELResolver mechanism, providing closer integration
than JSF 1.1's VariableResolver mechanism allowed for.
|
| org.springframework.web.multipart |
Multipart resolution framework for handling file uploads.
Provides a MultipartResolver strategy interface,
and a generic extension of the HttpServletRequest interface
for accessing multipart files in web application code.
|
| org.springframework.web.multipart.commons |
MultipartResolver implementation for
Jakarta Commons FileUpload.
|
| org.springframework.web.multipart.support |
Support classes for the multipart resolution framework.
Contains property editors for multipart files, and a
servlet filter for multipart handling without Spring's web MVC.
|
| org.springframework.web.util |
Miscellaneous web utility classes, such as HTML escaping,
Log4J initialization, and cookie handling.
|