Project Overview

• Minimal Spring Boot 4.0.6 application — no web layer, just the core container.
• Java 21, built with spring-boot-starter-parent as the parent POM.
• Only two dependencies: spring-boot-starter (runtime) and spring-boot-starter-test (test scope).
• Demonstrates: ApplicationContext retrieval, bean registration via @Bean, singleton scope behavior, and Logback profile-based configuration.

Maven Setup

• Inheriting from spring-boot-starter-parent gives you managed dependency versions, plugin defaults, and resource filtering — no version declarations needed for standard starters.
• The spring-boot-maven-plugin packages the app as an executable fat JAR.

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>4.0.6</version>
</parent>

<properties>
  <java.version>21</java.version>
</properties>

Application Entry Point & Bean Registration

@SpringBootApplication

• Combines @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan.
• Component scan roots at the package of the annotated class — all sub-packages are scanned automatically.
• The annotated class itself is registered as a Spring bean (singleton by default).

Capturing the ApplicationContext

• SpringApplication.run() returns the ApplicationContext — hold onto it to query beans programmatically.
• Useful for debugging: iterate all registered bean definition names sorted alphabetically.

ApplicationContext ctx = SpringApplication.run(MtitekSpringStarterProjectApplication.class, args);

// Dump all registered bean names
Arrays.stream(ctx.getBeanDefinitionNames())
      .sorted()
      .forEach(bdn -> LOG.info("Spring Bean Definition Name: {}", bdn));

Retrieving Beans from the Context

• Beans can be retrieved by type (ctx.getBean(MyClass.class)) or by name + type (ctx.getBean("beanName", MyClass.class)).
• The default bean name for a @SpringBootApplication class is the camel-case simple class name — e.g. MtitekSpringStarterProjectApplication → "mtitekSpringStarterProjectApplication".
• Both retrieval methods return the same singleton instance — mutation via one reference is visible through the other.

// Retrieve by type
MtitekSpringStarterProjectApplication app = ctx.getBean(MtitekSpringStarterProjectApplication.class);
app.setValue(2);

// Retrieve by name — same instance, value is still 2
app = ctx.getBean("mtitekSpringStarterProjectApplication",
    MtitekSpringStarterProjectApplication.class);
System.out.println(app.getValue()); // prints 2

Registering a Bean with @Bean

• Applied to a method in any Spring-managed class — the object returned by the method is registered as a bean in the application context.
• Bean name defaults to the method name — here "appUuid".
• In this project, @Bean is declared inside the @SpringBootApplication class, which carries @SpringBootConfiguration (a form of @Configuration) — the method runs in full mode (CGLIB proxy), so the singleton contract is enforced by Spring.

@Bean
String appUuid() {
    return UUID.randomUUID().toString();
}

// Retrieve the bean by name and type
String uuid = ctx.getBean("appUuid", String.class);

Note: Registering a plain String bean is valid but can cause ambiguity if multiple String beans exist. Always retrieve it by name in that case.

Configuration & Profiles

application.yml — Main

• Active profile set to dev — controls which <springProfile> block in logback-spring.xml is activated at runtime.
• Logging levels can alternatively be configured directly in application.yml via logging.level.* — the commented-out block in the project shows the equivalent YAML syntax.

spring:
  application:
    name: mtitek-spring-starter-project
  profiles:
    active: dev

application.yml — Test

• Test resources override main resources on the classpath — the test application.yml activates the prod profile during test runs.
• This suppresses file appenders and reduces log verbosity in CI/CD pipelines.

spring:
  application:
    name: mtitek-spring-starter-project
  profiles:
    active: prod

Logback Configuration

logback-spring.xml vs logback.xml

• Use logback-spring.xml (not logback.xml) to unlock Spring Boot extensions — specifically the <springProfile> element for profile-based log config.
• With plain logback.xml, Spring Boot has no chance to customize initialization — <springProfile> is silently ignored.

Appender Strategy

• CONSOLE: synchronous, human-readable pattern with timestamps and thread name.
• FILE: rolling file at ./logs/mtitek-spring-starter-project.log, rolling on size (10MB) and daily, archived under ./logs/archived/.
• ASYNC_FILE: wraps FILE in an AsyncAppender — writes are enqueued off the main thread, reducing I/O latency impact on throughput.

<appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
  <appender-ref ref="FILE" />
</appender>

Profile-based Log Levels

• dev: both CONSOLE and ASYNC_FILE active; com.mtitek.spring at INFO, root at INFO.
• prod: CONSOLE suppressed; com.mtitek.spring at INFO to ASYNC_FILE only; root at WARN — only warnings and errors from third-party libraries are captured.
• additivity="false" on the package logger prevents log events from bubbling up to the root logger, avoiding duplicate output.

<springProfile name="dev">
  <logger name="com.mtitek.spring" level="INFO" additivity="false">
    <appender-ref ref="CONSOLE" />
    <appender-ref ref="ASYNC_FILE" />
  </logger>
  <root level="INFO">
    <appender-ref ref="CONSOLE" />
    <appender-ref ref="ASYNC_FILE" />
  </root>
</springProfile>

<springProfile name="prod">
  <logger name="com.mtitek.spring" level="INFO" additivity="false">
    <appender-ref ref="ASYNC_FILE" />
  </logger>
  <root level="WARN">
    <appender-ref ref="ASYNC_FILE" />
  </root>
</springProfile>

Test Logback (src/test/resources/logback-test.xml)

• Minimal: CONSOLE only, no file appender, no rolling policy — keeps test output clean and fast.
• Picked up automatically by Logback during test execution when present in src/test/resources — takes precedence over logback-spring.xml.

Testing

• @SpringBootTest boots the full application context for each test run.
• The contextLoads() test is a smoke test — it passes if and only if the context starts without errors.
• Test profile is prod (set in src/test/resources/application.yml) — file logging suppressed, root level WARN.

@SpringBootTest
class MtitekSpringStarterProjectApplicationTests {
    @Test
    void contextLoads() { }
}

Build & Run

• Run from IDE: execute main() in MtitekSpringStarterProjectApplication.
• Run with Maven: mvn spring-boot:run
• Package the fat JAR and run it:

mvn clean package
java -jar target/mtitek-spring-starter-project-0.0.1-SNAPSHOT.jar

• Override the active profile at runtime:

java -jar target/mtitek-spring-starter-project-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod

The ./logs directory is created relative to the working directory at runtime — not relative to the JAR location. Adjust LOG_PATH in logback-spring.xml or pass -DLOG_PATH=/LOG_PATH as a JVM argument for deployments.