tessl/maven-org-springframework-boot--spring-boot-starter

Core starter providing fundamental building blocks for Spring Boot applications with auto-configuration support, logging, and YAML parsing

—

Pending

Overview

Eval results

Files

Spring Boot Starter

Name: tessl/maven-org-springframework-boot--spring-boot-starter
Author: tessl

The Spring Boot Starter is the foundational dependency for all Spring Boot applications, providing essential building blocks including auto-configuration support, logging infrastructure, and YAML configuration parsing. It acts as a comprehensive dependency aggregator that automatically brings together the core Spring Boot components needed to bootstrap production-grade applications.

Package Information

Package Name: org.springframework.boot:spring-boot-starter
Package Type: maven
Language: Java
Version: 3.5.3
Installation: <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId><version>3.5.3</version></dependency>

Core Imports

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.ApplicationRunner;

Basic Usage

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

For command line runners:

@Component
public class StartupRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("Application started with command line args: " + Arrays.toString(args));
    }
}

Architecture

Spring Boot Starter is built around several key architectural components:

Application Bootstrap: SpringApplication class provides the main entry point with lifecycle management
Auto-Configuration System: Automatic configuration based on classpath detection and conditional logic
Configuration Properties: Type-safe binding of external configuration to Java objects
Web Framework Integration: Embedded server support for both servlet and reactive applications
Dependency Aggregation: Curated set of compatible dependencies with sensible defaults

Capabilities

Application Bootstrap & Lifecycle

Core application startup, lifecycle management, and command line argument processing. Essential for every Spring Boot application.

public class SpringApplication {
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args);
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String... args);
    public SpringApplication(Class<?>... primarySources);
    public ConfigurableApplicationContext run(String... args);
}

@interface SpringBootApplication {
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
    String[] scanBasePackages() default {};
    Class<?>[] scanBasePackageClasses() default {};
}

Application Bootstrap

Auto-Configuration System

Intelligent automatic configuration based on classpath detection, providing convention-over-configuration setup for Spring Boot applications.

@interface EnableAutoConfiguration {
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

@interface AutoConfiguration {
    String[] after() default {};
    String[] before() default {};
    Class<?>[] afterName() default {};
    Class<?>[] beforeName() default {};
}

@interface ConditionalOnClass {
    Class<?>[] value() default {};
    String[] name() default {};
}

@interface ConditionalOnMissingBean {
    Class<?>[] value() default {};
    String[] type() default {};
    Class<? extends Annotation>[] annotation() default {};
}

Auto-Configuration

Configuration Properties

Type-safe configuration property binding with validation support, enabling external configuration management.

@interface ConfigurationProperties {
    String value() default "";
    String prefix() default "";
    boolean ignoreInvalidFields() default false;
    boolean ignoreUnknownFields() default true;
}

@interface EnableConfigurationProperties {
    Class<?>[] value() default {};
}

public class PropertyMapper {
    public static PropertyMapper get();
    public <T> PropertyMapper.Source<T> from(T value);
    public <T> PropertyMapper.Source<T> from(Supplier<T> supplier);
}

Configuration Properties

Web Framework Support

Comprehensive web application support including embedded servers (Tomcat, Jetty, Undertow, Netty) for both servlet and reactive applications.

public enum WebApplicationType {
    NONE, SERVLET, REACTIVE
}

public interface WebServer {
    void start() throws WebServerException;
    void stop() throws WebServerException;
    int getPort();
    void shutDownGracefully(GracefulShutdownCallback callback);
}

public interface ServletWebServerFactory extends WebServerFactory {
    WebServer getWebServer(ServletContextInitializer... initializers);
}

public interface ReactiveWebServerFactory extends WebServerFactory {
    WebServer getWebServer(HttpHandler httpHandler);
}

Web Framework

Data Access & Persistence

Database connectivity, transaction management, and ORM integration with support for JDBC, JPA, R2DBC, and database migration tools.

public final class DataSourceBuilder {
    public static DataSourceBuilder create();
    public static DataSourceBuilder create(ClassLoader classLoader);
    public DataSourceBuilder type(Class<? extends DataSource> type);
    public DataSourceBuilder url(String url);
    public DataSourceBuilder username(String username);
    public DataSourceBuilder password(String password);
    public <T extends DataSource> T build();
}

@interface EntityScan {
    String[] value() default {};
    String[] basePackages() default {};
    Class<?>[] basePackageClasses() default {};
}

Data Access

Logging & Diagnostics

Comprehensive logging infrastructure with structured logging support and application failure analysis capabilities.

public abstract class LoggingSystem {
    public static LoggingSystem get(ClassLoader classLoader);
    public abstract void beforeInitialize();
    public abstract void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile);
    public abstract void cleanUp();
}

public enum LogLevel {
    TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF
}

public interface FailureAnalyzer {
    FailureAnalysis analyze(Throwable failure);
}

Logging & Diagnostics

Task Execution & Scheduling

Asynchronous task execution and scheduling infrastructure with customizable thread pool management.

public class ThreadPoolTaskExecutorBuilder {
    public ThreadPoolTaskExecutorBuilder corePoolSize(int corePoolSize);
    public ThreadPoolTaskExecutorBuilder maxPoolSize(int maxPoolSize);
    public ThreadPoolTaskExecutorBuilder queueCapacity(int queueCapacity);
    public ThreadPoolTaskExecutorBuilder keepAlive(Duration keepAlive);
    public ThreadPoolTaskExecutorBuilder threadNamePrefix(String threadNamePrefix);
    public ThreadPoolTaskExecutor build();
}

public interface TaskExecutor extends Executor {
    void execute(Runnable task);
}

Task Execution

Common Types

public interface ApplicationArguments {
    String[] getSourceArgs();
    Set<String> getOptionNames();
    boolean containsOption(String name);
    List<String> getOptionValues(String name);
    List<String> getNonOptionArgs();
}

public interface CommandLineRunner {
    void run(String... args) throws Exception;
}

public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

public interface BootstrapContext {
    <T> T get(Class<T> type) throws IllegalStateException;
    <T> T getOrElse(Class<T> type, T other);
    <T> boolean isRegistered(Class<T> type);
}

public interface ConfigurableBootstrapContext extends BootstrapContext {
    <T> void register(Class<T> type, InstanceSupplier<T> instanceSupplier);
    <T> void registerIfAbsent(Class<T> type, InstanceSupplier<T> instanceSupplier);
    void addCloseListener(ApplicationListener<BootstrapContextClosedEvent> listener);
    void close();
}

@FunctionalInterface
public interface InstanceSupplier<T> {
    T get(BootstrapContext context);
}

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-boot--spring-boot-starter

Workspace: tessl
Visibility: Public
Created: 6 months ago
Last updated: about 1 month ago
Describes: pkg:maven/org.springframework.boot/spring-boot-starter@3.5.x