or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

aop.mdcore-container.mddata-access.mdindex.mdintegration.mdmessaging.mdreactive-web.mdtesting.mdweb-framework.md
tile.json

tessl/maven-org-springframework--spring

Comprehensive application framework and inversion of control container for the Java platform providing dependency injection, AOP, data access, transaction management, and web framework capabilities

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework/spring@5.3.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework--spring@5.3.0

index.mddocs/

Spring Framework

The Spring Framework is a comprehensive application framework and inversion of control container for the Java platform. It provides a complete programming and configuration model for modern Java-based enterprise applications, with extensive infrastructure support for developing Java applications.

Package Information

Maven Coordinates:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.39</version>
</dependency>

Gradle:

implementation("org.springframework:spring-context:5.3.39")

Java Version: Requires Java 8 or higher

Key Dependencies:

  • Spring uses SLF4J for logging
  • Optional dependencies include Jackson for JSON processing, AspectJ for AOP
  • Integration available with Hibernate, JPA, R2DBC, and other persistence frameworks

Core Imports

Essential Imports for Getting Started

// Core Application Context
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// Configuration and Component Scanning
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Bean;

// Dependency Injection Annotations
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Repository;

// Value Injection and Profiles
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Profile;

Resource and Property Management

import org.springframework.core.io.Resource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.env.Environment;
import org.springframework.context.annotation.PropertySource;

Basic Usage

Simple Spring Application

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    
    @Bean
    public DataService dataService() {
        return new DataServiceImpl();
    }
}

@Component
public class BusinessService {
    
    @Autowired
    private DataService dataService;
    
    public String processData(String input) {
        return dataService.transform(input);
    }
}

// Application startup
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        BusinessService service = context.getBean(BusinessService.class);
        String result = service.processData("hello");
        System.out.println(result);
    }
}

Property-Driven Configuration

@Configuration
@PropertySource("classpath:application.properties")
public class DatabaseConfig {
    
    @Value("${db.url}")
    private String dbUrl;
    
    @Value("${db.username}")
    private String dbUsername;
    
    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setUrl(dbUrl);
        dataSource.setUsername(dbUsername);
        return dataSource;
    }
}

Architecture

Core Architecture Components

Spring Framework is built on several foundational layers:

1. Core Container

  • Spring Core: Fundamental utilities, type conversion, and IoC container foundation
  • Spring Beans: Bean instantiation, dependency injection, and lifecycle management
  • Spring Context: Application context, events, validation, and internationalization
  • Spring Expression: Spring Expression Language (SpEL) for dynamic property access

2. Data Access Layer

  • Spring JDBC: Simplified JDBC operations and exception handling
  • Spring Transaction: Declarative and programmatic transaction management
  • Spring ORM: Integration with Hibernate, JPA, and other ORM frameworks
  • Spring R2DBC: Reactive database connectivity support

3. Web Layer

  • Spring Web: Web application utilities and WebApplicationContext
  • Spring WebMVC: Traditional servlet-based MVC framework
  • Spring WebFlux: Reactive web framework for non-blocking applications

4. Integration Layer

  • Spring AOP: Aspect-oriented programming with method interception
  • Spring Messaging: Message-driven applications and abstractions
  • Spring JMS: Java Message Service integration
  • Spring WebSocket: WebSocket support for real-time communication

Dependency Injection Container

// Container interfaces
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
}

public interface ApplicationContext extends BeanFactory, MessageSource, 
        ApplicationEventPublisher, ResourceLoader {
    String getId();
    String getApplicationName();
    String getDisplayName();
    long getStartupDate();
    ApplicationContext getParent();
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

Capabilities

Core Container & Dependency Injection

The Spring IoC container manages object creation, dependency injection, and lifecycle. It supports various injection methods including constructor injection, setter injection, and field injection.

Key APIs:

// Bean Definition and Configuration
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    String getBeanClassName();
    void setBeanClassName(String beanClassName);
    String getScope();
    void setScope(String scope);
    boolean isLazyInit();
    String[] getDependsOn();
}

// Property Access and Type Conversion
public interface BeanWrapper extends ConfigurablePropertyAccessor {
    Object getWrappedInstance();
    Class<?> getWrappedClass();
    PropertyDescriptor[] getPropertyDescriptors();
    PropertyDescriptor getPropertyDescriptor(String propertyName) 
            throws InvalidPropertyException;
}

For comprehensive details: Core Container & Dependency Injection

Aspect-Oriented Programming (AOP)

Spring AOP provides aspect-oriented programming implementation allowing you to define method interceptors and pointcuts to cleanly decouple functionality.

Key APIs:

// Core AOP interfaces
public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation invocation) throws Throwable;
}

public interface Pointcut {
    ClassFilter getClassFilter();
    MethodMatcher getMethodMatcher();
}

// Proxy creation
public class ProxyFactory extends AdvisedSupport {
    public Object getProxy();
    public Object getProxy(ClassLoader classLoader);
    public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor);
}

For comprehensive details: Aspect-Oriented Programming

Data Access & Transaction Management

Spring provides abstraction over JDBC, transaction management, and integration with ORM frameworks like Hibernate and JPA.

Key APIs:

// JDBC Template
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
    public <T> T queryForObject(String sql, Class<T> requiredType, Object... args);
    public <T> List<T> query(String sql, RowMapper<T> rowMapper, Object... args);
    public int update(String sql, Object... args);
}

// Transaction Management
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    Propagation propagation() default Propagation.REQUIRED;
    Isolation isolation() default Isolation.DEFAULT;
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    boolean readOnly() default false;
}

For comprehensive details: Data Access & Transaction Management

Web Framework (Spring MVC)

Spring MVC provides Model-View-Controller architecture for building web applications with flexible request handling and view resolution.

Key APIs:

// Controller annotations
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    String value() default "";
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
    String[] value() default {};
    RequestMethod[] method() default {};
    String[] params() default {};
    String[] headers() default {};
}

For comprehensive details: Web Framework (Spring MVC)

Reactive Web Framework (WebFlux)

Spring WebFlux provides reactive programming model for building non-blocking web applications using Reactor and reactive streams.

Key APIs:

// Functional routing
public interface RouterFunction<T extends ServerResponse> {
    Mono<HandlerFunction<T>> route(ServerRequest request);
    RouterFunction<T> and(RouterFunction<T> other);
    RouterFunction<T> andRoute(RequestPredicate predicate, HandlerFunction<T> handlerFunction);
}

// Reactive request/response
public interface ServerRequest {
    Mono<String> bodyToMono(Class<String> elementClass);
    <T> Flux<T> bodyToFlux(Class<T> elementClass);
    MultiValueMap<String, String> queryParams();
}

For comprehensive details: Reactive Web Framework (WebFlux)

Testing Support

Spring Test provides comprehensive testing utilities including TestContext framework, MockMvc for web layer testing, and transaction rollback support.

Key APIs:

// Test annotations
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@BootstrapWith(SpringBootTestContextBootstrapper.class)
public @interface SpringBootTest {
    Class<?>[] classes() default {};
    String[] properties() default {};
    WebEnvironment webEnvironment() default WebEnvironment.MOCK;
}

// MockMvc for web testing
public final class MockMvc {
    public ResultActions perform(RequestBuilder requestBuilder) throws Exception;
}

For comprehensive details: Testing Support

Messaging & JMS

Spring provides abstractions for message-driven applications including support for JMS, AMQP, and custom messaging solutions.

Key APIs:

// Message abstraction
public interface Message<T> {
    T getPayload();
    MessageHeaders getHeaders();
}

// JMS Template
public class JmsTemplate extends JmsDestinationAccessor implements JmsOperations {
    public void send(String destinationName, MessageCreator messageCreator) throws JmsException;
    public Object receiveAndConvert(String destinationName) throws JmsException;
}

For comprehensive details: Messaging & JMS

Integration & Support

Additional Spring modules provide integration with various enterprise technologies and cross-cutting concerns.

Key Areas:

  • Spring Aspects: AspectJ integration for advanced AOP
  • Spring Instrument: Load-time weaving and instrumentation
  • Spring Context Support: Additional context implementations
  • Spring WebSocket: WebSocket support for real-time communication
  • Spring OXM: Object/XML mapping abstractions

For comprehensive details: Integration & Support

Common Patterns

Configuration Patterns

// Java-based configuration
@Configuration
@EnableTransactionManagement
@ComponentScan(basePackages = {"com.example.service", "com.example.repository"})
public class AppConfig {
    
    @Bean
    @Profile("development")
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
    
    @Bean
    @Profile("production")
    public DataSource prodDataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:postgresql://localhost/mydb");
        return dataSource;
    }
}

Dependency Injection Best Practices

// Constructor injection (recommended)
@Service
public class OrderService {
    
    private final PaymentService paymentService;
    private final EmailService emailService;
    
    public OrderService(PaymentService paymentService, EmailService emailService) {
        this.paymentService = paymentService;
        this.emailService = emailService;
    }
}

// Qualifier for multiple implementations
@Service
public class NotificationService {
    
    @Autowired
    @Qualifier("emailNotifier")
    private Notifier emailNotifier;
    
    @Autowired
    @Qualifier("smsNotifier")  
    private Notifier smsNotifier;
}

Resource Management

// Resource loading
@Service
public class ConfigurationService {
    
    @Autowired
    private ResourceLoader resourceLoader;
    
    public Properties loadConfiguration(String configPath) {
        try {
            Resource resource = resourceLoader.getResource("classpath:" + configPath);
            Properties props = new Properties();
            props.load(resource.getInputStream());
            return props;
        } catch (IOException e) {
            throw new ConfigurationException("Failed to load configuration", e);
        }
    }
}

Module Dependencies

Understanding Spring's modular architecture helps in selecting the right dependencies:

  • spring-core + spring-beans: Minimal IoC container
  • + spring-context: Full application context with events, validation, i18n
  • + spring-aop: Aspect-oriented programming support
  • + spring-web: Web application utilities
  • + spring-webmvc: Traditional MVC framework
  • + spring-webflux: Reactive web framework (alternative to webmvc)
  • + spring-jdbc + spring-tx: Data access and transaction management
  • + spring-orm: ORM integration (Hibernate, JPA)
  • + spring-test: Testing utilities and TestContext framework

For a complete Spring application, typically you'll need spring-context (which includes core and beans) plus specific modules for your use case (web, data access, etc.).