Spring Core Basics — Part 1

Published in

technodyne

4 min readSep 9, 2014

First go to command line and create a simple project with maven.

mvn archetype:generate -DgroupId=com.supun.common -DartifactId=SpringExamples 
-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

This post has the setting up instruction of maven. Now edit the pom.xml file as follows.

[sourcecode language=”xml”]

<groupId>com.supun.common</groupId>
<artifactId>SpringExamples</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>SpringExamples</name>
<url>http://maven.apache.org</url>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
</dependencies>
</project>

[/sourcecode]

Now import this project to your Eclipse workspace. It will automatically download the dependencies.

Then create a Beans.xml file inside the src/main/java folder as follows.

[sourcecode language=”xml”]

<?xml version=”1.0" encoding=”UTF-8"?>

[/sourcecode]

Now create HelloWorld.java class.

[sourcecode language=”java”]

package com.supun.common;

public class HelloWorld {

private String message;

public void getMessage(){
System.out.println(“Your Message : “ + message);
}

public void setMessage(String message) {
this.message = message;
}
}

[/sourcecode]

Now change the App.java class as follows.

[sourcecode language=”java”]

package com.supun.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext(“Beans.xml”);

HelloWorld obj = (HelloWorld) context.getBean(“helloWorld”);

obj.getMessage();
}
}
[/sourcecode]

Now run the App.java class. The output is : Your Message : Hello Spring

In this example the spring configuration are added from the xml file.

This is how the spring framework is working.

The Spring container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete lifecycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application.These objects are called Spring Beans

In above example, the HelloWorld.java class is a POJO class. The metadata is taken from the Beans.xml.This metadata can be stored in the java file too.

Spring Bean Definition

The objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. These beans are created with the configuration metadata that you supply to the container, for example, in the form of XML <bean/> definitions which you have already seen.

The bean definition contains the information called configuration metadata which is needed for the container to know the followings:

How to create a bean
Bean’s lifecycle details
Bean’s dependencies

All the above configuration metadata translates into a set of the following properties that make up each bean definition.

PropertiesDescriptionclassThis attribute is mandatory and specify the bean class to be used to create the bean.nameThis attribute specifies the bean identifier uniquely. In XML-based configuration metadata, you use the id and/or name attributes to specify the bean identifier(s).scopeThis attribute specifies the scope of the objects created from a particular bean definition and it will be discussed in bean scopes chapter.constructor-argpropertiesautowiring modelazy-initialization modeA lazy-initialized bean tells the IoC container to create a bean instance when it is first requested, rather than at startup.initialization methodA callback to be called just after all necessary properties on the bean have been set by the container. It will be discussed in bean life cycle chapter.destruction methodA callback to be used when the container containing the bean is destroyed. It will be discussed in bean life cycle chapter.
Spring IoC container is totally decoupled from the format in which this configuration metadata is actually written. There are following three important methods to provide configuration metadata to the Spring Container:

XML based configuration file.

[sourcecode language=”xml”]

<?xml version=”1.0" encoding=”UTF-8"?>

<! — A simple bean definition →
<bean id=”…” class=”…”>
<! — collaborators and configuration for this bean go here →
</bean>

<! — A bean definition with lazy init set on →
<bean id=”…” class=”…” lazy-init=”true”>
<! — collaborators and configuration for this bean go here →
</bean>

<! — A bean definition with initialization method →
<bean id=”…” class=”…” init-method=”…”>
<! — collaborators and configuration for this bean go here →
</bean>

<! — A bean definition with destruction method →
<bean id=”…” class=”…” destroy-method=”…”>
<! — collaborators and configuration for this bean go here →
</bean>

<! — more bean definitions go here →

</beans>

[/sourcecode]

2.Annotation-based configuration.

Starting from Spring 2.5 it became possible to configure the dependency injection using annotations. So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself by using annotations on the relevant class, method, or field declaration.

3.Java Based configuration.

Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context. The simplest possible @Configuration class would be as follows:

Spring Core Basics — Part 1

Written by Supun Dharmarathne