Java Core Knowledge

Modern Java Features (17+)

// Records (immutable data classes) public record User(Long id, String name, String email) {}

// Sealed classes public sealed interface Shape permits Circle, Rectangle {} public final class Circle implements Shape { } public final class Rectangle implements Shape { }

// Pattern matching for instanceof if (obj instanceof String s) { System.out.println(s.toUpperCase()); }

// Switch expressions String result = switch (status) { case ACTIVE -> "Active"; case INACTIVE -> "Inactive"; default -> "Unknown"; };

// Text blocks String json = """ { "name": "John", "age": 30 } """;

Collections & Streams

// Stream operations List<String> names = users.stream() .filter(u -> u.isActive()) .map(User::getName) .sorted() .collect(Collectors.toList());

// Grouping Map<Status, List<User>> byStatus = users.stream() .collect(Collectors.groupingBy(User::getStatus));

// Optional handling Optional<User> user = findById(id); String name = user.map(User::getName).orElse("Unknown");

Common Patterns

// Builder pattern User user = User.builder() .name("John") .email("john@example.com") .build();

// Factory method public static User of(String name, String email) { return new User(null, name, email); }

// Dependency Injection (constructor) @Service public class UserService { private final UserRepository repository;

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

}

Exception Handling

// Custom exception public class UserNotFoundException extends RuntimeException { public UserNotFoundException(Long id) { super("User not found: " + id); } }

// Try-with-resources try (var reader = new BufferedReader(new FileReader(file))) { return reader.lines().collect(Collectors.toList()); }

Static Analysis & Linting

Official Rules References

Tool Rules Count Documentation

SonarJava 733 https://rules.sonarsource.com/java/

Checkstyle 200+ https://checkstyle.org/checks.html

PMD 400+ https://pmd.github.io/latest/pmd_rules_java.html

SpotBugs 400+ https://spotbugs.readthedocs.io/en/latest/bugDescriptions.html

Style Guides

Guide Link

Google Java Style https://google.github.io/styleguide/javaguide.html

Oracle Code Conventions https://www.oracle.com/java/technologies/javase/codeconventions-contents.html

Key Rules Categories

<!-- pom.xml - Maven Checkstyle Plugin --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-checkstyle-plugin</artifactId> <version>3.3.1</version> <configuration> <configLocation>google_checks.xml</configLocation> </configuration> </plugin>

Critical Rules to Enable

Category Rule Tool

Bug NullPointerException risks SonarJava S2259

Bug Resource leaks SonarJava S2095

Security SQL Injection SonarJava S3649

Security Hardcoded credentials SonarJava S2068

Maintainability Cognitive complexity SonarJava S3776

Maintainability Too many parameters Checkstyle

Production Readiness

Error Handling

// Custom exception hierarchy public abstract class BaseException extends RuntimeException { private final String errorCode; private final int httpStatus;

protected BaseException(String message, String errorCode, int httpStatus) {
    super(message);
    this.errorCode = errorCode;
    this.httpStatus = httpStatus;
}

public String getErrorCode() { return errorCode; }
public int getHttpStatus() { return httpStatus; }

}

public class EntityNotFoundException extends BaseException { public EntityNotFoundException(String entity, Object id) { super( String.format("%s not found with id: %s", entity, id), "NOT_FOUND", 404 ); } }

// Global exception handler @RestControllerAdvice public class GlobalExceptionHandler { private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

@ExceptionHandler(BaseException.class)
public ResponseEntity<ErrorResponse> handleBaseException(BaseException ex) {
    log.warn("Business error: {}", ex.getMessage());
    return ResponseEntity
        .status(ex.getHttpStatus())
        .body(new ErrorResponse(ex.getErrorCode(), ex.getMessage()));
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleUnexpected(Exception ex) {
    log.error("Unexpected error", ex);
    return ResponseEntity
        .status(500)
        .body(new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred"));
}

}

Null Safety

// Use Optional properly public Optional<User> findById(Long id) { return repository.findById(id); }

// Never return null from Optional public User getById(Long id) { return findById(id) .orElseThrow(() -> new EntityNotFoundException("User", id)); }

// Use @Nullable and @NonNull annotations import org.springframework.lang.NonNull; import org.springframework.lang.Nullable;

public User updateUser(@NonNull Long id, @Nullable String email) { User user = getById(id); if (email != null) { user.setEmail(email); } return repository.save(user); }

// Validation import jakarta.validation.constraints.*;

public record CreateUserRequest( @NotBlank @Size(min = 2, max = 100) String name, @NotBlank @Email String email, @NotNull @Min(0) Integer age ) {}

Logging

import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.slf4j.MDC;

@Service public class UserService { private static final Logger log = LoggerFactory.getLogger(UserService.class);

public User createUser(CreateUserRequest request) {
    MDC.put("operation", "createUser");
    MDC.put("email", request.email());

    log.info("Creating user");

    try {
        User user = userRepository.save(User.from(request));
        log.info("User created successfully: {}", user.getId());
        return user;
    } catch (Exception e) {
        log.error("Failed to create user", e);
        throw e;
    } finally {
        MDC.clear();
    }
}

}

Testing

// Unit test with Mockito @ExtendWith(MockitoExtension.class) class UserServiceTest { @Mock private UserRepository repository;

@InjectMocks
private UserService service;

@Test
void shouldCreateUser() {
    // Given
    var request = new CreateUserRequest("John", "john@example.com", 30);
    var expected = new User(1L, "John", "john@example.com", 30);
    when(repository.save(any())).thenReturn(expected);

    // When
    var result = service.createUser(request);

    // Then
    assertThat(result).isEqualTo(expected);
    verify(repository).save(any());
}

@Test
void shouldThrowWhenUserNotFound() {
    // Given
    when(repository.findById(1L)).thenReturn(Optional.empty());

    // When/Then
    assertThatThrownBy(() -> service.getById(1L))
        .isInstanceOf(EntityNotFoundException.class)
        .hasMessageContaining("User not found");
}

}

// Integration test @SpringBootTest @AutoConfigureMockMvc @Testcontainers class UserControllerIT { @Container static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");

@Autowired
private MockMvc mockMvc;

@Test
void shouldCreateUser() throws Exception {
    mockMvc.perform(post("/api/users")
            .contentType(MediaType.APPLICATION_JSON)
            .content("""
                {"name": "John", "email": "john@example.com", "age": 30}
                """))
        .andExpect(status().isCreated())
        .andExpect(jsonPath("$.id").exists());
}

}

Performance

// Connection pooling (HikariCP) // application.yml spring: datasource: hikari: maximum-pool-size: 10 minimum-idle: 5 connection-timeout: 30000 idle-timeout: 600000

// Caching @Cacheable(value = "users", key = "#id") public User findById(Long id) { return repository.findById(id).orElseThrow(); }

@CacheEvict(value = "users", key = "#user.id") public User save(User user) { return repository.save(user); }

Monitoring Metrics

Metric Target

Test coverage

80%

Cyclomatic complexity < 10

SonarQube bugs 0

Security vulnerabilities 0

Checklist

• Custom exception hierarchy

• Global exception handler

• Bean validation on DTOs

• Optional for nullable returns

• @NonNull/@Nullable annotations

• Structured logging with MDC

• Unit tests with Mockito

• Integration tests with Testcontainers

• Connection pool configured

• Caching for hot data

When NOT to Use This Skill

Scenario Use Instead

Spring Boot framework backend-spring-boot skill

Lombok annotations lombok skill

MapStruct mapping mapstruct skill

JPA/Hibernate ORM-specific skills

Testing with JUnit testing-junit skill

Anti-Patterns

Anti-Pattern Why It's Bad Correct Approach

Returning null NullPointerException Use Optional

Catching generic Exception Hides specific errors Catch specific exceptions

Not closing resources Resource leaks Use try-with-resources

Mutable static fields Thread-safety issues Use immutable or synchronized

String concatenation in loops O(n²) performance Use StringBuilder

Empty catch blocks Silent failures Log or rethrow

Using == for strings Compares references Use .equals()

Not overriding equals/hashCode Broken collections Override both or neither

Quick Troubleshooting

Issue Cause Solution

NullPointerException Accessing null reference Check for null, use Optional

ClassCastException Wrong type cast Use instanceof before casting

ConcurrentModificationException Modifying while iterating Use Iterator.remove()

OutOfMemoryError Heap exhausted Increase heap, fix memory leaks

StackOverflowError Infinite recursion Add base case, use iteration

"Cannot find symbol" Compilation error Check imports, spelling

Deadlock Circular lock dependency Use consistent lock ordering

Resource leak Not closing streams Use try-with-resources

Reference Documentation

• Spring Boot

• Lombok

• Quality Principles