Spring Framework 3.0: What's New, Release History & Support Lifecycle

What Is New in Spring Framework 3.0

Spring Framework 3.0 is a major release focused on modernizing the codebase for Java 5+ and introducing core enhancements that shape the framework's future direction. The key theme is embracing annotation-based configuration and expression-driven logic across the container, MVC, and data layers.

How did the core container become more expressive?

The core IoC container shifted its foundation to fully leverage Java 5 features. This move wasn't just about syntax; it enabled a more type-safe and intention-revealing programming model for Spring beans.

Annotation-Driven Dependency Injection

Classpath scanning for @Component stereotypes (@Service, @Repository) became a first-class alternative to XML bean definitions. The @Autowired annotation allowed for concise, declarative injection points, reducing verbose property and constructor ref tags.

// Before: XML <property name="service" ref="myService"/>
// After:
@Component
public class MyProcessor {
    @Autowired
    private MyService service;
}

Spring Expression Language (SpEL)

SpEL integrated directly into the container, letting you reference bean properties, system environments, or perform simple logic right in your XML or annotation values. This made configuration more dynamic without writing custom factory code.

<bean id="dataSource" class="...">
    <property name="url" value="#{systemProperties['db.url']}"/>
</bean>

What changed for building web applications?

Spring MVC was overhauled to support annotation-based controllers, which dramatically simplified request mapping and handler method signatures. This laid the groundwork for the REST support that would mature in later releases.

Annotation-Based Controllers

The @Controller and @RequestMapping annotations eliminated the need to implement specific interfaces or extend base classes. Handler methods could have flexible arguments and return types, making unit testing straightforward.

@Controller
public class UserController {
    @RequestMapping("/user/{id}")
    public String getUser(@PathVariable("id") Long id, Model model) {
        // ...
    }
}

Early REST Support and URI Templates

While full REST controllers came later, 3.0 introduced essential building blocks. The @PathVariable annotation and URI template support in @RequestMapping made it possible to build clean, resource-oriented URLs. The framework also started offering content negotiation for different response formats (XML, JSON).

How did data access and validation improve?

This release integrated modern persistence standards and validation APIs, reducing the boilerplate needed for common data tasks. It was a step towards unifying Spring's data philosophy with Java EE standards.

JSR-303 Bean Validation

Spring provided built-in support for JSR-303 (Bean Validation), allowing you to annotate your model objects with constraints like @NotNull and @Size. The framework automatically invoked validators within its data binding workflow, especially useful in web layers.

public class Person {
    @NotNull
    @Size(min=2, max=30)
    private String name;
    // getters and setters
}

JPA 2.0 Support

While Spring had long supported JPA, 3.0 began aligning with JPA 2.0 features. This included better integration of new criteria APIs and enhanced persistence context propagation, although full 2.0 support stabilized in subsequent releases.

Why was the testing framework updated?

Spring 3.0 solidified the framework's commitment to first-class testing support. New annotations made it easier to load application contexts and inject dependencies directly into unit tests, blurring the line between unit and integration testing in a productive way.

The @ContextConfiguration annotation became the standard way to specify which Spring configuration files to load for a test class. Annotations like @Autowired could be used in test classes to pull in beans, and @TransactionConfiguration helped manage test transactions. This made testing Spring components far less cumbersome.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-config.xml")
public class MyServiceTest {
    @Autowired
    private MyService service;
    // test methods
}