Spring Development Tools

• Build a Spring application with the Spring Tool Suit

• Build a Spring application with the Eclipse IDE

• Build a Spring application with the IntelliJ IDE

• Build a Spring application with the Maven command line interface

• Build a Spring application with the Gradle command line interface

• Build a Spring application with the Gradle Wrapper 

Spring Core Tasks

• Manage and Configure POJOs with the Spring IoC Container

• Create POJOs by Invoking a Constructor

• Use POJO References, Auto-Wiring, and Imports to Interact with Other POJOs

• Configure POJOs with Java Collection Attributes

• Set a POJOs Scope

• Use Data from External Resources (Text Files, XML Files, Properties Files,  or Image Files)

• Resolve I18N Text Messages for Different Locales in Properties Files

• Customize POJO Initialization and Destruction

• Create Post Processors to Validate and Modify POJOs

•  Create POJOs with a Factory (Static Method, Instance Method,  Spring’s FactoryBean)

•  Use Spring Environments and Profiles to Load Different Sets of POJOs

• Aspect Orientated Programming

• Declare POJOs from Static Fields or Object Properties

• Making POJOs Aware of Spring’s IoC Container Resources

• Communicate Application Events Between POJOs

• Use Property Editors in Spring

• Inherit POJO Configurations

• Implement POJOs with Scripting Languages

• Inject Spring POJOs into Scripts

• Refresh POJOs from Scripts

• Define Script Sources as Inline Code and not in External Files

• Use the Spring Expression Language to Configure POJOs

Spring Annotation Driven Core Tasks

• Using Java Config to configure POJOs

• Create POJOs by Invoking a Constructor

• Use POJO References and Auto-Wiring to Interact with other POJOs

• Auto-wire POJOs the @Resource and @Inject annotation

• Set a POJOs Scope with the @Scope annotation

•  Use data from External Resources (Text files, XML files, properties files,  or image files)

• Resolve I18N Text Messages for different locales in properties files

• Customize POJO Initialization and Destruction with annotations

• Create Post Processors to validate and modify POJOs

• Create POJOs with a factory (Static method, Instance method, Spring’s FactoryBean)

• Use Spring Environments and Profiles to load different sets of POJOs

• Aspect Orientated programming with Annotations

• Accessing the Join Point Information

• Specifying Aspect Precedence with the @Order annotation

•  Reuse Aspect Pointcut Definitions

• Writing AspectJ Pointcut Expressions

• AOP introductions for POJOs

• Introduce states to your POJOs with AOP

•  Load-Time Weaving AspectJ Aspects in Spring

• Configuring AspectJ Aspects in Spring

• Inject POJOs into Domain Objects with AOP

• Concurrency with Spring and TaskExecutors

Spring @MVC

• Developing a Simple Web Application with Spring MVC

• Mapping requests with @RequestMapping

• Intercepting Requests with Handler Interceptors

• Resolving User Locales

• Externalizing Locale-Sensitive Text Messages

• Resolving Views by Names

• Views and Content Negotiation

• Mapping Exceptions to Views

•  Handling Forms with Controllers

• Bean validation with Annotations (JSR-303)

• Creating Excel and PDF Views

Spring REST

• Publishing XML with REST Services

• Publishing JSON with REST services

• Accessing a REST Service with Spring

• Publishing RSS and Atom feeds

Spring Social

• Setting Up Spring Social

• Connecting to Twitter

• Connecting to Facebook

• Showing Service Provider Connection Status

• Using the Twitter API

• Using a Persistent UsersConnectionRepository

• Integrating Spring Social and Spring Security

Spring Security

• Securing URL Access

• Logging In to Web Applications

• Authenticating Users

• Making Access Control Decisions

• Securing Method Invocations

• Handling Security in Views

• Handling Domain Object Security

Spring Mobile

• Device detection without Spring Mobile

• Device detection with Spring Mobile

• Using Site preferences

• Using the Device Information to Render View

• Site Switching

Spring with Other Web Frameworks

• Accessing Spring in Generic Web Applications

• Using Spring in Your Servlets and Filters

• Integrating Spring with JSF

Data Access

• Problems with Direct JDBC

• Using a JDBC Template to Update a Databas

• Using a JDBC Template to Query a Database

• Simplifying JDBC Template Creation

• Using Named Parameters in a JDBC Template

• Handling Exceptions in the Spring JDBC Framework

• Problems with Using ORM Frameworks Directly

• Configuring ORM Resource Factories in Spring

• Persisting Objects with Spring’s ORM Templates

• Persisting Objects with Hibernate’s Contextual Sessions

• Persisting Objects with JPA’s Context Injectio

• Simplify JPA with Spring Data JPA

Spring Transaction Management

• Problems with Transaction Managemen

• Choosing a Transaction Manager Implementation

• Managing Transactions Programmatically with the Transaction Manager API

• Managing Transactions Programmatically with a Transaction Template

• Managing Transactions Declaratively with Transaction Advice

• Managing Transactions Declaratively with the @Transactional Annotation

• Setting the Propagation Transaction Attribute

• Setting the Isolation Transaction Attribute

•  Setting the Rollback Transaction Attribute

• Setting the Timeout and Read-Only Transaction Attributes

• Managing Transactions with Load-Time Weaving

Spring Batch

• Setting Up Spring Batch’s Infrastructure

• Reading and Writing

• Writing a Custom ItemWriter and ItemReader

• Processing Input Before Writing

• Better Living through Transactions

• Retrying

• Controlling Step Execution

• Launching a Job

• Parameterizing a Job

NoSQL and BigData

• Using MongoDB

• Using Redis

• Using Hadoop

• Using Neo4j

Spring Java Enterprise Services and Remoting Technologies

• Register Spring POJOs as JMX MBeans

• Publish and Listen to JMX Notifications

• Access Remote JMX MBeans in Spring

• Send E-mail with Spring’s E-mail Support

• Schedule tasks with Spring’s Quartz Support

• Schedule tasks with Spring’s Scheduling

• Expose and Invoke Services through RMI

• Expose and Invoke Services through HTTP

• Expose and invoke SOAP Web Services with JAX-WS

• Introduction to contract first SOAP Web Services

• Expose and invoke SOAP Web Services with Spring-WS

• Develop SOAP Web Services with Spring-WS and XML Marshalling

Spring Messaging

• Send and Receive JMS Messages with Spring

• Convert JMS Messages

• Manage JMS Transactions

• Create Message-Driven POJOs in Spring

• Cache and pool JMS connections

• Send and Receive AMQP Messages with Spring 

Spring Integration

• Integrating One System with Another Using EAI

• Integrating Two Systems Using JMS

• Interrogating Spring Integration Messages for Context Information

• Integrating Two Systems Using a File System

• Transforming a Message from One Type to Another

• Error Handling Using Spring Integration

• Forking Integration Control: Splitters and Aggregators

• Conditional Routing with Routers

• Staging Events Using Spring Batch

• Using Gateways

Spring Testing

• Creating Tests with JUnit and TestNG

• Creating Unit Tests and Integration Tests

• Unit Testing Spring MVC Controllers

• Managing Application Contexts in Integration Tests

• Injecting Test Fixtures into Integration Tests

• Managing Transactions in Integration Tests

• Accessing a Database in Integration Tests

• Using Spring’s Common Testing Annotations

• Integration Testing Spring MVC Controllers

Grails

• Getting and Installing Grails

• Creating a Grails Application

• Grails Plug-Ins

• Developing, Producing, and Testing in Grails Environments

• Creating an Application’s Domain Classes

• Generating CRUD Controllers and Views for an Application’s Domain Classes

• Internationalization (I18n) Message Properties

• Changing Permanent Storage Systems

• Logging

• Running Unit and Integration Tests

• Using Custom Layouts and Templates

• Using GORM Queries

• Creating Custom Tags

• Adding Security