Welcome to Spring Tutorials!

1) What do I need to know before learning Spring Framework?

2) What is at the heart of Spring Framework?

3) Where do I download it?

4) Can you give me a simple example of “Spring Framework”?

package com.springtutorials.tutorial1.services;

/**
 * @author amit@springtutorials.com
 *
 * A dummy service implementation that returns "OK"
 */
public class DummyServiceImpl implements DummyService {

    @Override
    public String test() {
        return "OK";
    }
}

The DummyServiceImpl is again a plain vanilla implementation of service that returns “OK”. There is no spring code in it.

The Problem

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.springtutorials</groupId>
   <artifactId>tutorial1</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>tutorial1</name>
   <description>Spring Tutorials - Tutorial 1</description>

   <properties>
      <spring.version>4.3.10.RELEASE</spring.version>
   </properties>

   <dependencies>
      <!-- Spring dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

    </dependencies>

</project>

The pom is simple and yet powerful. The three Spring libraries pack enough power to run a standalone application. These three libraries form the basis for almost all Spring Projects.

This zip file has done some work for your already.

package com.springtutorials.tutorial1.services;

import org.springframework.stereotype.Service;

/**
 * @author amit@springtutorials.com
 *
 * A dummy Spring service implementation that returns "OK"
 */
@Service
public class DummyServiceImpl implements DummyService {

    @Override
    public String test() {
        return "OK";
    }
}

Spring calls any class that has Spring injected into it – a Spring Bean. It is the only simple way to explain what a bean is. I will go into details of this later but should suffice for now (please bear with me).

package com.springtutorials.tutorial1;

import com.springtutorials.tutorial1.services.DummyService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author amit@springtutorials.com
 */
public class HelloWorldSpring {

    public static void main(String[] args){
        ApplicationContext ctx =
                new AnnotationConfigApplicationContext("com.springtutorials.tutorial1");
        System.out.println(" Spring Tutorial 1: Hello World config within this class ");
        //DummyService dummyService = new DummyServiceImpl();
        DummyService dummyService = (DummyService) ctx.getBean("dummyServiceImpl");
        System.out.println(" DummyService returned: "+dummyService.test());
    }

}

AnnotationConfigApplicationContext is a fancy way of telling Spring that Spring Bean uses annotation.

package com.springtutorials.tutorial1;

import com.springtutorials.tutorial1.services.DummyService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author amit@springtutorials.com
 */
public class HelloWorldSpringByInterface {

    public static void main(String[] args){
        ApplicationContext ctx =
                new AnnotationConfigApplicationContext("com.springtutorials.tutorial1");
        System.out.println(" Spring Tutorial 1: Hello World config by interface ");
        //DummyService dummyService = new DummyServiceImpl();
        DummyService dummyService = (DummyService) ctx.getBean(DummyService.class);
        System.out.println(" DummyService returned: "+dummyService.test());
    }

}

Not much is different between 2a and 2b. Is there? 2a was asking for service using the name. 2b is asking for service via the interface.

package com.springtutorials.tutorial1.config;

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

/**
 * @author amit@springtutorials.com
 *
 * Simplest way to initialize Spring in your application
 */
@Configuration
@ComponentScan(basePackages = {"com.springtutorials.tutorial1"})
public class Tutorial1Config {

    //nothing
}

3) Change the HelloWorld to get the Spring Context using the new file Tutorial1Config

package com.springtutorials.tutorial1;

import com.springtutorials.tutorial1.config.Tutorial1Config;
import com.springtutorials.tutorial1.services.DummyService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author amit@springtutorials.com
 */
public class HelloWorldSpringConfig {

    public static void main(String[] args){
        ApplicationContext ctx =
                new AnnotationConfigApplicationContext(Tutorial1Config.class);
        System.out.println(" Spring Tutorial 1: Hello World with Config in its own file. ");
        //DummyService dummyService = new DummyServiceImpl();
        DummyService dummyService = (DummyService) ctx.getBean(DummyService.class);
        System.out.println(" DummyService returned: "+dummyService.test());
    }

}

So instead of providing the package name in every class, you moved the configuration to its own file. Now you are calling the class.

1. We learned how Spring solved some common enterprise issues we faced in the past.
2. We took a java class and added Spring to it to show a simple hello world example.
3. We learned that Spring packs a lot of functionality in its offering. We have only scratched the surface here. We saw a glimpse of it in Spring Boot but there is a lot more functionality that is available there.
4. We downloaded a project template with all dependencies and sample code to get us started.
5. We also learned how to download it plain vanilla.
6. Spring is flexible and allows us to work with it in many ways.
7. Spring makes testing our code easier.
8. We learned that Spring supports ant, maven, gradle or simple java application.