Spring Framework Overview: Concepts, Modules, Configuration, and Annotations

Spring is an open‑source application framework that aims to reduce the complexity of Java application development. It is lightweight, loosely coupled, and provides a layered architecture that allows developers to pick and choose components while offering a cohesive platform for J2EE development.

Key advantages include its modular architecture, support for POJO programming, simplified JDBC access through dependency injection, and the fact that it is free and open source.

Core functionalities of Spring cover a wide range of concerns: lightweight container, Inversion of Control (IoC), Aspect‑Oriented Programming (AOP), a configurable MVC web framework, transaction management, and a comprehensive JDBC exception hierarchy.

The framework is divided into several modules:

Core Container : Spring Core, Spring Bean, Spring Expression Language (SpEL), Spring Context.

Data Access/Integration : JDBC, ORM, OXM, JMS, Transaction.

Web : AOP, Web MVC, Servlet, WebSocket, Portlet, Instrumentation, Test.

Miscellaneous : Messaging (STOMP), Aspects (AspectJ integration).

Spring configuration files are typically XML documents that declare bean definitions, their properties, and wiring information. XML can be verbose, so Spring also supports annotation‑based and Java‑based configuration.

A typical Spring application consists of interfaces, bean classes (with properties, getters, and setters), AOP components, bean configuration files, and user programs that consume the beans.

Spring can be used in several ways: as a full‑stack web application framework, as a middle‑tier framework integrated with other web frameworks, for remote services, or as a container for plain old Java objects (POJOs).

The IoC container creates, configures, assembles, and manages the full lifecycle of beans using dependency injection. Configuration metadata can be supplied via XML, Java annotations, or Java code.

Dependency injection (DI) allows developers to describe how objects should be created and wired without manually instantiating them. DI can be performed via constructor injection, setter injection, or (in theory) interface injection, though Spring primarily supports the first two.

Spring defines five bean scopes: singleton (one instance per container), prototype (new instance on each request), request (per HTTP request), session (per HTTP session), and global‑session (for portlet environments).

The bean lifecycle includes instantiation, property population, awareness callbacks (BeanNameAware, BeanFactoryAware), BeanPostProcessor pre‑initialization, custom init‑method invocation, post‑initialization processing, and optional destroy callbacks when the container shuts down.

Internal beans are anonymous beans defined as properties of other beans; they are always prototype scoped.

Spring supports several autowiring modes: no (default, no autowiring), byName, byType, constructor, and autodetect. Autowiring can be overridden with explicit ref or value settings, and it does not apply to simple data types.

Important Spring annotations include:

@Controller – marks a class as a Spring MVC controller.

@Service – indicates a service‑layer component.

@RequestMapping – maps HTTP requests to controller methods.

@ResponseBody – returns objects as JSON/XML responses.

@PathVariable – binds URI template variables to method parameters.

@Autowired – injects bean dependencies automatically.

@Qualifier – resolves ambiguity when multiple beans of the same type exist.

@Scope – defines bean scope.

@Configuration, @ComponentScan, @Bean – enable Java‑based configuration.

@Aspect, @Before, @After, @Around, @Pointcut – support AOP.

To enable annotation‑based configuration, the <context:annotation-config/> element must be added to the Spring XML configuration.

Example XML bean definition:

<bean id="studentbean" class="org.edureka.firstSpring.StudentBean">
    <property name="name" value="Edureka"/>
</bean>

Example Java‑based configuration:

public class StudentConfig {
    @Bean
    public StudentBean myStudent() {
        return new StudentBean();
    }
}