Spring Boot 4 and Spring Framework 7: The New Era of Java for Fast and Secure Microservices

// src/main/java/com/yourcompany/service/package-info.java
@org.jspecify.annotations.NullMarked
package com.yourcompany.service;

@NullMarked
package com.example.users;

public class UserService {

    // The IDE will warn if you try to pass null
    public User createUser(@NonNull String name, @Nullable String lastName) {
        // name is never null - safe to use directly
        String fullName = name.toUpperCase();

        // lastName can be null - you must check
        if (lastName != null) {
            fullName += " " + lastName.toUpperCase();
        }

        return new User(fullName);
    }
}

package com.yourcompany.clients;

import org.springframework.web.service.annotation.GetExchange;
import org.springframework.web.service.annotation.PostExchange;
import org.springframework.web.service.annotation.HttpExchange;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;

@HttpExchange("/api/products")
public interface ProductClient {

    @GetExchange("/{id}")
    Product getProduct(@PathVariable("id") String id);

    @GetExchange
    List<Product> listProducts();

    @PostExchange
    Product createProduct(@RequestBody Product product);
}

@Configuration
public class ClientConfig {

    @Bean
    public ProductClient productClient(RestClient.Builder builder) {
        RestClient restClient = builder
            .baseUrl("https://api.example.com")
            .build();

        HttpServiceProxyFactory factory = HttpServiceProxyFactory
            .builderFor(RestClientAdapter.create(restClient))
            .build();

        return factory.createClient(ProductClient.class);
    }
}

@Service
@EnableResilientMethods
public class PaymentService {

    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public PaymentResponse processPayment(PaymentRequest request) {
        // If it fails, it retries up to 3 times with 1 second wait
        return paymentGateway.process(request);
    }

    @ConcurrencyLimit(maxConcurrency = 10)
    public Report generateReport() {
        // Maximum 10 concurrent calls
        return reportService.generate();
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    // Version 1: Simple response
    @GetMapping(version = "1", produces = MediaType.APPLICATION_JSON_VALUE)
    public List<OrderV1> getOrdersV1() {
        return orderService.getSimpleOrders();
    }

    // Version 2: Enriched response with metadata
    @GetMapping(version = "2", produces = MediaType.APPLICATION_JSON_VALUE)
    public OrderResponseV2 getOrdersV2() {
        return orderService.getCompleteOrders();
    }
}

@Configuration
public class ApiVersioningConfig implements WebMvcConfigurer {

    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        // Header strategy
        configurer.apiVersioning(builder -> builder
            .strategy(VersionStrategy.HEADER)
            .headerName("API-Version")
        );

        // Or by path: /v1/orders, /v2/orders
        // Or by query parameter: /orders?version=1
    }
}

@Service
public class InventoryService {

    @Observed(name = "inventory.check", contextualName = "checkAvailability")
    public boolean checkAvailability(String productId) {
        // Automatically generates metrics for:
        // - Execution time
        // - Number of calls
        // - Error rate
        return inventoryRepository.hasStock(productId);
    }
}

{
  "status": "UP",
  "components": {
    "ssl": {
      "status": "WARNING",
      "details": {
        "certificate": "api.example.com",
        "expiresIn": "12 days",
        "expiryDate": "2025-12-05"
      }
    }
  }
}

public List<Person> findAll() {
    return jdbcTemplate.query(
        "SELECT id, name, age FROM person",
        new RowMapper<Person>() {
            @Override
            public Person mapRow(ResultSet rs, int rowNum) throws SQLException {
                Person p = new Person();
                p.setId(rs.getLong("id"));
                p.setName(rs.getString("name"));
                p.setAge(rs.getInt("age"));
                return p;
            }
        }
    );
}

public List<Person> findAll() {
    return jdbcClient.sql("SELECT id, name, age FROM person")
        .query((rs, rowNum) -> new Person(
            rs.getLong("id"),
            rs.getString("name"),
            rs.getInt("age")
        ))
        .list();
}

// Or even simpler with automatic mapping
public List<Person> findAll() {
    return jdbcClient.sql("SELECT * FROM person")
        .query(Person.class)
        .list();
}

public Optional<Person> findById(Long id) {
    return jdbcClient.sql("SELECT * FROM person WHERE id = :id")
        .param("id", id)
        .query(Person.class)
        .optional();
}

public int updateAge(Long id, int newAge) {
    return jdbcClient.sql("UPDATE person SET age = :age WHERE id = :id")
        .param("age", newAge)
        .param("id", id)
        .update();
}

@HttpServiceClientTest
class ProductClientTest {

    @Autowired
    private ProductClient productClient;

    @Test
    void shouldGetProduct() {
        // Only loads configuration needed for HTTP clients
        Product product = productClient.getProduct("123");
        assertThat(product).isNotNull();
    }
}

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class IntegrationTest {

    @Autowired
    private TestRestClient restClient;

    @Test
    void shouldCreateUser() {
        User newUser = new User("John", "Doe");

        User created = restClient.post()
            .uri("/api/users")
            .body(newUser)
            .exchange()
            .expectStatus().isCreated()
            .expectBody(User.class)
            .returnResult();

        assertThat(created.getId()).isNotNull();
    }
}

<plugin>
    <groupId>org.openrewrite.maven</groupId>
    <artifactId>rewrite-maven-plugin</artifactId>
    <version>5.42.0</version>
    <configuration>
        <activeRecipes>
            <recipe>org.openrewrite.java.spring.boot4.UpgradeSpringBoot_4_0</recipe>
        </activeRecipes>
    </configuration>
</plugin>