Ebooks

Spring Boot GenericApplicationContext

Spring Boot GenericApplicationContext tutorial shows how to use the GenericApplicationContext in a Spring application. In the example, we create a Spring Boot console application.

Spring is a popular Java application framework and Spring Boot is an evolution of Spring that helps create stand-alone, production-grade Spring based applications easily.

GenericApplicationContext

GenericApplicationContext is an implementation of the ApplicationContext, which does not assume a specific bean definition format; e.g. XML or annotations.

Spring Boot GenericApplicationContext example

In the following application we create a GenericApplicationContext and register a new bean with the context's registerBean() method. Later we retrieve the bean from the application context with getBean().

pom.xml
<?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.zetcode</groupId>
    <artifactId>genappctx</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>genappctx</name>
    <description>Using GenericApplicationContext</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

This is the Maven pom.xml file. The spring-boot-starter-parent is a parent POM providing dependency and plugin management for applications built with Maven. The spring-boot-starter is a core starter, including auto-configuration support, logging, and YAML. The spring-boot-starter-test adds testing support in Spring. The spring-boot-maven-plugin packages Spring applications into executable JAR or WAR archives.

application.properties
spring.main.banner-mode=off
logging.level.root=ERROR
logging.pattern.console=%d{dd-MM-yyyy HH:mm:ss} %magenta([%thread]) %highlight(%-5level) %logger.%M - %msg%n

The application.properties is the main configuration file in Spring Boot. We turn off the Spring banner, reduce the amount of logging to errors only, and set the console logging pattern.

TimeService.java
package com.zetcode.service;

import java.time.Instant;

public class TimeService {

    public Instant getNow() {

        return Instant.now();
    }
}

TimeService contains a simple method which returns current date and time. This service class is going to be registered in our generic application context.

MyApplication.java
package com.zetcode;

import com.zetcode.service.TimeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.support.GenericApplicationContext;

@SpringBootApplication
public class MyApplication implements CommandLineRunner {

    @Autowired
    private GenericApplicationContext context;

    public static void main(String[] args) {

        SpringApplication.run(MyApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {

        context.registerBean("com.zetcode.Service.TimeService",
                TimeService.class, () -> new TimeService());

        var timeService = (TimeService) context.getBean(TimeService.class);

        System.out.println(timeService.getNow());

        context.registerShutdownHook();
    }
}

MyApplication is the entry point which sets up Spring Boot application. The @SpringBootApplication annotation enables auto-configuration and component scanning. It is a convenience annotation for @Configuration, @EnableAutoConfiguration, and @ComponentScan annotations.

@Autowired
private GenericApplicationContext context;

We inject the GenericApplicationContext.

context.registerBean("com.zetcode.Service.TimeService",
    TimeService.class, () -> new TimeService());

A new TimeService bean is registered with the registerBean() method.

var timeService = (TimeService) context.getBean(TimeService.class);

We retrieve the bean with getBean().

System.out.println(timeService.getNow());

Finally, we call the bean's getNow() method.

MyApplicationTests.java
package com.zetcode;

import com.zetcode.service.TimeService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.test.context.junit4.SpringRunner;

import java.time.Instant;

import static org.assertj.core.api.Assertions.assertThat;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyApplicationTests {

    @Autowired
    private GenericApplicationContext context;

    @Test
    public void testNow() {

        var timeService = (TimeService) context.getBean("com.zetcode.Service.TimeService");
        var now = timeService.getNow();

        assertThat(now.isBefore(Instant.now()));
    }
}

We have a simple test that uses the TimeService's getNow() method.

var timeService = (TimeService) context.getBean("com.zetcode.Service.TimeService");

This time we refer to the bean by its given name.

$ mvn -q spring-boot:run
2018-11-24T16:31:32.146393700Z

We run the application.

In this tutorial, we have shown how to use GenericApplicationContext in a Spring application. You might also be interested in the related tutorials: Spring Boot @PostConstruct tutorial, Spring Boot @Controller tutorial, Spring Boot @ExceptionHandler tutorial, Spring Boot upload file, Spring Boot @PathVariable tutorial, Spring Boot @RequestParam tutorial, Spring Boot @ResponseBody tutorial, Java tutorial.