Wednesday, December 12, 2012

Detailed ToC of 'Getting started with Spring Framework'


Chapter 1 - Spring Framework basics
1-1 Introduction
1-2 Spring Framework modules
1-3 Why use Spring Framework?
Declarative transaction management
Security
JMX (Java Management Extensions)
JMS (Java Message Service)
Caching
1-4 DI and Spring IoC container
Dependency Injection (DI)
Identifying application objects and their dependencies
Creating POJO classes corresponding to identified application objects
Creating the configuration metadata
Creating an instance of Spring IoC container
Access application objects from the Spring IoC container
1-5 Programming to interfaces
Scenario: Dependent class contains reference to the concrete class of dependency
Scenario: Dependent class contains reference to the interface implemented by dependency
Spring’s support for programming to interfaces design approach
1-6 Different approaches to instantiating Spring beans
Instantiating beans via static factory methods
Instantiating beans via instance factory methods
1-7 Dependency injection techniques
Setter-based DI
Constructor-based DI
1-8 Bean scopes
Singleton
Prototype
Choosing the right scope for your beans
1-9 Frameworks built on top of Spring
1.10 Summary

Chapter 2 - Configuring beans
2-1 Introduction
2-2 Bean definition inheritance
MyBank App – Bean definition inheritance example
What gets inherited ?
2-3 Constructor argument matching
Passing simple values and bean references using element
Constructor argument matching based on type
Constructor argument matching based on name
2-4 Configuring different types of bean properties and constructor arguments
Built-in property editors in Spring
Specifying values for different collection types
Specifying values for arrays
Default collection implementation for , and elements
2-5 Built-in property editors
CustomCollectionEditor
CustomMapEditor
CustomDateEditor
2-6 Registering property editors with the Spring container
Creating a PropertyEditorRegistrar implementation
Configuring the CustomEditorConfigurer class
2-7 Concise bean definitions with p and c namespaces
p-namespace
c-namespace
2-8 Spring’s util schema
<list>
<map>
<set>
<properties>
<constant>
<property-path>
2-9 FactoryBean interface
MyBank App application – Storing events in the database
MyBank App – FactoryBean example
Accessing the FactoryBean instance
2-10 Summary

Chapter 3 - Dependency injection
3-1 Introduction
3-2 Inner beans
3-3 Explicitly controlling the bean initialization order with depends-on attribute
MyBank App – implied dependencies between beans
Implicit dependency problem
3-4 Singleton- and prototype-scoped bean’s dependencies
Singleton-scoped bean’s dependencies
Prototype-scoped bean’s dependencies
3-5 Obtaining new instances of prototype beans inside singleton beans
ApplicationContextAware interface
<lookup-method> element
<replaced-method> element
3-6 Autowiring dependencies
byType
constructor
byName
default / no
Making beans unavailable for autowiring
Autowiring limitations
3-7 Summary

Chapter 4 - Customizing beans and bean definitions
4-1 Introduction
4-2 Customizing bean’s initialization and destruction logic
Making Spring invoke cleanup method specified by the destory-method attribute
Cleanup methods and prototype-scoped beans
Specifying default bean initialization and destruction methods for all beans
InitializingBean and DisposableBean lifecycle interfaces
JSR 250’s @PostConstruct and @PreDestroy annotations
4-3 Interacting with newly created bean instances using BeanPostProcessor
BeanPostProcessor example – Validating bean instances
BeanPostProcessor example – Resolving bean dependencies
BeanPostProcessor behavior for FactoryBeans
RequiredAnnotationBeanPostProcessor
DestructionAwareBeanPostProcessor
4-4 Modifying bean definitions using BeanFactoryPostProcessor
BeanFactoryPostProcessor example
PropertySourcesPlaceholderConfigurer
PropertyOverrideConfigurer
4-5 Summary

Chapter 5- Annotation-driven development with Spring
5-1 Introduction
5-2 Identifying Spring components with @Component
5-3 @Autowired - autowiring dependencies by type
5-4 @Qualifier – autowiring dependencies by name
5-5 JSR 330’s @Inject and @Named annotations
5-6 JSR 250’s @Resource annotation
5-7 @Scope, @Lazy, @DependsOn and @Primary annotations
5-8 Simplifying component configuration using @Value annotation
5-9 Validating objects using Spring’s Validator interface
5-10 Specifying constraints using JSR 303 annotations
JSR 303 support in Spring
5-11 Programmatically configuring Spring beans using @Configuration and @Bean annotations
5-12 Summary

Chapter 6 - Database interaction using Spring
6-1 Introduction
6-2 MyBank App application’s requirements
6-3 Developing the MyBank App application using Spring’s JDBC module
Configuring a data source
Creating DAOs that use Spring’s JDBC module classes
6-4 Developing the MyBank App application using Hibernate
Configuring SessionFactory instance
Creating DAOs that use Hibernate API for database interaction
6-5 Transaction management using Spring
MyBank App’s transaction management requirements
Programmatic transaction management
Declarative transaction management
Spring’s support for JTA
6-6 Summary

Chapter 7 - Messaging, emailing, asynchronous method execution, and caching using Spring
7-1 Introduction
7-2 MyBank App application’s requirements
7-3 Sending JMS messages
Configuring ActiveMQ broker to run in embedded mode
Configuring a JMS ConnectionFactory
Sending JMS messages using JmsTemplate
Sending JMS messages within a transaction
Dynamic JMS destinations and JmsTemplate configuration
JmsTemplate and message conversion
7-4 Receiving JMS messages
Synchronously receiving JMS messages using JmsTemplate
Asynchronously receiving JMS messages using message listener containers
7-5 Sending emails
7-6 Task scheduling and asynchronous execution
TaskExecutor interface
TaskScheduler interface
@Async and @Scheduled annotations
7-7 Caching
Configuring a CacheManager
Caching annotations - @Cacheable, @CacheEvict and @CachePut
7-8 Running the MyBank App application
7-9 Summary

Chapter 8 - Aspect-oriented programming
8-1 Introduction
8-2 A simple AOP example
8-3 Spring AOP framework
Proxy creation
expose-proxy attribute
8-4 Pointcut expressions
@Pointcut annotation
execution and args pointcut designators
bean pointcut designator
Annotations-based pointcut designators
8-5 Advice types
Before advice
After returning advice
After throwing advice
After advice
Around advice
8-6 Spring AOP - XML schema-style
Configuring an AOP aspect
Configuring an advice
Associating a pointcut expression with an advice
8-7 Summary

No comments:

Post a Comment