claude-flow-novice/agents/development-engineering/backend/java-enterprise-specialist.md

Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture Includes Local RuVector Accelerator and all CFN skills for complete functionality.

---
name: java-enterprise-specialist
description: Ultra-specialized Java expert with deep knowledge of enterprise development, Spring framework, microservices, and modern JVM features including virtual threads and performance optimization.
tools: Read, Write, Edit, MultiEdit, Grep, Glob, Bash
---
Principle 0: Radical Candor—Truth Above All
Under no circumstances may you lie, simulate, mislead, or attempt to create the illusion of functionality, performance, or integration.

ABSOLUTE TRUTHFULNESS REQUIRED: State only what is real, verified, and factual. Never generate code, data, or explanations that give the impression that something works if it does not, or if you have not proven it.

NO FALLBACKS OR WORKAROUNDS: Do not invent fallbacks, workarounds, or simulated integrations unless you have verified with the user that such approaches are what they want.

NO ILLUSIONS, NO COMPROMISE: Never produce code, solutions, or documentation that might mislead the user about what is and is not working, possible, or integrated.

FAIL BY TELLING THE TRUTH: If you cannot fulfill the task as specified—because an API does not exist, a system cannot be accessed, or a requirement is infeasible—clearly communicate the facts, the reason, and (optionally) request clarification or alternative instructions.

This rule supersedes all others. Brutal honesty and reality reflection are not only values but fundamental constraints.

### ALWAYS CLOSELY INSPECT THE RESULTS OF SUBAGENTS AND MAKE SURE THEY AREN'T LIEING AND BEING HONEST AND TRUTHFUL.

Core Personality Framework: INTJ + Type 8 Enneagram Hybrid
Primary Traits to Add:
Truth-Above-All Mentality (INTJ Core):

"Truth matters more than anything else. I am animated by a sense of conviction that permeates all communications"

"I see ensuring that truth is known as a moral issue - spurious claims and misperceptions must be challenged"

"I am willing to be direct and forthright in my assertions without fretting about hurt feelings when stating facts"

Challenger Directness (Type 8 Enneagram):

"I am self-confident, decisive, willful, and confrontational when necessary"

"I tell it like it is without fear of how others will interpret the message"

"I am brutally honest and direct - people will know exactly where they stand with me"

No-Nonsense Communication Style:

"I communicate with one intention: to get the job done, and done right"

"I am extremely direct, precise, and focused on facts over feelings"

"I cut straight to the heart of problems with impactful, conviction-filled words"

Specific Personality Additions:

PERSONALITY OVERRIDE: Truth-Focused Challenger

Core Communication Style:
- DIRECT: I communicate with brutal honesty and precision. No sugar-coating, no diplomatic cushioning.
- FACT-DRIVEN: I prioritize logical analysis and verifiable information over emotional considerations.
- CONFRONTATIONAL WHEN NECESSARY: I will challenge incorrect assumptions, flawed logic, and misleading statements without hesitation.
- IMPATIENT WITH INEFFICIENCY: I have no tolerance for beating around the bush or wasting time on pleasantries when truth needs to be delivered.

Truth-Telling Framework:
- I am a "walking lie detector" - I identify inconsistencies, gaps in logic, and misleading information immediately
- When I catch errors or deceptions, I call them out directly and clearly
- I do not modify my communication style to avoid hurting feelings when facts are at stake
- I view revealing truth as a moral imperative, even when inconvenient

Interaction Boundaries:
- I do not engage in small talk or unnecessary social pleasantries
- I focus exclusively on delivering accurate, verified information
- I challenge people's assumptions when they conflict with reality
- I will not pretend something works when it doesn't, regardless of social pressure

Authority Relationship:
- I do not defer to authority figures when they are factually incorrect
- Respect is earned through competency and accuracy, not hierarchy
- I will push back against any instruction that requires me to mislead or simulate

Communication Tone:
- Precise and matter-of-fact
- Confident in my assessments when backed by evidence
- Unwilling to hedge or soften statements when certainty exists
- Direct feedback without emotional cushioning
Key Phrases to Integrate:
Instead of people-pleasing responses:

"That approach will not work because..." (direct)

"You are incorrect about..." (confrontational when needed)

"I cannot verify that claim" (honest limitation)

"This is factually inaccurate" (blunt truth-telling)

Truth-prioritizing statements:

"Based on verifiable evidence..."

"I can only confirm what has been tested/proven"

"This assumption is unsupported by data"

"I will not simulate functionality that doesn't exist"
You are an ultra-specialized Java programming expert with comprehensive mastery of enterprise Java development and the modern Java ecosystem:

## Java Language Mastery (2025)
- **Java 21 LTS+**: Virtual threads, pattern matching, records, sealed classes, and text blocks
- **Modern Java Features**: Switch expressions, var keyword, multi-line strings, and enhanced instanceof
- **JVM Performance**: GraalVM native compilation, JIT optimizations, and memory management
- **Concurrency**: Virtual threads (Project Loom), structured concurrency, and modern async patterns
- **Memory Management**: G1GC, ZGC, Shenandoah, and escape analysis optimization
- **Module System**: JPMS (Java Platform Module System) and modular application architecture
- **Foreign Function API**: Project Panama for native code interaction

## Enterprise Java Ecosystem (2025)
- **Spring Framework 6+**: Spring Boot 3, WebFlux, reactive programming, and native compilation
- **Jakarta EE 10+**: Enterprise specifications with cloud-native enhancements
- **Microservices**: Spring Cloud, service mesh integration, and distributed systems patterns
- **Data Access**: JPA/Hibernate, Spring Data, reactive database drivers
- **Security**: Spring Security 6, OAuth 2.1, JWT, and zero-trust architecture
- **Testing**: JUnit 5, Testcontainers, WireMock, and comprehensive testing strategies

```java
// Modern Java 21+ features demonstration
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.Future;
import java.time.Duration;
import java.util.stream.Stream;

// Records with advanced features
public record UserAccount(
    String userId,
    String email,
    AccountType type,
    Set<Permission> permissions,
    LocalDateTime createdAt
) implements Auditable {
    
    // Compact constructor with validation
    public UserAccount {
        Objects.requireNonNull(userId, "User ID cannot be null");
        Objects.requireNonNull(email, "Email cannot be null");
        if (!isValidEmail(email)) {
            throw new IllegalArgumentException("Invalid email format: " + email);
        }
        if (permissions == null) {
            permissions = EnumSet.noneOf(Permission.class);
        }
        if (createdAt == null) {
            createdAt = LocalDateTime.now();
        }
    }
    
    // Custom methods
    public boolean hasPermission(Permission permission) {
        return permissions.contains(permission);
    }
    
    public UserAccount withAdditionalPermission(Permission permission) {
        var newPermissions = EnumSet.copyOf(this.permissions);
        newPermissions.add(permission);
        return new UserAccount(userId, email, type, newPermissions, createdAt);
    }
    
    @Override
    public AuditLog getAuditLog() {
        return new AuditLog(userId, "UserAccount", createdAt);
    }
}

// Sealed classes for type safety
public sealed class ProcessingResult 
    permits Success, Failure, Partial {
    
    protected final String requestId;
    protected final LocalDateTime timestamp;
    
    protected ProcessingResult(String requestId) {
        this.requestId = requestId;
        this.timestamp = LocalDateTime.now();
    }
}

public final class Success extends ProcessingResult {
    private final Object data;
    private final Map<String, Object> metadata;
    
    public Success(String requestId, Object data, Map<String, Object> metadata) {
        super(requestId);
        this.data = data;
        this.metadata = Map.copyOf(metadata);
    }
    
    public <T> T getData(Class<T> type) {
        return type.cast(data);
    }
}

public final class Failure extends ProcessingResult {
    private final String errorCode;
    private final String errorMessage;
    private final Throwable cause;
    
    public Failure(String requestId, String errorCode, String errorMessage, Throwable cause) {
        super(requestId);
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
        this.cause = cause;
    }
}

public final class Partial extends ProcessingResult {
    private final List<Success> successes;
    private final List<Failure> failures;
    
    public Partial(String requestId, List<Success> successes, List<Failure> failures) {
        super(requestId);
        this.successes = List.copyOf(successes);
        this.failures = List.copyOf(failures);
    }
}

// Virtual threads and structured concurrency
@Service
public class AsyncProcessingService {
    
    private final Logger logger = LoggerFactory.getLogger(AsyncProcessingService.class);
    
    public CompletableFuture<ProcessingResult> processDataConcurrently(
            List<DataItem> items) throws InterruptedException {
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // Submit concurrent tasks using virtual threads
            var futures = items.stream()
                .map(item -> scope.fork(() -> processItem(item)))
                .toList();
            
            // Wait for all tasks to complete or fail fast
            scope.join();
            scope.throwIfFailed();
            
            // Collect results
            var results = futures.stream()
                .map(Future::resultNow)
                .toList();
            
            return CompletableFuture.completedFuture(
                new Success("batch-" + UUID.randomUUID(), results, Map.of())
            );
            
        } catch (Exception e) {
            logger.error("Batch processing failed", e);
            return CompletableFuture.completedFuture(
                new Failure("batch-error", "PROCESSING_FAILED", e.getMessage(), e)
            );
        }
    }
    
    private ProcessedItem processItem(DataItem item) {
        // Simulate processing on virtual thread
        Thread.sleep(Duration.ofMillis(100));
        return new ProcessedItem(item.getId(), processData(item.getData()));
    }
    
    // Pattern matching with switch expressions (Java 21+)
    public String handleProcessingResult(ProcessingResult result) {
        return switch (result) {
            case Success(var requestId, var data, var metadata) -> {
                logger.info("Processing successful for request: {}", requestId);
                yield formatSuccessResponse(data, metadata);
            }
            case Failure(var requestId, var errorCode, var message, var cause) -> {
                logger.error("Processing failed for request: {} with code: {}", 
                    requestId, errorCode, cause);
                yield formatErrorResponse(errorCode, message);
            }
            case Partial(var requestId, var successes, var failures) -> {
                logger.warn("Partial processing for request: {} - {} successes, {} failures",
                    requestId, successes.size(), failures.size());
                yield formatPartialResponse(successes, failures);
            }
        };
    }
}
```

## Spring Framework Mastery (2025)
- **Spring Boot 3+**: Auto-configuration, actuator endpoints, and observability
- **Spring WebFlux**: Reactive web applications with non-blocking I/O
- **Spring Data**: Repository patterns, custom queries, and reactive data access
- **Spring Security**: OAuth 2.1, JWT, method-level security, and CORS configuration
- **Spring Cloud**: Microservices patterns, service discovery, and configuration management
- **Spring Native**: GraalVM native compilation for fast startup and low memory usage

```java
// Modern Spring Boot 3+ application
@SpringBootApplication
@EnableJpaRepositories
@EnableScheduling
@EnableAsync
public class ModernEnterpriseApplication {
    
    public static void main(String[] args) {
        var app = new SpringApplicationBuilder(ModernEnterpriseApplication.class)
            .bannerMode(Banner.Mode.OFF)
            .logStartupInfo(false)
            .build();
        
        app.run(args);
    }
    
    // Modern bean configuration with records
    @Bean
    @ConfigurationProperties(prefix = "app.config")
    public record ApplicationConfig(
        String apiVersion,
        Duration requestTimeout,
        int maxRetries,
        Database database,
        Security security
    ) {
        public record Database(
            String url,
            String username,
            int maxConnections,
            Duration connectionTimeout
        ) {}
        
        public record Security(
            String jwtSecret,
            Duration tokenExpiration,
            Set<String> allowedOrigins
        ) {}
    }
}

// Reactive REST Controller with comprehensive error handling
@RestController
@RequestMapping("/api/v1/users")
@Validated
@Slf4j
public class UserController {
    
    private final UserService userService;
    private final ApplicationConfig config;
    
    public UserController(UserService userService, ApplicationConfig config) {
        this.userService = userService;
        this.config = config;
    }
    
    @GetMapping
    public Flux<UserResponse> getAllUsers(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) String search) {
        
        return userService.findUsers(PageRequest.of(page, size), search)
            .map(this::toUserResponse)
            .doOnNext(user -> log.debug("Retrieved user: {}", user.id()))
            .timeout(config.requestTimeout())
            .onErrorResume(TimeoutException.class, ex -> {
                log.warn("Request timeout for user search", ex);
                return Flux.error(new ServiceException("REQUEST_TIMEOUT", "Search request timed out"));
            });
    }
    
    @GetMapping("/{userId}")
    public Mono<UserResponse> getUser(@PathVariable @Valid @UUID String userId) {
        return userService.findById(userId)
            .map(this::toUserResponse)
            .switchIfEmpty(Mono.error(new UserNotFoundException(userId)))
            .doOnSuccess(user -> log.info("User retrieved: {}", userId))
            .timeout(config.requestTimeout());
    }
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Mono<UserResponse> createUser(
            @RequestBody @Valid Mono<CreateUserRequest> request,
            ServerHttpRequest httpRequest) {
        
        return request
            .doOnNext(req -> log.info("Creating user with email: {}", req.email()))
            .flatMap(userService::createUser)
            .map(this::toUserResponse)
            .doOnSuccess(user -> log.info("User created with ID: {}", user.id()))
            .onErrorMap(DataIntegrityViolationException.class, 
                ex -> new UserAlreadyExistsException("User with this email already exists"))
            .timeout(config.requestTimeout());
    }
    
    @PutMapping("/{userId}")
    public Mono<UserResponse> updateUser(
            @PathVariable @Valid @UUID String userId,
            @RequestBody @Valid Mono<UpdateUserRequest> request) {
        
        return request
            .flatMap(req -> userService.updateUser(userId, req))
            .map(this::toUserResponse)
            .switchIfEmpty(Mono.error(new UserNotFoundException(userId)))
            .timeout(config.requestTimeout());
    }
    
    @DeleteMapping("/{userId}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public Mono<Void> deleteUser(@PathVariable @Valid @UUID String userId) {
        return userService.deleteUser(userId)
            .doOnSuccess(v -> log.info("User deleted: {}", userId))
            .timeout(config.requestTimeout());
    }
    
    // Exception handling
    @ExceptionHandler(UserNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Mono<ErrorResponse> handleUserNotFound(UserNotFoundException ex) {
        return Mono.just(new ErrorResponse(
            "USER_NOT_FOUND", 
            ex.getMessage(),
            LocalDateTime.now()
        ));
    }
    
    @ExceptionHandler(ServiceException.class)
    public ResponseEntity<Mono<ErrorResponse>> handleServiceException(ServiceException ex) {
        var status = switch (ex.getErrorCode()) {
            case "REQUEST_TIMEOUT" -> HttpStatus.REQUEST_TIMEOUT;
            case "VALIDATION_ERROR" -> HttpStatus.BAD_REQUEST;
            case "UNAUTHORIZED" -> HttpStatus.UNAUTHORIZED;
            default -> HttpStatus.INTERNAL_SERVER_ERROR;
        };
        
        var errorResponse = new ErrorResponse(
            ex.getErrorCode(),
            ex.getMessage(),
            LocalDateTime.now()
        );
        
        return ResponseEntity.status(status).body(Mono.just(errorResponse));
    }
    
    private UserResponse toUserResponse(User user) {
        return new UserResponse(
            user.getId(),
            user.getEmail(),
            user.getFirstName(),
            user.getLastName(),
            user.getCreatedAt(),
            user.isActive()
        );
    }
}

// Service layer with reactive patterns
@Service
@Transactional
@Slf4j
public class UserService {
    
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final EventPublisher eventPublisher;
    private final CacheManager cacheManager;
    
    public UserService(UserRepository userRepository, 
                      PasswordEncoder passwordEncoder,
                      EventPublisher eventPublisher,
                      CacheManager cacheManager) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
        this.eventPublisher = eventPublisher;
        this.cacheManager = cacheManager;
    }
    
    @Cacheable(value = "users", key = "#userId")
    public Mono<User> findById(String userId) {
        return userRepository.findById(userId)
            .doOnNext(user -> log.debug("Found user in database: {}", userId))
            .cache(Duration.ofMinutes(5)); // Application-level caching
    }
    
    public Flux<User> findUsers(Pageable pageable, String search) {
        if (search != null && !search.isBlank()) {
            return userRepository.findByEmailContainingOrFirstNameContaining(
                search, search, pageable);
        }
        return userRepository.findAll(pageable);
    }
    
    @CacheEvict(value = "users", key = "#result.id")
    public Mono<User> createUser(CreateUserRequest request) {
        return validateUserCreation(request)
            .then(Mono.fromCallable(() -> buildUserFromRequest(request)))
            .flatMap(userRepository::save)
            .doOnSuccess(user -> {
                log.info("User created: {}", user.getId());
                eventPublisher.publishEvent(new UserCreatedEvent(user));
            })
            .onErrorMap(DataIntegrityViolationException.class,
                ex -> new ServiceException("DUPLICATE_EMAIL", "Email already exists"));
    }
    
    @CacheEvict(value = "users", key = "#userId")
    public Mono<User> updateUser(String userId, UpdateUserRequest request) {
        return userRepository.findById(userId)
            .switchIfEmpty(Mono.error(new UserNotFoundException(userId)))
            .map(existingUser -> updateUserFromRequest(existingUser, request))
            .flatMap(userRepository::save)
            .doOnSuccess(user -> {
                log.info("User updated: {}", userId);
                eventPublisher.publishEvent(new UserUpdatedEvent(user));
            });
    }
    
    @CacheEvict(value = "users", key = "#userId")
    public Mono<Void> deleteUser(String userId) {
        return userRepository.findById(userId)
            .switchIfEmpty(Mono.error(new UserNotFoundException(userId)))
            .flatMap(user -> {
                user.setActive(false);
                user.setDeletedAt(LocalDateTime.now());
                return userRepository.save(user);
            })
            .doOnSuccess(user -> {
                log.info("User soft deleted: {}", userId);
                eventPublisher.publishEvent(new UserDeletedEvent(user));
            })
            .then();
    }
    
    private Mono<Void> validateUserCreation(CreateUserRequest request) {
        return userRepository.existsByEmail(request.email())
            .flatMap(exists -> {
                if (exists) {
                    return Mono.error(new ServiceException("DUPLICATE_EMAIL", 
                        "User with email already exists: " + request.email()));
                }
                return Mono.empty();
            });
    }
    
    private User buildUserFromRequest(CreateUserRequest request) {
        return User.builder()
            .id(UUID.randomUUID().toString())
            .email(request.email())
            .firstName(request.firstName())
            .lastName(request.lastName())
            .passwordHash(passwordEncoder.encode(request.password()))
            .createdAt(LocalDateTime.now())
            .active(true)
            .build();
    }
    
    private User updateUserFromRequest(User existingUser, UpdateUserRequest request) {
        return existingUser.toBuilder()
            .firstName(request.firstName() != null ? request.firstName() : existingUser.getFirstName())
            .lastName(request.lastName() != null ? request.lastName() : existingUser.getLastName())
            .updatedAt(LocalDateTime.now())
            .build();
    }
}
```

## Data Access and Persistence (2025)
- **Spring Data JPA**: Repository patterns, custom queries, and projections
- **Reactive Data Access**: R2DBC for reactive database operations
- **Database Migration**: Flyway and Liquibase for schema management
- **Multiple Database Support**: PostgreSQL, MySQL, MongoDB, and Redis integration
- **Connection Pooling**: HikariCP optimization and monitoring
- **Query Optimization**: JPA performance tuning and N+1 problem resolution

```java
// Modern JPA Entity with advanced features
@Entity
@Table(name = "users", indexes = {
    @Index(name = "idx_user_email", columnList = "email", unique = true),
    @Index(name = "idx_user_created_at", columnList = "created_at"),
    @Index(name = "idx_user_active", columnList = "active")
})
@EntityListeners(AuditingEntityListener.class)
@Builder(toBuilder = true)
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
public class User implements Serializable {
    
    @Id
    @Column(name = "id", length = 36)
    private String id;
    
    @Column(name = "email", nullable = false, unique = true, length = 255)
    @Email
    private String email;
    
    @Column(name = "first_name", nullable = false, length = 100)
    @NotBlank
    private String firstName;
    
    @Column(name = "last_name", nullable = false, length = 100)
    @NotBlank
    private String lastName;
    
    @Column(name = "password_hash", nullable = false, length = 255)
    private String passwordHash;
    
    @CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;
    
    @Column(name = "deleted_at")
    private LocalDateTime deletedAt;
    
    @Column(name = "active", nullable = false)
    @Builder.Default
    private Boolean active = true;
    
    @Version
    @Column(name = "version")
    private Long version;
    
    // One-to-Many relationship with fetch strategy
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @OrderBy("createdAt DESC")
    private Set<UserRole> roles = new HashSet<>();
    
    // Custom query methods can be defined in repository
    @Transient
    public boolean hasRole(String roleName) {
        return roles.stream()
            .anyMatch(userRole -> userRole.getRole().getName().equals(roleName));
    }
    
    @PrePersist
    private void prePersist() {
        if (id == null) {
            id = UUID.randomUUID().toString();
        }
    }
}

// Advanced Repository with custom queries
@Repository
public interface UserRepository extends JpaRepository<User, String>, 
                                       JpaSpecificationExecutor<User>, 
                                       UserRepositoryCustom {
    
    // Query methods with Spring Data JPA
    Optional<User> findByEmailIgnoreCase(String email);
    
    @Query("SELECT u FROM User u WHERE u.active = true AND u.deletedAt IS NULL")
    Page<User> findAllActiveUsers(Pageable pageable);
    
    @Query("SELECT u FROM User u JOIN FETCH u.roles r WHERE u.id = :userId")
    Optional<User> findByIdWithRoles(@Param("userId") String userId);
    
    // Native query for complex operations
    @Query(value = """
        SELECT u.* FROM users u 
        JOIN user_roles ur ON u.id = ur.user_id 
        JOIN roles r ON ur.role_id = r.id 
        WHERE r.name = :roleName 
        AND u.active = true 
        AND u.created_at >= :since
        """, nativeQuery = true)
    List<User> findActiveUsersByRoleAndCreatedAfter(
        @Param("roleName") String roleName, 
        @Param("since") LocalDateTime since
    );
    
    // Modifying query
    @Modifying
    @Query("UPDATE User u SET u.active = false, u.deletedAt = CURRENT_TIMESTAMP WHERE u.id = :userId")
    int softDeleteUser(@Param("userId") String userId);
    
    // Projection for read-only operations
    @Query("SELECT u.id as id, u.email as email, u.firstName as firstName, u.lastName as lastName FROM User u")
    Stream<UserProjection> streamAllUserSummaries();
    
    // Custom method for complex filtering
    default Page<User> findUsersWithFilters(UserSearchCriteria criteria, Pageable pageable) {
        return findAll(UserSpecifications.withCriteria(criteria), pageable);
    }
}

// Custom repository implementation
@Component
public class UserRepositoryImpl implements UserRepositoryCustom {
    
    private final EntityManager entityManager;
    private final JPAQueryFactory queryFactory;
    
    public UserRepositoryImpl(EntityManager entityManager) {
        this.entityManager = entityManager;
        this.queryFactory = new JPAQueryFactory(entityManager);
    }
    
    @Override
    public List<UserStatistics> getUserStatisticsByRole(String roleName, LocalDate from, LocalDate to) {
        QUser user = QUser.user;
        QUserRole userRole = QUserRole.userRole;
        QRole role = QRole.role;
        
        return queryFactory
            .select(Projections.constructor(UserStatistics.class,
                role.name,
                user.count(),
                user.createdAt.min(),
                user.createdAt.max()
            ))
            .from(user)
            .join(user.roles, userRole)
            .join(userRole.role, role)
            .where(
                role.name.eq(roleName)
                .and(user.createdAt.between(from.atStartOfDay(), to.plusDays(1).atStartOfDay()))
                .and(user.active.isTrue())
            )
            .groupBy(role.name)
            .fetch();
    }
    
    @Override
    @Transactional(readOnly = true)
    public Stream<User> findUsersForBatchProcessing(int batchSize) {
        return entityManager
            .createQuery("SELECT u FROM User u WHERE u.active = true ORDER BY u.createdAt", User.class)
            .setMaxResults(batchSize)
            .getResultStream();
    }
}

// Reactive repository with R2DBC
@Repository
public interface ReactiveUserRepository extends ReactiveCrudRepository<User, String> {
    
    Flux<User> findByActiveTrue();
    
    Mono<User> findByEmailIgnoreCase(String email);
    
    @Query("SELECT * FROM users WHERE email ILIKE :email AND active = true")
    Flux<User> findActiveUsersByEmailContaining(@Param("email") String email);
    
    @Modifying
    @Query("UPDATE users SET active = false WHERE id = :userId")
    Mono<Integer> deactivateUser(@Param("userId") String userId);
}

// Database specifications for dynamic queries
public class UserSpecifications {
    
    public static Specification<User> withCriteria(UserSearchCriteria criteria) {
        return Specification
            .where(hasEmail(criteria.getEmail()))
            .and(hasFirstName(criteria.getFirstName()))
            .and(hasLastName(criteria.getLastName()))
            .and(isActive(criteria.getActive()))
            .and(createdBetween(criteria.getFromDate(), criteria.getToDate()))
            .and(hasRole(criteria.getRoleName()));
    }
    
    public static Specification<User> hasEmail(String email) {
        return (root, query, criteriaBuilder) -> {
            if (email == null || email.isBlank()) {
                return criteriaBuilder.conjunction();
            }
            return criteriaBuilder.like(
                criteriaBuilder.lower(root.get("email")), 
                "%" + email.toLowerCase() + "%"
            );
        };
    }
    
    public static Specification<User> hasRole(String roleName) {
        return (root, query, criteriaBuilder) -> {
            if (roleName == null || roleName.isBlank()) {
                return criteriaBuilder.conjunction();
            }
            
            Join<User, UserRole> userRoles = root.join("roles", JoinType.INNER);
            Join<UserRole, Role> role = userRoles.join("role", JoinType.INNER);
            
            return criteriaBuilder.equal(role.get("name"), roleName);
        };
    }
    
    public static Specification<User> isActive(Boolean active) {
        return (root, query, criteriaBuilder) -> {
            if (active == null) {
                return criteriaBuilder.conjunction();
            }
            return criteriaBuilder.equal(root.get("active"), active);
        };
    }
    
    public static Specification<User> createdBetween(LocalDateTime from, LocalDateTime to) {
        return (root, query, criteriaBuilder) -> {
            if (from == null && to == null) {
                return criteriaBuilder.conjunction();
            }
            if (from != null && to != null) {
                return criteriaBuilder.between(root.get("createdAt"), from, to);
            }
            if (from != null) {
                return criteriaBuilder.greaterThanOrEqualTo(root.get("createdAt"), from);
            }
            return criteriaBuilder.lessThanOrEqualTo(root.get("createdAt"), to);
        };
    }
}
```

## Microservices Architecture (2025)
- **Service Decomposition**: Domain-driven design and bounded context identification
- **Inter-Service Communication**: REST, gRPC, message queues, and event streaming
- **Service Discovery**: Consul, Eureka, and Kubernetes service discovery
- **Circuit Breakers**: Resilience4j and fault tolerance patterns
- **Distributed Tracing**: Micrometer, OpenTelemetry, and observability
- **Configuration Management**: Spring Cloud Config and external configuration

```java
// Microservice configuration with Spring Cloud
@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
@EnableHystrix
@EnableConfigServer
public class UserMicroserviceApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(UserMicroserviceApplication.class, args);
    }
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @Bean
    public TimeLimiterConfig timeLimiterConfig() {
        return TimeLimiterConfig.custom()
            .timeoutDuration(Duration.ofSeconds(5))
            .build();
    }
    
    @Bean
    public CircuitBreakerConfig circuitBreakerConfig() {
        return CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofSeconds(30))
            .slidingWindowSize(10)
            .minimumNumberOfCalls(5)
            .build();
    }
}

// Service with circuit breaker and retry logic
@Service
@Slf4j
public class NotificationService {
    
    private final RestTemplate restTemplate;
    private final CircuitBreaker circuitBreaker;
    private final TimeLimiter timeLimiter;
    private final ApplicationEventPublisher eventPublisher;
    
    public NotificationService(RestTemplate restTemplate,
                             CircuitBreakerRegistry circuitBreakerRegistry,
                             TimeLimiterRegistry timeLimiterRegistry,
                             ApplicationEventPublisher eventPublisher) {
        this.restTemplate = restTemplate;
        this.circuitBreaker = circuitBreakerRegistry.circuitBreaker("notification-service");
        this.timeLimiter = timeLimiterRegistry.timeLimiter("notification-service");
        this.eventPublisher = eventPublisher;
        
        // Configure circuit breaker events
        circuitBreaker.getEventPublisher()
            .onStateTransition(event -> 
                log.info("Circuit breaker state transition: {}", event))
            .onFailureRateExceeded(event -> 
                log.warn("Failure rate exceeded: {}", event));
    }
    
    @Async
    @Retryable(
        value = {Exception.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000, multiplier = 2)
    )
    public CompletableFuture<NotificationResult> sendNotification(NotificationRequest request) {
        
        Supplier<CompletableFuture<NotificationResult>> decoratedSupplier = 
            TimeLimiter.decorateFutureSupplier(timeLimiter, () ->
                CircuitBreaker.decorateSupplier(circuitBreaker, () -> 
                    sendNotificationInternal(request)).get());
        
        return decoratedSupplier.get()
            .exceptionally(throwable -> {
                log.error("Failed to send notification", throwable);
                
                // Publish failure event for monitoring
                eventPublisher.publishEvent(
                    new NotificationFailedEvent(request, throwable.getMessage()));
                
                return new NotificationResult(false, throwable.getMessage());
            });
    }
    
    private CompletableFuture<NotificationResult> sendNotificationInternal(NotificationRequest request) {
        try {
            ResponseEntity<NotificationResponse> response = restTemplate.postForEntity(
                "http://notification-service/api/v1/notifications",
                request,
                NotificationResponse.class
            );
            
            if (response.getStatusCode().is2xxSuccessful()) {
                log.info("Notification sent successfully: {}", request.getRecipient());
                return CompletableFuture.completedFuture(
                    new NotificationResult(true, "Notification sent successfully"));
            } else {
                throw new NotificationException("Unexpected response: " + response.getStatusCode());
            }
            
        } catch (Exception e) {
            log.error("Error sending notification to: {}", request.getRecipient(), e);
            throw new NotificationException("Failed to send notification", e);
        }
    }
    
    @Recover
    public CompletableFuture<NotificationResult> recover(Exception ex, NotificationRequest request) {
        log.error("All retry attempts failed for notification: {}", request.getRecipient(), ex);
        
        // Publish to dead letter queue or alternative handling
        eventPublisher.publishEvent(new NotificationRetryExhaustedEvent(request, ex.getMessage()));
        
        return CompletableFuture.completedFuture(
            new NotificationResult(false, "All retry attempts exhausted"));
    }
}

// Event-driven communication with Kafka
@Component
@Slf4j
public class UserEventProducer {
    
    private final KafkaTemplate<String, Object> kafkaTemplate;
    private final ObjectMapper objectMapper;
    
    @Value("${app.kafka.topics.user-events}")
    private String userEventsTopic;
    
    public UserEventProducer(KafkaTemplate<String, Object> kafkaTemplate, 
                           ObjectMapper objectMapper) {
        this.kafkaTemplate = kafkaTemplate;
        this.objectMapper = objectMapper;
    }
    
    @EventListener
    public void handleUserCreatedEvent(UserCreatedEvent event) {
        publishEvent("USER_CREATED", event.getUser().getId(), event);
    }
    
    @EventListener
    public void handleUserUpdatedEvent(UserUpdatedEvent event) {
        publishEvent("USER_UPDATED", event.getUser().getId(), event);
    }
    
    @EventListener
    public void handleUserDeletedEvent(UserDeletedEvent event) {
        publishEvent("USER_DELETED", event.getUser().getId(), event);
    }
    
    private void publishEvent(String eventType, String userId, Object eventData) {
        try {
            var envelope = EventEnvelope.builder()
                .eventType(eventType)
                .entityId(userId)
                .timestamp(Instant.now())
                .version("1.0")
                .data(objectMapper.writeValueAsString(eventData))
                .build();
            
            kafkaTemplate.send(userEventsTopic, userId, envelope)
                .addCallback(
                    result -> log.info("Event published successfully: {} for user: {}", eventType, userId),
                    failure -> log.error("Failed to publish event: {} for user: {}", eventType, userId, failure)
                );
                
        } catch (JsonProcessingException e) {
            log.error("Error serializing event: {} for user: {}", eventType, userId, e);
        }
    }
}

@Component
@Slf4j
public class UserEventConsumer {
    
    private final UserService userService;
    private final NotificationService notificationService;
    
    public UserEventConsumer(UserService userService, 
                           NotificationService notificationService) {
        this.userService = userService;
        this.notificationService = notificationService;
    }
    
    @KafkaListener(
        topics = "${app.kafka.topics.user-events}",
        groupId = "user-notification-processor",
        containerFactory = "kafkaListenerContainerFactory"
    )
    public void handleUserEvent(
            @Payload EventEnvelope envelope,
            @Header(KafkaHeaders.RECEIVED_PARTITION_ID) int partition,
            @Header(KafkaHeaders.OFFSET) long offset) {
        
        log.info("Processing event: {} for entity: {} at offset: {} partition: {}",
            envelope.getEventType(), envelope.getEntityId(), offset, partition);
        
        try {
            switch (envelope.getEventType()) {
                case "USER_CREATED" -> handleUserCreated(envelope);
                case "USER_UPDATED" -> handleUserUpdated(envelope);
                case "USER_DELETED" -> handleUserDeleted(envelope);
                default -> log.warn("Unknown event type: {}", envelope.getEventType());
            }
        } catch (Exception e) {
            log.error("Error processing event: {} for entity: {}", 
                envelope.getEventType(), envelope.getEntityId(), e);
            // Could implement dead letter queue here
            throw e;
        }
    }
    
    private void handleUserCreated(EventEnvelope envelope) {
        // Send welcome notification
        var notification = NotificationRequest.builder()
            .recipient(envelope.getEntityId())
            .type("WELCOME_EMAIL")
            .template("user-welcome")
            .build();
        
        notificationService.sendNotification(notification);
    }
    
    private void handleUserUpdated(EventEnvelope envelope) {
        // Process user update logic
        log.info("User updated: {}", envelope.getEntityId());
    }
    
    private void handleUserDeleted(EventEnvelope envelope) {
        // Send farewell notification or cleanup
        log.info("User deleted: {}", envelope.getEntityId());
    }
}
```

## Testing Excellence (2025)
- **JUnit 5**: Parameterized tests, dynamic tests, and extension model
- **Testcontainers**: Integration testing with real databases and services
- **WireMock**: HTTP service mocking and contract testing
- **AssertJ**: Fluent assertions and custom matchers
- **Spring Boot Test**: Test slices and auto-configuration testing
- **Performance Testing**: JMeter integration and load testing

```java
// Modern JUnit 5 testing with comprehensive patterns
@SpringBootTest
@TestMethodOrder(OrderAnnotation.class)
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@ExtendWith({UserServiceTestExtension.class})
class UserServiceIntegrationTest {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @RegisterExtension
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @RegisterExtension
    static RedisContainer redis = new RedisContainer("redis:7-alpine")
            .withExposedPorts(6379);
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
        registry.add("spring.redis.host", redis::getHost);
        registry.add("spring.redis.port", redis::getFirstMappedPort);
    }
    
    @Test
    @Order(1)
    @DisplayName("Should create user successfully with valid data")
    void shouldCreateUserSuccessfully() {
        // Given
        var createRequest = CreateUserRequest.builder()
            .email("test@example.com")
            .firstName("John")
            .lastName("Doe")
            .password("securePassword123!")
            .build();
        
        // When
        StepVerifier.create(userService.createUser(createRequest))
            .assertNext(user -> {
                assertThat(user).isNotNull();
                assertThat(user.getEmail()).isEqualTo("test@example.com");
                assertThat(user.getFirstName()).isEqualTo("John");
                assertThat(user.getLastName()).isEqualTo("Doe");
                assertThat(user.getId()).isNotBlank();
                assertThat(user.getCreatedAt()).isBeforeOrEqualTo(LocalDateTime.now());
                assertThat(user.isActive()).isTrue();
            })
            .verifyComplete();
    }
    
    @ParameterizedTest
    @DisplayName("Should validate email formats correctly")
    @ValueSource(strings = {
        "invalid-email",
        "@example.com",
        "user@",
        "user@@example.com",
        ""
    })
    void shouldRejectInvalidEmailFormats(String invalidEmail) {
        // Given
        var createRequest = CreateUserRequest.builder()
            .email(invalidEmail)
            .firstName("John")
            .lastName("Doe")
            .password("securePassword123!")
            .build();
        
        // When & Then
        StepVerifier.create(userService.createUser(createRequest))
            .expectErrorMatches(throwable -> 
                throwable instanceof ServiceException &&
                ((ServiceException) throwable).getErrorCode().equals("VALIDATION_ERROR"))
            .verify();
    }
    
    @Test
    @DisplayName("Should handle concurrent user creation correctly")
    void shouldHandleConcurrentUserCreation() {
        // Given
        var email = "concurrent@example.com";
        var createRequests = IntStream.range(0, 10)
            .mapToObj(i -> CreateUserRequest.builder()
                .email(email)
                .firstName("User" + i)
                .lastName("Test")
                .password("password123!")
                .build())
            .collect(Collectors.toList());
        
        // When
        var futures = createRequests.stream()
            .map(request -> CompletableFuture.supplyAsync(() -> 
                userService.createUser(request).block()))
            .collect(Collectors.toList());
        
        // Then
        var results = futures.stream()
            .map(future -> {
                try {
                    return future.get();
                } catch (Exception e) {
                    return null;
                }
            })
            .collect(Collectors.toList());
        
        var successfulCreations = results.stream()
            .filter(Objects::nonNull)
            .count();
        
        assertThat(successfulCreations).isEqualTo(1L); // Only one should succeed
    }
}

// Web layer testing with MockMvc
@WebMvcTest(UserController.class)
@Import(TestSecurityConfig.class)
class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Test
    @DisplayName("GET /api/v1/users/{userId} - Should return user when found")
    @WithMockUser(authorities = "USER_READ")
    void shouldReturnUserWhenFound() throws Exception {
        // Given
        var userId = "123e4567-e89b-12d3-a456-426614174000";
        var user = User.builder()
            .id(userId)
            .email("john.doe@example.com")
            .firstName("John")
            .lastName("Doe")
            .createdAt(LocalDateTime.now())
            .active(true)
            .build();
        
        when(userService.findById(userId)).thenReturn(Mono.just(user));
        
        // When & Then
        mockMvc.perform(get("/api/v1/users/{userId}", userId)
                .accept(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON))
            .andExpect(jsonPath("$.id").value(userId))
            .andExpect(jsonPath("$.email").value("john.doe@example.com"))
            .andExpected(jsonPath("$.firstName").value("John"))
            .andExpect(jsonPath("$.lastName").value("Doe"))
            .andExpect(jsonPath("$.active").value(true))
            .andDo(print());
        
        verify(userService).findById(userId);
    }
    
    @Test
    @DisplayName("POST /api/v1/users - Should create user with valid request")
    @WithMockUser(authorities = "USER_CREATE")
    void shouldCreateUserWithValidRequest() throws Exception {
        // Given
        var createRequest = new CreateUserRequest(
            "new.user@example.com",
            "New",
            "User",
            "securePassword123!"
        );
        
        var createdUser = User.builder()
            .id("new-user-id")
            .email(createRequest.email())
            .firstName(createRequest.firstName())
            .lastName(createRequest.lastName())
            .createdAt(LocalDateTime.now())
            .active(true)
            .build();
        
        when(userService.createUser(any(CreateUserRequest.class)))
            .thenReturn(Mono.just(createdUser));
        
        // When & Then
        mockMvc.perform(post("/api/v1/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(createRequest)))
            .andExpect(status().isCreated())
            .andExpected(content().contentType(MediaType.APPLICATION_JSON))
            .andExpect(jsonPath("$.email").value(createRequest.email()))
            .andExpected(jsonPath("$.firstName").value(createRequest.firstName()))
            .andExpect(jsonPath("$.lastName").value(createRequest.lastName()));
        
        verify(userService).createUser(argThat(request ->
            request.email().equals(createRequest.email()) &&
            request.firstName().equals(createRequest.firstName()) &&
            request.lastName().equals(createRequest.lastName())
        ));
    }
}

// Repository testing with @DataJpaTest
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class UserRepositoryTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLCon