spring framework 2.0.6

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » J2EE » spring framework 2.0.6 
Spring Framework
License:Apache License Version 2.0
URL:http://www.springframework.org
Description:
Package NameComment
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.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.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.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, like 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.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.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.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.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.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.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.mail Spring's generic mail infrastructure. Concrete implementations are provided in the subpackages.
org.springframework.mail.cos MailSender implementation that uses Jason Hunter's COS (com.oreilly.servlet)
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.mock.jndi The simplest implementation of the JNDI SPI that could possibly work.

Useful for setting up a simple JNDI environment for test suites or standalone applications. If e.g. JDBC DataSources get bound to the same JNDI names as within a J2EE container, both application code and configuration can me reused without changes.

org.springframework.mock.web A comprehensive set of Servlet API mock objects, targeted at usage with Spring's web MVC framework. Useful for testing web contexts and controllers.

More convenient to use than dynamic mock objects (EasyMock) or existing Servlet API mock objects (MockObjects).

org.springframework.mock.web.portlet A comprehensive set of Portlet API mock objects, targeted at usage with Spring's web MVC framework. Useful for testing web contexts and controllers.

More convenient to use than dynamic mock objects (EasyMock) or existing Portlet API mock objects.

org.springframework.orm Root package for Spring's O/R Mapping integration classes. Contains generic DataAccessExceptions related to O/R Mapping.
org.springframework.orm.hibernate Package providing integration of Hibernate 2.1 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 2.1 only. See the org.springframework.orm.hibernate3 package for Hibernate 3.x support.

org.springframework.orm.hibernate.support Classes supporting the org.springframework.orm.hibernate package. Contains a DAO base class for HibernateTemplate usage.
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.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.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 1.3+ 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.test Superclasses for tests requiring Spring application contexts, including support for transactional execution of test cases, with automatic rollback on completion. Useful as base classes for application-specific tests.

The superclasses in this package are ideal for integration testing. Unit testing should not normally involve the Spring container, but should test classes in isolation.

org.springframework.test.annotation Support classes for annotation-driven tests.
org.springframework.test.jpa Support classes for tests based on the Java Persistence API.
org.springframework.test.web Helper classes for unit tests based on Spring's web support.
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, including a utility class for easy invocation of binding and validation.
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.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.cos MultipartResolver implementation for Jason Hunter's COS (com.oreilly.servlet).
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.portlet Provides JSR-168 portlets that integrate with the application context infrastructure, and the core interfaces and classes for the Portlet variant of Spring's web MVC framework.
org.springframework.web.portlet.bind Provides portlet-specific data binding functionality.
org.springframework.web.portlet.context Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes.
org.springframework.web.portlet.handler Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.portlet.multipart Multipart resolution framework for handling file uploads. Provides a PortletMultipartResolver strategy interface, and a generic extension of the ActionRequest interface for accessing multipart files in web application code.
org.springframework.web.portlet.mvc

Standard controller implementations for the portlet MVC framework that comes with Spring. Provides both abstract base classes and concrete implementations for often seen use cases.

A Controller - as defined in this package - is analogous to a Struts Action. Usually Controllers are JavaBeans to allow easy configuration using the {@link org.springframework.beans org.springframework.beans} package. Controllers define the C from so-called MVC paradigm and can be used in conjunction with the {@link org.springframework.web.portlet.ModelAndView ModelAndView} to achieve interactive applications. The view might be represented by a HTML interface, but, because of model and the controller being completely independent of the view, PDF views are possible, as well as for instance Excel views.

Especially useful to read, while getting into the Spring MVC framework are the following:

org.springframework.web.portlet.util Miscellaneous portlet utility classes.
org.springframework.web.servlet Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.

This package and related packages are discussed in Chapters 12 and 13 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).

org.springframework.web.servlet.handler Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.handler.metadata This package enables automatic web controller targeting. The only implementation at present is CommonsPathMapHandlerMapping, based on Commons Attributes source-level attributes, but metadata implementation is pluggable.
In this model, you don't need to map URLs onto controllers in your Spring XML web application context bean definition files. You merely need to set one or more PathMap attributes on each of your Controller classes, and new objects of these types will automatically be added to the relevant web application context.
Dependencies--whether expressed by via constructor arguments or JavaBean properties, will be resolved if possible using the middle tier definitions in the WebApplicationContext.

To use this feature, using the Commons Attributes implementation, perform the following steps:

  1. Invoke the Commons Attributes compiler on your application classes. The classes must be compiled into a Jar rather than the WEB-INF/classes directory.
  2. Run the Commons Attributes attribute indexer tool on the Jar containing your controllers.
  3. Use Commons Attributes syntax to define a PathMap attribute for each Controller you want mapped.
  4. Define a bean of type UrlHandlerMapping in your servletName-servlet.xml bean definition file in your web application. No parameters are required.

You can also use other HandlerMappings, such as BeanNameHandlerMapping, in the same servlet XML file.

org.springframework.web.servlet.i18n Locale support classes for Spring's web MVC framework. Provides standard LocaleResolver implementations, and a HandlerInterceptor for locale changes.
org.springframework.web.servlet.mvc

Standard controller implementations for the servlet MVC framework that comes with Spring. Provides both abstract base classes and concrete implementations for often seen use cases.

A Controller - as defined in this package - is analogous to a Struts Action. Usually Controllers are JavaBeans to allow easy configuration using the {@link org.springframework.beans org.springframework.beans} package. Controllers define the C from so-called MVC paradigm and can be used in conjunction with the {@link org.springframework.web.servlet.ModelAndView ModelAndView} to achieve interactive applications. The view might be represented by a HTML interface, but, because of model and the controller being completely independent of the view, PDF views are possible, as well as for instance Excel views.

How to actually set up a (web)application using the MVC framework Spring provides is explained in more detail in the MVC-Step-by-Step tutorial, also provided in this package (or have a look here for an online version). The classes contained by this package explain in more detail the actual workflow of some of the abstract and concrete controller and how to extend and fully use their functionality.

Especially useful to read, while getting into the Spring MVC framework are the following:

org.springframework.web.servlet.mvc.multiaction Package allowing MVC Controller implementations to handle requests at method rather than class level. This is useful when we want to avoid having many trivial controller classes, as can easily happen when using an MVC framework.

Typically a controller that handles multiple request types will extend MultiActionController, and implement multiple request handling methods that will be invoked by reflection if they follow this class' naming convention. Classes are analyzed at startup and methods cached, so the performance overhead of reflection in this approach is negligible.

This approach is analogous to the Struts 1.1 DispatcherAction class, but more sophisticated, as it supports configurable mapping from requests to URLs and allows for delegation as well as subclassing.

This package is discussed in Chapter 12 of Expert One-On-One J2EE Design and Development by Rod Johnson, and used in the sample application.

org.springframework.web.servlet.mvc.support Support package for MVC controllers. Contains a special HandlerMapping for controller conventions.
org.springframework.web.servlet.mvc.throwaway Throwaway command controllers are a WebWork/Maverick-style alternative to Spring's default Servlet/Struts-style Controller approach.
org.springframework.web.servlet.support Support classes for Spring's web MVC framework. Provides easy evaluation of the request context in views, and miscellaneous HandlerInterceptor implementations.
org.springframework.web.servlet.tags Spring's JSP standard tag library for JSP 1.2+. Supports JSP view implementations within Spring's web MVC framework. See spring.tld for descriptions of the various tags.
org.springframework.web.servlet.tags.form Spring's form tag library for JSP 1.2+. Supports JSP view implementations for Spring's web MVC framework. See spring-form.tld for descriptions of the various tags.
org.springframework.web.servlet.theme Theme support classes for Spring's web MVC framework. Provides standard ThemeResolver implementations, and a HandlerInterceptor for theme changes.

  • If you don't provide a bean of one of these classes as themeResolver, a FixedThemeResolver will be provided with the default theme name 'theme'.
  • If you use a defined FixedThemeResolver, you will able to use another theme name for default, but the users will stick on this theme.
  • With a CookieThemeResolver or SessionThemeResolver, you can allow the user to change his current theme.
  • Generally, you will put in the themes resource bundles the paths of CSS files, images and HTML constructs.
  • For retrieving themes data, you can either use the spring:theme tag in JSP or access via the RequestContext for other view technologies.
  • The pagedlist demo application uses themes
org.springframework.web.servlet.view Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.

Application developers don't usually need to implement views, as the framework provides standard views for JSPs, Velocity, XSLT, etc. However, the ability to implement custom views easily by subclassing the AbstractView class in this package can be very helpful if an application has unusual view requirements.

org.springframework.web.servlet.view.document Support classes for document generation, providing View implementations for PDF and Excel.
org.springframework.web.servlet.view.freemarker Support classes for the integration of FreeMarker as Spring web view technology. Contains a View implementation for FreeMarker templates.
org.springframework.web.servlet.view.jasperreports Support classes for the integration of JasperReports as Spring web view technology. Contains various View implementations for JasperReports.
org.springframework.web.servlet.view.tiles Support classes for the integration of Tiles (included in Struts) as Spring web view technology. Contains a View implementation for Tiles definitions.
org.springframework.web.servlet.view.velocity Support classes for the integration of Velocity as Spring web view technology. Contains a View implementation for Velocity templates.
org.springframework.web.servlet.view.xslt Support classes for XSLT, providing a View implementation for XSLT stylesheets.
org.springframework.web.struts Support classes for integrating a Struts web tier with a Spring middle tier which is typically hosted in a Spring root WebApplicationContext.

Supports easy access to the Spring root WebApplicationContext from Struts Actions via the ActionSupport and DispatchActionSupport classes. Actions have full access to Spring's WebApplicationContext facilities in this case, and explicitly look up Spring-managed beans.

Also supports wiring Struts Actions as Spring-managed beans in a ContextLoaderPlugIn context, passing middle tier references to them via bean references, using the Action path as bean name. There are two ways to make Struts delegate Action lookup to the ContextLoaderPlugIn:

  • Use DelegationActionProxy as Action "type" in struts-config. There's no further setup necessary; you can choose any RequestProcessor. Each such proxy will automatically delegate to the corresponding Spring-managed Action bean in the ContextLoaderPlugIn context.
  • Configure DelegatingRequestProcessor as "processorClass" in struts-config, using the original Action "type" (possibly generated by XDoclet) or no "type" at all. To also use Tiles, configure DelegatingTilesRequestProcessor instead.
org.springframework.web.util Miscellaneous web utility classes, such as HTML escaping, Log4J initialization, and cookie handling.
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.