Spring Tutorial[Java Brains]

Spring is a light weight, non-invasive IoC Container and AOP framework. It provides support for JPA, Hibernate, Web services, Schedulers, Ajax, Struts, JSF and many other frameworks. The Spring MVC components can be used to develop MVC based web applications. Spring framework provides many features that makes the development of enterprise application easy.

Understanding Dependency Injection  

In this tutorial, we'll understand the concept of Dependency injection.

Setting Up  

In this tutorial, we'll learn how to set up our Eclipse development environment to write Spring code.

Understanding Spring Bean Factory  

In this tutorial, we'll discuss the role of Spring as a bean container. We'll also have a quick discussion on the Factory pattern, and I'll introduce you to the Spring Bean Factory object.

Writing Code Using the Bean Factory  

In this tutorial, we'll write code to implement the BeanFactory concept that we learnt in our previous tutorial. We'll write a Spring XML to configure a Spring bean. Then we'll use the BeanFactory to instantiate our bean in the Spring container.

ApplicationContext and Property Initialization  

We'll first replace the BeanFactory with the more powerful ApplicationContext. We'll then make Spring initialize a property of an object by specifying the value in the configuration XML.

Using Constructor Injection  

We'll now use constructors to set the member variable values for our Spring beans. We'll also look at some techniques to resolve conflicts in the case of overloaded constructors.

Injecting Objects  

In this tutorial, we'll use dependency injection to inject an object dependency to a Spring bean.

Inner Beans, Aliases and idref  

In this tutorial, we'll look at some concepts related to bean naming and usage like alias and idref. We'll also understand how to write inner beans.

Initializing Collections  

In this tutorial, we'll initialize a member variable that's a collection and each of the elements are references to other beans.

Bean Autowiring  

We'll now look at a configuration feature provided by Spring to wire dependencies automatically: Bean Autowiring. We'll learn about different types of autowiring, and we'll write some code to implement bean autowiring by name.

Understanding Bean Scopes  

This tutorial covers the concepts of Bean Scopes in Spring. We'll understand when beans are created and how to configure different scopes for the beans.

Using ApplicationContextAware  

We'll provide our beans with access to the ApplicationContext object by implementing the ApplicationContextAware interface. We'll also use BeanNameAware interface to get the name of the bean configured in the Spring XML.

Bean Definition Inheritance  

In this tutorial, we'll learn what bean definition inheritance is, and how to configure a parent bean definition and have children beans inherit the bean definitions.

Lifecycle Callbacks  

We'll use two different ways to run methods on initialization and destruction of beans.

Writing a BeanPostProcessor  

In this tutorial, we'll understand what a BeanPostProcessor is. We'll also write a BeanPostProcessor that prints a message upon initializing each and every bean in the Spring XML.

Writing a BeanFactoryPostProcessor  

In this tutorial, we'll learn about and write our own BeanFactoryPostProcessor. We'll also try out a handy BeanFactoryPostProcessor that comes with Spring: the PropertyPlaceholderConfigurer.

Coding To Interfaces  

When using Spring for dependency injection, it's a good practice to use interfaces for referencing dependencies. In this tutorial, we'll learn how to "code to interfaces".

Introduction to Annotations and the Required Annotation  

Here we'll have our first look at Spring annotations. We'll understand and implement the Required annotation, and we'll also learn how it's actually a BeanPostProcessor that's working behind the scenes.

The Autowired Annotation  

In this tutorial, we'll use the Autowired annotation to wire up dependencies. We'll learn how to add dependencies by type and name. We'll also use Qualifiers to narrow down dependency contenders.

Some JSR-250 Annotations  

We'll learn and implement three JSR-250 annotations that Spring supports:Resource, PostConstruct and PreDestroy.

Component and Stereotype Annotations  

We'll now use the Component annotation to define Spring beans. We'll also look at some Stereotype annotations.

Using MessageSource To Get Text From Property Files  

In this tutorial, we'll use the MessageSource interface to retrieve messages out of property files.

Event Handling in Spring  

We'll now look at Spring's support for Event Handling. We'll write an event listener in this tutorial. i'll also show you how to write custom events and publish them anywhere in the code.