Read this blog aloud:
One of the most significant upgrades in the Java world happened at the end of 2025, Spring Boot was upgraded from 3.x to 4.0 along with the main Spring Framework upgrading from Spring 6.x to Spring 7.0. In this blog we look at what the main changes are, what impact they might have on a project / developer, what you need to use the latest version of Spring Boot and why you should consider upgrading.
Spring Boot
Let’s start off with what is Spring Boot? Spring Boot aims to make working with the (now huge) Spring Framework and eco system easier. It takes a n opinionated view of the Spring platform and how you should work with it. This helps developers and projects to get started with a Spring application with the minimum of fuss and configuration. It can be used to create standalone Spring applications, embed web servers within an application, deploy onto a web server, and incorporate logging, metrics and management facilities into an application. For more information on Spring Boot see the main Spring Boot documentation site.
It’s important to release that Spring Boot builds upon, and relies on, the Spring Framework. You cannot use Spring Boot without using Spring. In fact, Spring Boot is a module which builds upon and configures the main Spring framework. This means you can use Spring without Spring Boot (but why would you want to?).
Working with Spring Boot
When you create a new project using Spring Boot many defaults are assumed that you would otherwise have to set manually yourself. There are also default Spring Boot configurations that can be used to further set up a project. It is also possible for Spring Boto to discover what modules you are using and to infer their configurations. It is of course, possible to override these defaults but in many (most?) cases they are at least suitable for an initial set up.
In fact, this feature makes it particularly well suited for cloud computing environments / docker configurations as many of the Spring Boot defaults suit those environments and make creating a container very straight forward.
Spring Boot 4.0 / Spring framework 7.0
Back in 2022 when Spring Boot 3 and Spring Framework 6 were launched they represented a major step forward in how developers worked with Spring. For example, they started the migration from the javax.* to the jakarta.* world as well as providing early support for GraalVM. The latest Spring Boot 4.0 and Spring Framework 7.0 have significantly accelerated this move. Both these new versions move Spring into the world of modern Java applications, libraries and code styles. They also move the Kotlin view of Spring forward significantly as well.
To summarise the new features in Spring Boot 4.0 and Spring framework 7.0 we can list:
Updated Java Baseline
Jakarta 11 has now been fully adopted
Kotlin 2.2 is now required
GraalVM Improved Support
The Spring codebase has been restructured into smaller modules
Standardised Approach to Defining Nullability
Provision of the HTTPServiceClient class
API Versioning
Testing Upgrades
General 3rd Party Library Upgrade Maintenance
Logging and Monitoring Developments
Removal of XML Configuration
Spring AI Integration
Let's take a look at some of the highlights...
Updated Java baseline
The Java Baseline has been moved forward. In line with identified LTS (Long Term Support) versions of Java, Spring Framework 7.0 requires at least Java 17 as a minimum (as was the case with the previous version of Spring) but now strongly recommends updating to either Java 21 or ideally Java 25. Sticking with Java 17 reflects that fact that many developers are still having to use this version of the language. However, moving to a newer version can provide productivity, performance and memory gains and is thus the recommended approach from Spring.
Jakarta 11 fully Supported
Jakarta 11 has now been fully adopted. Previously support for the older Java Enterprise Edition packaging naming was still supported. This has now been removed from the Spring world and instead it has fully adopted the Jakarta package structures. This means that Spring 7.0 has now moved up to Servlet 6.1, JPA 3.2, JUnit 6.x??? and Bean Validation 3.1.
Kotlin 2.2 Support
Kotlin 2.2 is now required when using Spring from Kotlin. This moves Spring forward within the Kotlin world, bringing improved coroutine support and better Gradle integration. 
GraalVM Improved Support
Spring Boot 4’s support for, and integration with, GraalVM 24 is significantly enhanced.
More Modular Design
The whole of the Spring codebase has been repackaged to reduce dependencies between modules and to allow the set of runtime libraries used to be smaller in size. This represents a complete restructuring and modularization of the Spring Boot codebase providing smaller and more focused jars. For new projects this is hidden from the developer. For existing projects this may require some refactoring and further configuration. Alternatively, you can add the spring-boot-autoconfigure-classic module which will collect all auto-configuration classes into one dependency and allow your existing code to run on top of the new modular structure.
Standardised Approach to Defining Nullability
Framework wide improvements for null safety with JSpecify. Java allows null to be used to represent a variable of some object type. However, languages such as Kotlin do not and the use of null is often considered harmful in many Java development teams. To aid this Spring had provided the ability to indicate that a value should not be null or should be allowed to be null. However, not all Spring modules used the same way of specifying nullability. In Spring Framework 7.0 this is standardised to use the JSpecify library using @NonNull and @Nullable. This also provides better alignment with the Kotlin world.
Provision of the HTTPServiceClient class
HTTPServiceClients are a new feature which allow the developer to specify a suitably annotated Java interface and then allow the HTTPServiceClient to provide the boiler plate code to access remote HTTP APIs. This significantly reduces the amount of such code that needs to be written by a developer.
API Versioning
A standard way of indicating versioning information has been introduced to Spring Framework 7.0. This allows a version number to be specified for an API allowing the changes in behaviour to be represented by, for example different methods, with different version meta data. The user of this API can then use this information when invoking the API and Spring will handle routing the request to the correct method.
Testing Upgrades
Testing has been upgraded with a move to JUnit Jupiter 6.x and Mockito 5.20 as well as additional supporting classes such as RestTestClient to simplify the testing of restful APIs.
General 3rd Party Library Upgrade Maintenance
Other 3rd party modules have also been updated for example, Jackson 3.x, Hibernate 7.1, Jetty 6.2.0, Tomcat 11.0 etc.
Logging and Monitoring Developments
Logging enhancements are also included. The Spring JCL logging bridge has been removed and replaced with the Apache Commons Logging framework.
In terms of monitoring, the previous observability API has been revised such that it now uses the latest OpenTelemetry SDK with a default starter that configures this. Some of the observability modules have also changed their names, for example spring-boot-metrics becomes spring-boot-micrometer-metrics, representing the change in the lower-level implementation. 
Removal of XML Configuration
Removal of the XML-based configuration. Originally, most Spring applications were configured using external XML files. However, the move away from XML started a long time ago and now finally, this feature has been removed altogether.
Spring AI Integration
Spring AI is an application framework for AI engineering. It aims to make the integration of AI tools, into a Spring based application, as seamless as integrating a database. Spring Framework 7.0 provides initial integration for this Spring module.
Upgrading to Spring Boot 4.0
Given the changes to both Spring Boot 4.0 and Spring Framework 7.0 care should be taken when upgrading. If you have a project which is on a version of Spring that predates Spring Boot 3.5, then you should first move to that version. Spring 4.0 removes many methods, classes and properties which are marked as deprecated in Spring Boot 3.5. Only once there are no deprecation warnings should you consider upgrading to Spring Boot 4.0. For more information see the Spring 3.5 to 4.0 migration guide.
Summary
Planning to upgrade to Spring Boot 4.0 needs consideration and planning, however using Spring Boot 4.0 for a new Spring based project should be a no brainer. Spring Boot 4.0 (and the associated Spring Framework 7.0) bring significant updates in terms of performance, developer support, security both in terms of how a developer works with APIs but also in terms of support that improves the integrity of your code and adds useful new features that reduce the amount of boiler plate code you must write. The fact that it can also support newer languages constructs in the latest versions of java dn Kotlin is just the icing on the cake.