SPR-001: Core Spring Syllabus

In this four-day bootcamp you learn how to use the Spring Framework to create well-designed, testable business applications in an agile manner. Completion of this course entitles each student to waive the registration fee for the Spring Framework Certification Examination.

Outline

A day-by-day outline of our flagship Spring training course follows:

  • Day 1 - Spring Framework Foundations
    • Introduction to the lightweight container architecture and the Spring Application Context
    • How Dependency Injection and Test-Driven Development allow you to develop consistently structured, highly configurable, easily testable applications quickly
    • How Spring helps you write better, more cohesive code, with a discussion of relevant Object-Oriented design patterns
    • Hands-on labs based upon a realistic business case to be extended throughout the course
  • Day 2 - Effective Middle-Tier Architecture
    • Pragmatic Spring Aspect-Oriented Programming in the middle-tier, with examples and without buzzwords
    • Effective persistence: how to build a persistence layer with Spring in best-practice fashion
    • Analysis and tradeoffs of relevant persistence strategies, including Hibernate and Spring JDBC
    • Transaction management strategies with Spring at the service layer
    • Middle-tier unit and integration test strategies
  • Day 3 - Implementing Enterprise Information Connectivity
    • Understanding ORM and Hibernate with Spring
    • An overview of Spring Web MVC, Spring JavaScript, Spring Web Flow and Spring Faces
    • Configuring Spring-managed services for remoting without any code
    • Designing contract-first web services with Spring Web Services
  • Day 4 - Integration with Enterprise Services
    • Understanding Spring Security and role-based access
    • Building in manageability with Spring JMX
    • Configuring Message-Driven POJOs with Spring JMS
    • Understanding SpringSource Enterprise Solutions

Day by day account

A detailed, day in the life account of each day follows:

Day 1

Day 1 will start with a detailed explanation of the concepts of Inversion of Control and Dependency Injection. You will learn how to use those fundamental principles to increase the testability of your code and to create well-designed, layered applications. You'll apply design patterns that are ideally suited for use with a lightweight container, and see techniques by example that help you maximize code reuse.

Next, you'll dive into the world of the Spring Application Context, the heart of Spring. You'll learn not only the basic features of the Application Context, but also the advanced capabilities necessary to develop maintainable, extensible applications. These include how and when to:

  • Organize Spring configuration files effectively by means of modularization
  • Use Spring IDE to visualize your application's configuration
  • Define FactoryBeans to encapsulate creation and/or lookup logic
  • Insert custom behavior at well-defined points within the Context lifecycle
  • Leverage Spring 2.0+ namespaces for more concise XML configuration
  • Extend Spring support classes to bootstrap an Application Context and inject dependencies for integration tests

By the end of the day, you'll understand the Spring Lightweight Container Architecture and how it allows you to rapidly assemble a complex system from a set of loosely coupled components. You'll understand the big picture of what Spring is all about, and how it helps you write high quality applications faster.

Day 1 introduces a realistic business case to fuel the hands-on application development throughout the course. Day 1 itself includes several labs where you will become familiar with the fundamentals of Spring's lightweight container while following a test-driven approach. You'll learn how to use mocks and stubs effectively to facilitate parallel development across collaborating teams, and see what's required from a communication perspective to make it happen. You'll gain experience designing a well-defined business facade, and apply techniques for capturing business contracts in code. You'll develop top-down integration tests to validate those contracts early, and use Spring's test support library to rapidly establish a test harness. The same business case will be used for the remaining three days of the course with labs covering persistence, web-tier, and integration.

Day 2

Day 2 picks up where Day 1 left off: extending the business case into a realistic middle-tier application. Now that the core application logic you implemented on the first day will be integrated with enterprise services such as transaction management, you will dive into the world of Aspect Oriented Programming (AOP), learning where to use AOP and how to identify crosscutting concerns. You'll learn how to use Spring's built-in aspects and develop one of your own.

AOP topics covered:

  • The building blocks of AOP, without all the buzzwords
  • The advice types supported by Spring
  • How to use pointcuts to target aspects in a dynamic fashion
  • The different ways of creating AOP proxies in Spring and how to choose between them

After the fundamentals of Spring AOP have been established, you will move on to Spring's role in transaction management and data access. By the end of the day, you'll know how to significantly reduce the complexity of your data access code by leveraging Spring for resource management, exception translation, and declarative transaction demarcation.

After an overview of Spring's middle-tier support, you'll proceed into implementation of the data access layer for the lab application. You'll leverage both Hibernate and JDBC to connect your application to a database. Using Spring's DaoSupport classes and the Template-based infrastructure, you'll implement reliable and performant data access services in very few lines of code. You'll gain hands-on experience on how to wield JDBC effectively in situations which you require ultimate performance and demand complex relational operations. You'll see how Spring has a unique capability to combine ORM and JDBC data access techniques in one application.

Next, you'll demarcate transactions using several techniques from the Spring transaction infrastructure. Both declarative and programmatic transaction management are covered. You'll get hands-on experience with PlatformTransactionManager implementations, including how to mix JDBC and Hibernate access in the same transaction. You'll learn how Spring supports switching between local and global transaction management without requiring any code changes even while accommodating advanced features such as nested transactions and savepoints, available when working with some transactional resources.

And it doesn't stop there. You'll declaratively set transaction boundaries, use propagation and rollback rules properly, and learn how to design the transaction infrastructure for your application. You'll apply transaction behavior automatically using autoproxy creators and learn how to express transactional policies as source-level metadata with JDK 5.0 annotations.

By the end of the day, you'll build a fully functional middle-tier, hosting your application's core logic in support of the business case. You'll verify quantitatively that the components of the application work in isolation as well as part of an end-to-end integration test, all without deploying to an application server once. You'll have experienced first-hand the benefits of Test-Driven Development (TDD) and fail-fast. You'll understand how to use Hibernate and JDBC effectively, and see how Spring allows you to decorate your business services with infrastructure in a declarative, dynamic fashion.

Day 3

Day 3 provides an introduction to "Spring Web" and also focuses on effective enterprise connectivity for data exchange and business activity. You will first become familiar with the value of object relational mappers such as Hibernate. A brief change of venue is offered in the "Spring Web" overview.

This is an introduction to Spring Web MVC, Spring JavaScript, Spring Web Flow and Spring Faces. The Spring MVC coverage provides "essential" MVC information. It covers the request processing life-cycle, the key artifacts of MVC such as the DispatcherServlet and it concludes with an MVC "quick start". Detailed coverage of Spring Web (Spring Web MVC, Spring JavaScript, Spring Web Flow and Spring Faces) can be found in the "Developing Rich Web Applications with Spring" course.

You'll be guided with your new knowledge of Spring's powerful DispatcherServlet to see how it is used in various forms of remoting and Spring's support of Web Services. You'll export a transactional service to remote clients over a variety of protocols with Spring's Remoting support. In the last part of the day learn how to create Web Services, working in a contract first fashion.

Day 4

Day 4 is all about building on what you've done so far.  You'll see an overview of how to add comprehensive security services to your application using Spring Security. You'll learn how to accommodate the wide variety of authentication mechanisms that may be required in an enterprise application. At the same time, you'll learn how to apply access rules that are completely decoupled from the authentication mechanism.

You'll see how Spring lets you tap into the full power of J2EE without costly rewrites or rearchitecture. You'll learn how do JMS messaging with Spring's Message-Driven POJOs. You will also see how to build in monitoring and manageability to your application using Spring's JMX support.

As one recent student told us, by the end of the course you'll have "learned a ton, almost all of which you can apply immediately". In addition, all the training materials covered, as well as the end deliverable you build, are yours for your continued reference.

 

General Information

Approach

Through our trainings, you benefit from the wide experience and architectural expertise of our team. We bring that experience to you in a highly interactive, intensely hands-on setting.

The Core Spring course not only focuses on explaining Spring features and how to use them, but also on fundamental architectural issues. It's important to know how to use certain parts of a framework, but it's even more important to be able to decide when to use them.

Assumptions

We assume participants have a good understanding of the core Java APIs, as well as a basic knowledge of general J2EE concepts and APIs, such as JTA and the Servlet API. As we cover object-relational mapping technologies (ORM) in this course as well, we assume basic knowledge of ORM concepts.

Lab Work

Since this class focuses on Spring as well as the theory of developing lightweight applications that are maintainable and extensible from the ground up, it is 40% theory-oriented. There is 60% lab-work.

Since lab work is a major part of the course, you use a computer when taking this course. For scheduled public training events, we generally (unless otherwise indicated) provide a fully configured lab PC for your use. You may bring your laptop, but it is not necessary. For on-site trainings, SpringSource also offers the possibility of arranging a development machine for you. More information about the availability of computers is available when registering for this course.

 

Contact Us

If you would like more information on this training, please contact us.