GAD-DES03: Spring

Overview of Spring Framework

Introduction to Spring Framework

• • Dependency Injection and Inversion of Control
  • Modules
    • Core Container
    • Data Access/Integration
    • Web
    • AOP and Instrumentation
    • Test
  • Usage scenarios
    • Dependency Management and Naming Conventions
    • Logging
      • Not Using Commons Logging
      • Using SLF4J
      • Using Log4J

What’s New in Spring 3.0

• New Features and Enhancements in Spring 3.0
  • Java 5
  • Improved documentation
  • New module organization and build system
  • Overview of new features
    • Core APIs updated for Java 5
    • Spring Expression Language
    • The Inversion of Control (IoC) container
    • Java based bean metadata
    • Defining bean metadata within components
    • General purpose type conversion system and field formatting system
    • The Data Tier
    • The Web Tier
    • Comprehensive REST support
    • @MVC additions
    • Declarative model validation
    • Early support for Java EE 6
    • Support for embedded databases

Core Technologies

• The IoC container
  • Introduction to the Spring IoC container and beans
  • Bean overview
  • Dependencies
• 3.4.1. Dependency injection
• 3.4.2. Dependencies and configuration in detail
• 3.4.3. Using depends-on
• 3.4.4. Lazy-initialized beans
• 3.4.5. Autowiring collaborators
• 3.4.6. Method injection
• 3.4.6.1. Lookup method injection
• 3.4.6.2. Arbitrary method replacement
  • Bean scopes
• 3.5.1. The singleton scope
• 3.5.2. The prototype scope
• 3.5.3. Singleton beans with prototype-bean dependencies
• 3.5.4. Request, session, and global session scopes
• 3.5.5. Custom scopes
  • Customizing the nature of a bean
• 3.6.1. Lifecycle callbacks
• 3.6.2. ApplicationContextAware and BeanNameAware
• 3.6.3. Other Aware interfaces
  • Bean definition inheritance
  • Container extension points
  • Annotation-based container configuration
  • Classpath scanning and managed components
  • Java-based container configuration
  • Registering a LoadTimeWeaver
  • Additional Capabilities of the ApplicationContext
  • The BeanFactory
• Resources
  • Introduction
  • The Resource interface
  • Built-in Resource implementations
  • The ResourceLoader
  • The ResourceLoaderAware interface
  • Resources as dependencies
  • Application contexts and Resource paths
• Validation, Data Binding, and Type Conversion
  • Introduction
  • Validation using Spring’s Validator interface
  • Resolving codes to error messages
  • Bean manipulation and the BeanWrapper
  • Spring 3 Type Conversion
  • Spring 3 Field Formatting
  • Spring 3 Validation
• Spring Expression Language (SpEL)
  • Introduction
  • Feature Overview
  • Expression Evaluation using Spring’s Expression Interface
    • The EvaluationContext interface
      • Type Conversion
  • Expression support for defining bean definitions
    • XML based configuration
    • Annotation-based configuration
  • Language Reference
    • Literal expressions
    • Properties, Arrays, Lists, Maps, Indexers
    • Inline lists
    • Array construction
    • Methods
    • Operators
      • Relational operators
      • Logical operators
      • Mathematical operators
    • Assignment
    • Types
    • Constructors
    • Variables
      • The #this and #root variables
    • Functions
    • Bean references
    • Ternary Operator (If-Then-Else)
    • The Elvis Operator
    • Safe Navigation operator
    • Collection Selection
    • Collection Projection
    • Expression templating
  • Classes used in the examples
• Aspect Oriented Programming with Spring
  • Introduction
    • AOP concepts
    • Spring AOP capabilities and goals
    • AOP Proxies
  • @AspectJ support
    • Enabling @AspectJ Support
    • Declaring an aspect
    • Declaring a pointcut
    • Declaring advice
  • Schema-based AOP support
    • Declaring an aspect
    • Declaring a pointcut
    • Declaring advice
    • Introductions
    • Aspect instantiation models
    • Advisors
  • Choosing which AOP declaration style to use
    • Spring AOP or full AspectJ?
    • @AspectJ or XML for Spring AOP?
  • Mixing aspect types
  • Proxying mechanisms
    • Understanding AOP proxies
  • Programmatic creation of @AspectJ Proxies
  • Using AspectJ with Spring applications
    • Using AspectJ to dependency inject domain objects with Spring
    • Other Spring aspects for AspectJ
    • Configuring AspectJ aspects using Spring IoC
    • Load-time weaving with AspectJ in the Spring Framework
  • Further Resources
• Spring AOP APIs
  • Introduction
  • Pointcut API in Spring
    • Concepts
    • Operations on pointcuts
    • AspectJ expression pointcuts
    • Convenience pointcut implementations
  • Advice API in Spring
    • Advice lifecycles
    • Advice types in Spring
  • Advisor API in Spring
  • Using the ProxyFactoryBean to create AOP proxies
    • Basics
    • JavaBean properties
    • JDK- and CGLIB-based proxies
    • Proxying interfaces
    • Proxying classes
    • Using ‘global’ advisors
  • Concise proxy definitions
  • Creating AOP proxies programmatically with the ProxyFactory
  • Manipulating advised objects
  • Using the «autoproxy» facility
  • Using TargetSources
  • Defining new Advice types
  • Further resources
• Testing
  • Introduction to testing
  • Unit testing
    • Mock objects
    • Unit testing support classes
  • Integration testing
    • Overview
    • Goals of integration testing
    • JDBC testing support
    • Annotations
    • Spring TestContext Framework
    • PetClinic example
  • Further Resources

Data Access

• Transaction Management
  • Introduction to Spring Framework transaction management
  • Advantages of the Spring Framework’s transaction support model
  • Understanding the Spring Framework transaction abstraction
  • Synchronizing resources with transactions
  • Declarative transaction management
  • Programmatic transaction management
  • Choosing between programmatic and declarative transaction management
  • Application server-specific integration
  • Solutions to common problems
• DAO support
  • Introduction
  • Consistent exception hierarchy
  • Annotations used for configuring DAO or Repository classes
• Data access with JDBC
  • Introduction to Spring Framework JDBC
  • Using the JDBC core classes to control basic JDBC processing and error handling
  • Controlling database connections
  • JDBC batch operations
  • Simplifying JDBC operations with the SimpleJdbc classes
  • Modeling JDBC operations as Java objects
  • Common problems with parameter and data value handling
  • Embedded database support
    • Why use an embedded database?
    • Creating an embedded database instance using Spring XML
    • Creating an embedded database instance programmatically
    • Extending the embedded database support
    • Using HSQL
    • Using H2
    • Using Derby
  • Initializing a DataSource
• Object Relational Mapping (ORM) Data Access
  • Introduction to ORM with Spring
  • General ORM integration considerations
  • Hibernate
    • SessionFactory setup in a Spring container
    • Implementing DAOs based on plain Hibernate 3 API
    • Declarative transaction demarcation
    • Programmatic transaction demarcation
    • Transaction management strategies
    • Comparing container-managed and locally defined resources
    • Spurious application server warnings with Hibernate
  • JDO
    • PersistenceManagerFactory setup
    • Implementing DAOs based on the plain JDO API
    • Transaction management
    • JdoDialect
  • JPA
    • Three options for JPA setup in a Spring environment
      • LocalEntityManagerFactoryBean
      • Obtaining an EntityManagerFactory from JNDI
      • LocalContainerEntityManagerFactoryBean
      • Dealing with multiple persistence units
    • Implementing DAOs based on plain JPA
    • Transaction Management
    • JpaDialect
  • iBATIS SQL Maps
    • Setting up the SqlMapClient
    • Using SqlMapClientTemplate and SqlMapClientDaoSupport
    • Implementing DAOs based on plain iBATIS API
• Marshalling XML using O/X Mappers
  • Introduction
  • Marshaller and Unmarshaller
    • Marshaller
    • Unmarshaller
    • XmlMappingException
  • Using Marshaller and Unmarshaller
  • XML Schema-based Configuration
  • JAXB
    • Jaxb2Marshaller
      • XML Schema-based Configuration
  • Castor
    • CastorMarshaller
    • Mapping
  • XMLBeans
    • XmlBeansMarshaller
      • XML Schema-based Configuration
  • JiBX
    • JibxMarshaller
      • XML Schema-based Configuration
  • XStream
    • XStreamMarshaller
• V. The Web
• Web MVC framework
  • Introduction to Spring Web MVC framework
    • Features of Spring Web MVC
    • Pluggability of other MVC implementations
  • The DispatcherServlet
  • Implementing Controllers
    • Defining a controller with @Controller
    • Mapping requests with @RequestMapping
  • Handler mappings
    • Intercepting requests – the HandlerInterceptor interface
  • Resolving views
    • Resolving views with the ViewResolver interface
    • Chaining ViewResolvers
    • Redirecting to views
    • ContentNegotiatingViewResolver
  • Using locales
  • Using themes
  • Spring’s multipart (fileupload) support
    • Introduction
    • Using the MultipartResolver
    • Handling a file upload in a form
  • Handling exceptions
    • HandlerExceptionResolver
    • @ExceptionHandler
  • Convention over configuration support
  • ETag support
  • Configuring Spring MVC
  • More Spring Web MVC Resources
• View technologies
  • Introduction
  • JSP & JSTL
  • Tiles
    • Dependencies
    • How to integrate Tiles
  • Velocity & FreeMarker
    • Dependencies
    • Context configuration
    • Creating templates
    • Advanced configuration
    • Bind support and form handling
  • XSLT
    • Introduction
      • Bean definitions
      • Standard MVC controller code
      • Convert the model data to XML
      • Defining the view properties
      • Document transformation
  • Document views (PDF/Excel)
    • Introduction
    • Configuration and setup
      • Document view definitions
      • Controller code
      • Subclassing for Excel views
      • Subclassing for PDF views
  • JasperReports
    • Dependencies
    • Configuration
      • Configuring the ViewResolver
      • Configuring the Views
      • About Report Files
      • Using JasperReportsMultiFormatView
    • Populating the ModelAndView
    • Working with Sub-Reports
    • Configuring Exporter Parameters
  • Feed Views
  • XML Marshalling View
  • JSON Mapping View
• Integrating with other web frameworks
  • Introduction
  • Common configuration
  • JavaServer Faces 1.1 and 1.2
    • DelegatingVariableResolver (JSF 1.1/1.2)
    • SpringBeanVariableResolver (JSF 1.1/1.2)
    • SpringBeanFacesELResolver (JSF 1.2+)
    • FacesContextUtils
  • Apache Struts 1.x and 2.x
    • ContextLoaderPlugin
      • DelegatingRequestProcessor
      • DelegatingActionProxy
    • ActionSupport Classes
  • WebWork 2.x
  • Tapestry 3.x and 4.x
    • Injecting Spring-managed beans
  • Further Resources
• Portlet MVC Framework
  • Introduction
    • Controllers – The C in MVC
    • Views – The V in MVC
    • Web-scoped beans
  • The DispatcherPortlet
  • The ViewRendererServlet
  • Controllers
  • Handler mappings
• 18.8. Handling exceptions
• 18.9. Annotation-based controller configuration
• 18.10. Portlet application deployment

Integration

• Remoting and web services using Spring
  • Introduction
  • Exposing services using RMI
  • Using Hessian or Burlap to remotely call services via HTTP
  • Exposing services using HTTP invokers
  • Web services
    • Exposing servlet-based web services using JAX-RPC
    • Accessing web services using JAX-RPC
    • Registering JAX-RPC Bean Mappings
    • Registering your own JAX-RPC Handler
    • Exposing servlet-based web services using JAX-WS
    • Exporting standalone web services using JAX-WS
    • Exporting web services using the JAX-WS RI’s Spring support
    • Accessing web services using JAX-WS
  • JMS
    • Server-side configuration
    • Client-side configuration
  • Auto-detection is not implemented for remote interfaces
  • Accessing RESTful services on the Client
    • RestTemplate
    • HTTP Message Conversion
• Enterprise JavaBeans (EJB) integration
  • Introduction
  • Accessing EJBs
    • Concepts
    • Accessing local SLSBs
    • Accessing remote SLSBs
    • Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
  • Using Spring’s EJB implementation support classes
    • EJB 2.x base classes
    • EJB 3 injection interceptor
• JMS (Java Message Service)
  • Introduction
  • Using Spring JMS
    • JmsTemplate
    • Connections
    • Destination Management
    • Message Listener Containers
    • Transaction management
  • Sending a Message
  • Receiving a message
  • Support for JCA Message Endpoints
  • JMS Namespace Support
• JMX
  • Introduction
  • Exporting your beans to JMX
    • Creating an MBeanServer
    • Reusing an existing MBeanServer
    • Lazy-initialized MBeans
    • Automatic registration of MBeans
    • Controlling the registration behavior
  • Controlling the management interface of your beans
  • Controlling the ObjectNames for your beans
  • JSR-160 Connectors
    • Server-side Connectors
    • Client-side Connectors
    • JMX over Burlap/Hessian/SOAP
  • Accessing MBeans via Proxies
  • Notifications
    • Registering Listeners for Notifications
    • Publishing Notifications
  • Further Resources
• JCA CCI
  • Introduction
  • Configuring CCI
  • Using Spring’s CCI access support
  • Modeling CCI access as operation objects
  • Transactions
• Email
  • Introduction
  • Usage
  • Using the JavaMail MimeMessageHelper
• Task Execution and Scheduling
  • Introduction
  • The Spring TaskExecutor abstraction
  • The Spring TaskScheduler abstraction
  • The Task Namespace
  • Annotation Support for Scheduling and Asynchronous Execution
  • Using the OpenSymphony Quartz Scheduler
  • Using JDK Timer support
• Dynamic language support
  • Introduction
  • Defining beans that are backed by dynamic languages
  • Scenarios
    • Scripted Spring MVC Controllers
    • Scripted Validators
  • Bits and bobs