Coding Guidelines Java

Coding Guidelines (Java/Spring Boot)

Apply these standards to all Java and Spring Boot code. Focus on robustness, maintainability, and best practices.

Section 1: Java Fundamentals (Effective Java)

Class and Object Principles

• Immutability: Minimize mutability. Immutable classes are simpler and safer.
  • To create: Provide no setters, make the class final, make all fields final and private, and make defensive copies of mutable components.
• Composition > Inheritance: Prefer composition over inheritance. Inheritance violates encapsulation.
• Encapsulation: Minimize the accessibility of classes and members. Use private whenever possible. Never expose public fields; use getters.
• Interfaces: Prefer interfaces over abstract classes for defining types. Code to the interface, not the implementation (e.g., List<String> list = new ArrayList<>()).
• equals() and hashCode(): Always override hashCode when overriding equals.

Resource Management

• try-with-resources: Prefer try-with-resources over try-finally blocks to ensure proper resource closure (AutoCloseable).
• Avoid Finalizers: Do not use finalizers or cleaners.

Generics

• No Raw Types: Never use raw types (e.g., List). Use parameterized types (e.g., List<String>).
• Wildcards (PECS): Use bounded wildcards to increase API flexibility (PECS Rule: Producer-Extends, Consumer-Super).

Lambdas and Streams

• Method References: Prefer method references (e.g., User::getName) over lambdas (e.g., u -> u.getName) when possible.
• Pure Functions: Prefer pure functions (no side effects) in stream operations.
• Standard Functional Interfaces: Use standard java.util.function interfaces (like Predicate, Function).

Methods and General Programming

• Validation: Check parameter validity at the beginning of methods (e.g., IllegalArgumentException, NullPointerException).
• Defensive Copies: Make defensive copies of mutable components.
• Primitives > Boxed: Prefer primitive types (int) over boxed types (Integer) for performance and to avoid NullPointerException.
• Optional: Use Optional judiciously for return values that might be null. Do not use Optional for collections (return empty collections).

Concurrency

• Executor Framework: Prefer Executors and Tasks (java.util.concurrent) over managing Threads directly.
• Synchronization: Synchronize access (read and write) to shared mutable data. Keep synchronized blocks small.

Section 2: Spring and Spring Boot Patterns

Dependency Injection (DI) and Configuration

• Constructor Injection: Use constructor injection to declare dependencies. This allows fields to be final, ensuring immutability.
• @ConfigurationProperties: To inject configuration properties, prefer a POJO annotated with @ConfigurationProperties. It is type-safe and more robust than @Value.
• Starters: Use Spring Boot Starters for simplified dependency management.
• Java Configuration: Prefer @Configuration classes and @Bean methods over XML.
• Stereotypes: Use standard stereotypes (@Component, @Service, @Repository, @Controller).

Web, Data, and APIs

• @RestController: Use @RestController for REST services with specific mappings (e.g., @GetMapping).
• Spring Data: Use Spring Data Repository interfaces to abstract data access.
• WebClient: Prefer the WebClient (reactive) for service-to-service communication over the legacy RestTemplate.

Testing and Production

• @SpringBootTest: Use @SpringBootTest for high-level integration tests.
• Test Slices: Use Test Slices (e.g., @WebMvcTest, @DataJpaTest) to test specific layers.
• Testcontainers: Use Testcontainers for integration tests with real dependencies (e.g., databases) in Docker containers.
• Actuator: Always include the spring-boot-starter-actuator for monitoring, health (/health), and metrics.
• Security: Use Spring Security for authentication and authorization.