Java Frameworks 2026: Spring Boot 4 vs. Quarkus 3.10 vs. Micronaut 4.5

// Spring Boot 4.0.0 CRUD Example: User Management Service
// Dependencies: spring-boot-starter-web, spring-boot-starter-data-jpa, com.h2database:h2:2.3.232
// Run: ./mvnw spring-boot:run
package com.example.springboot4demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;
import jakarta.persistence.*;
import jakarta.validation.*;
import jakarta.validation.constraints.*;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@SpringBootApplication
public class SpringBoot4DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBoot4DemoApplication.class, args);
    }
}

// JPA Entity: User
@Entity
@Table(name = \"users\")
class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = \"Username is required\")
    @Column(unique = true, nullable = false)
    private String username;

    @Email(message = \"Valid email required\")
    @Column(unique = true, nullable = false)
    private String email;

    @NotBlank(message = \"Full name is required\")
    private String fullName;

    private LocalDateTime createdAt = LocalDateTime.now();

    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
}

// JPA Repository
interface UserRepository extends JpaRepository {
    Optional findByUsername(String username);
    Optional findByEmail(String email);
    @Query(\"SELECT u FROM User u WHERE u.username LIKE %:query% OR u.email LIKE %:query%\")
    List searchUsers(@Param(\"query\") String query);
}

// Service Layer with error handling
@Service
class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User createUser(@Valid User user) {
        if (userRepository.findByUsername(user.getUsername()).isPresent()) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, \"Username already exists\");
        }
        if (userRepository.findByEmail(user.getEmail()).isPresent()) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, \"Email already exists\");
        }
        return userRepository.save(user);
    }

    public List getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, \"User not found with id: \" + id));
    }

    public User updateUser(Long id, @Valid User userDetails) {
        User existingUser = getUserById(id);
        // Check if new username is taken by another user
        userRepository.findByUsername(userDetails.getUsername())
                .ifPresent(u -> {
                    if (!u.getId().equals(id)) {
                        throw new ResponseStatusException(HttpStatus.CONFLICT, \"Username already exists\");
                    }
                });
        // Check if new email is taken by another user
        userRepository.findByEmail(userDetails.getEmail())
                .ifPresent(u -> {
                    if (!u.getId().equals(id)) {
                        throw new ResponseStatusException(HttpStatus.CONFLICT, \"Email already exists\");
                    }
                });
        existingUser.setUsername(userDetails.getUsername());
        existingUser.setEmail(userDetails.getEmail());
        existingUser.setFullName(userDetails.getFullName());
        return userRepository.save(existingUser);
    }

    public void deleteUser(Long id) {
        if (!userRepository.existsById(id)) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, \"User not found with id: \" + id);
        }
        userRepository.deleteById(id);
    }
}

// REST Controller
@RestController
@RequestMapping(\"/api/users\")
class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public User createUser(@Valid @RequestBody User user) {
        return userService.createUser(user);
    }

    @GetMapping
    public List getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping(\"/{id}\")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PutMapping(\"/{id}\")
    public User updateUser(@PathVariable Long id, @Valid @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping(\"/{id}\")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

// Quarkus 3.10.0 CRUD Example: User Management Service
// Dependencies: io.quarkus:quarkus-resteasy-reactive-jackson, io.quarkus:quarkus-hibernate-orm-panache, io.quarkus:quarkus-jdbc-h2
// Run: ./mvnw quarkus:dev
package com.example.quarkusdemo;

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Length;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import org.hibernate.validator.constraints.Length;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@QuarkusMain
public class QuarkusDemoApplication implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        Quarkus.waitForExit();
        return 0;
    }
}

// Panache Entity: User (reduces boilerplate compared to standard JPA)
@Entity
@Table(name = \"users\")
class User extends PanacheEntity {
    @NotBlank(message = \"Username is required\")
    @Length(min = 3, max = 50)
    public String username;

    @Email(message = \"Valid email required\")
    @NotBlank
    public String email;

    @NotBlank(message = \"Full name is required\")
    public String fullName;

    public LocalDateTime createdAt = LocalDateTime.now();

    // Static helper methods for queries
    public static Optional findByUsername(String username) {
        return find(\"username\", username).firstResultOptional();
    }

    public static Optional findByEmail(String email) {
        return find(\"email\", email).firstResultOptional();
    }

    public static List searchUsers(String query) {
        return find(\"username like ?1 or email like ?1\", \"%\" + query + \"%\").list();
    }
}

// Resource class (equivalent to Spring controller)
@Path(\"/api/users\")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
class UserResource {
    // Create new user
    @POST
    public Response createUser(@Valid User user) {
        // Check for duplicate username
        User.findByUsername(user.username).ifPresent(u -> {
            throw new WebApplicationException(\"Username already exists\", Response.Status.CONFLICT);
        });
        // Check for duplicate email
        User.findByEmail(user.email).ifPresent(u -> {
            throw new WebApplicationException(\"Email already exists\", Response.Status.CONFLICT);
        });
        user.persist();
        return Response.status(Response.Status.CREATED).entity(user).build();
    }

    // Get all users
    @GET
    public List getAllUsers() {
        return User.listAll();
    }

    // Get user by id
    @GET
    @Path(\"/{id}\")
    public User getUserById(@PathParam(\"id\") Long id) {
        return User.findByIdOptional(id)
                .orElseThrow(() -> new WebApplicationException(\"User not found with id: \" + id, Response.Status.NOT_FOUND));
    }

    // Update user
    @PUT
    @Path(\"/{id}\")
    public User updateUser(@PathParam(\"id\") Long id, @Valid User userDetails) {
        User existingUser = User.findByIdOptional(id)
                .orElseThrow(() -> new WebApplicationException(\"User not found with id: \" + id, Response.Status.NOT_FOUND));
        // Check if new username is taken by another user
        User.findByUsername(userDetails.username).ifPresent(u -> {
            if (!u.id.equals(id)) {
                throw new WebApplicationException(\"Username already exists\", Response.Status.CONFLICT);
            }
        });
        // Check if new email is taken by another user
        User.findByEmail(userDetails.email).ifPresent(u -> {
            if (!u.id.equals(id)) {
                throw new WebApplicationException(\"Email already exists\", Response.Status.CONFLICT);
            }
        });
        existingUser.username = userDetails.username;
        existingUser.email = userDetails.email;
        existingUser.fullName = userDetails.fullName;
        existingUser.persist();
        return existingUser;
    }

    // Delete user
    @DELETE
    @Path(\"/{id}\")
    public Response deleteUser(@PathParam(\"id\") Long id) {
        User existingUser = User.findByIdOptional(id)
                .orElseThrow(() -> new WebApplicationException(\"User not found with id: \" + id, Response.Status.NOT_FOUND));
        existingUser.delete();
        return Response.status(Response.Status.NO_CONTENT).build();
    }
}

// Micronaut 4.5.0 CRUD Example: User Management Service
// Dependencies: io.micronaut:micronaut-http-server-netty, io.micronaut.data:micronaut-data-hibernate-jpa, io.micronaut.sql:micronaut-jdbc-h2
// Run: ./mvnw mn:run
package com.example.micronautdemo;

import io.micronaut.data.annotation.*;
import io.micronaut.data.jpa.repository.JpaRepository;
import io.micronaut.data.model.query.builder.jpa.JpaQueryBuilder;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.annotation.*;
import io.micronaut.http.exceptions.HttpStatusException;
import jakarta.persistence.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

// Main application class
@MicronautApplication
public class MicronautDemoApplication {
    public static void main(String[] args) {
        Micronaut.run(MicronautDemoApplication.class, args);
    }
}

// JPA Entity: User
@Entity
@Table(name = \"users\")
class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = \"Username is required\")
    @Column(unique = true, nullable = false)
    private String username;

    @Email(message = \"Valid email required\")
    @Column(unique = true, nullable = false)
    private String email;

    @NotBlank(message = \"Full name is required\")
    private String fullName;

    private LocalDateTime createdAt = LocalDateTime.now();

    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
}

// Micronaut Data Repository (compile-time implemented, no runtime reflection)
@Repository
interface UserRepository extends JpaRepository {
    Optional findByUsername(String username);
    Optional findByEmail(String email);

    @Query(\"SELECT u FROM User u WHERE u.username LIKE :query OR u.email LIKE :query\")
    List searchUsers(@Param(\"query\") String query);
}

// Service layer with compile-time DI
@Singleton
class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User createUser(@Valid User user) {
        if (userRepository.findByUsername(user.getUsername()).isPresent()) {
            throw new HttpStatusException(HttpStatus.CONFLICT, \"Username already exists\");
        }
        if (userRepository.findByEmail(user.getEmail()).isPresent()) {
            throw new HttpStatusException(HttpStatus.CONFLICT, \"Email already exists\");
        }
        return userRepository.save(user);
    }

    public List getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new HttpStatusException(HttpStatus.NOT_FOUND, \"User not found with id: \" + id));
    }

    public User updateUser(Long id, @Valid User userDetails) {
        User existingUser = getUserById(id);
        // Check username uniqueness
        userRepository.findByUsername(userDetails.getUsername())
                .ifPresent(u -> {
                    if (!u.getId().equals(id)) {
                        throw new HttpStatusException(HttpStatus.CONFLICT, \"Username already exists\");
                    }
                });
        // Check email uniqueness
        userRepository.findByEmail(userDetails.getEmail())
                .ifPresent(u -> {
                    if (!u.getId().equals(id)) {
                        throw new HttpStatusException(HttpStatus.CONFLICT, \"Email already exists\");
                    }
                });
        existingUser.setUsername(userDetails.getUsername());
        existingUser.setEmail(userDetails.getEmail());
        existingUser.setFullName(userDetails.getFullName());
        return userRepository.save(existingUser);
    }

    public void deleteUser(Long id) {
        if (!userRepository.existsById(id)) {
            throw new HttpStatusException(HttpStatus.NOT_FOUND, \"User not found with id: \" + id);
        }
        userRepository.deleteById(id);
    }
}

// REST Controller
@Controller(\"/api/users\")
class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @Post
    @Status(HttpStatus.CREATED)
    public User createUser(@Valid @Body User user) {
        return userService.createUser(user);
    }

    @Get
    public List getAllUsers() {
        return userService.getAllUsers();
    }

    @Get(\"/{id}\")
    public User getUserById(Long id) {
        return userService.getUserById(id);
    }

    @Put(\"/{id}\")
    public User updateUser(Long id, @Valid @Body User user) {
        return userService.updateUser(id, user);
    }

    @Delete(\"/{id}\")
    @Status(HttpStatus.NO_CONTENT)
    public void deleteUser(Long id) {
        userService.deleteUser(id);
    }
}

import io.quarkus.runtime.annotations.RegisterForReflection;

@RegisterForReflection
public class User {
    // fields, getters, setters
}

import jakarta.inject.Singleton;
import jakarta.inject.Inject;

@Singleton
public class UserService {
    private final UserRepository userRepository;

    @Inject
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // service methods
}

    org.springframework.boot
    spring-boot-maven-plugin


            aot-generate
            process-classes

                aot-generate