Create simple HelloWorld spring application
Tags: programming, java, tutorial
Published: 2022-01-08 15:02:59

In this tutorial I'm going to cover step by step, how to create simple annotation based "HelloWorld" spring application. To create spring application, first of all you need to configure or create a spring project in your IDE (for this tutorial I'm going to use Eclipse IDE). If you having some trable with project creation, I strongly recommend to [click here](https://suvasish114.medium.com/how-to-create-a-simple-spring-project-in-eclipse-using-maven-f52c264163c4) and get start with your spring journey.

### Project Structure

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ulwjw8qass6yuenp0mug.png)

### Step1

Let's create a simple POJO class named `HelloWorld`, inside your project classpath (in my case com.example.SpringAnnotation is my project classpath). `HelloWorld.java` POJO class containing one string variable named `greeting` and one `setGreeting(String greeting)` and `getGreeting()` function. Those function are called getter and setter methods.

`setGreeting(String greeting)` function simply set the local variable named `greeting` and `getGreeting()` function simply fetch the data of the local variable `greeting`.

Another public function `sayHello()` simply print the message in the console using `println()` method. 

```java
package com.example.SpringAnnotation;

public class HelloWorld {
	private String greeting;

	public String getGreeting() {
		return greeting;
	}

	public void setGreeting(String greeting) {
		this.greeting = greeting;
	}
	public void sayHello() {
		System.out.println("Message is: "+greeting);
	}
}
```

### Step2

After creating your POJO class, now it's time to define a configuration class. Let's create a `HelloWorldConfig` class.
Annotate the class with `@Configuration` annotaion. By defining the class with `@Configuration` we telling spring that this class is going to contain bean definations.

Now inside the class we are going to create bean defination. Every bean definations must annotated with `@Bean` annotation. One configaretion class can have multiple bean definations. In this case I'm going to create one bean named `helloWorld()` (started with small 'h'). 

```java
package com.example.SpringAnnotation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HelloWorldConfig {
	// Bean name = helloWorld
	@Bean
	public HelloWorld helloWorld() {
		HelloWorld hello = new HelloWorld();
		hello.setGreeting("Hello Spring");
		return hello;
	}
}
```

### Step3

Now, bean defination is complete. Now create a xml file in your application classpath. I'm going to create `Config.xml` in my root class path so that no need to specify the xml files with fully specified path name. Now copy the following code and paste in your xml file. This step is important beacause it define the beans prototype.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.2.xsd"></beans>
```
Now add the following tag inside `<beans></beans>` tag.
```xml
<context:component-scan base-package="com.example.SpringAnnotation"/>
```
`context:component-scan` tag allow your code to scan for a specific bean. The `base-package="<your_component_classpath>"` locate for your defined components class path, so that it can scan for the secified beans in those location.

### Step4

Now, we are ready to write our final pice of code or the driving code. Now create a java class containing the main method(if you create your project using maven or groovy project template, you are provided a java class containing main mathod, just use those file).

Inside those class declare a `ApplicationContext` variable and 
define with `ClassPathXmlApplicationContext()` with parameter the string representation of your configuration xml file name with fully specified path (in my case, my xml file is placed at the root location, so I no need to enter the fully specified path name). Make sure that this variable is declared as static, so that we can access it from main method.

The `ApplicationContext` interface is responsible to create the spring IOC container(if you are not familiar with IOC, [click here](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans) and go through the documentation). `ClassPathXmlApplicationContext` class is a subclass which implemented `ApplicationContext` interface. There are many other subclass available to create IOC container.

Now, inside the main method of our code, create a variable of type `HelloWorld` and instantiated it with a defined bean. In this case `context.getBean("helloWorld", HelloWorld.class)` return a variable of type `HelloWorld`. The first argument of getBean refers to the bean name as string and the second argument refers to the actual class. By default getBean() method's return type is `java.lang.Object`. The second argument in the getBean() method actually used to typecast the value. So we no need to typecast it manually. In the below code, I'm typecasting the value to `HelloWorld.class` type.

Now, we are all set. Simply call the `sayHello()` method and your code works successfully.

```java
package com.example.SpringAnnotation;

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

public class App {
	private static ApplicationContext context =  new ClassPathXmlApplicationContext("Config.xml");
    public static void main( String[] args ){
        HelloWorld helloWorld = context.getBean("helloWorld", HelloWorld.class);
        helloWorld.sayHello();
    }
}
```

### Output

Plox!!! our code runs successfully. Here is the output-

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ch2cm047yay4e230hweh.png)