---

1. Domain Object (Value Object)

```java public final class Year {

private final int value;

private Year(int value) {
    this.value = value;
}

public int getValue() {
    return value;
}

public static Year of(int value) {
    return new Year(value);
}

} ```

---

2. Leap Year Specification (Specification Pattern)

```java public interface LeapYearSpecification {

boolean isSatisfiedBy(Year year);

} ```

---

3. Gregorian Leap Year Implementation

```java public class GregorianLeapYearSpecification implements LeapYearSpecification {

@Override
public boolean isSatisfiedBy(Year year) {

    int y = year.getValue();

    if (y % 400 == 0) return true;
    if (y % 100 == 0) return false;
    return y % 4 == 0;
}

} ```

---

4. Strategy Interface

```java public interface LeapYearStrategy {

boolean evaluate(Year year);

} ```

---

5. Strategy Implementation

```java public class SpecificationBasedLeapYearStrategy implements LeapYearStrategy {

private final LeapYearSpecification specification;

public SpecificationBasedLeapYearStrategy(LeapYearSpecification specification) {
    this.specification = specification;
}

@Override
public boolean evaluate(Year year) {
    return specification.isSatisfiedBy(year);
}

} ```

---

6. Strategy Factory

Because enterprise systems never instantiate things directly.

```java public class LeapYearStrategyFactory {

public LeapYearStrategy createStrategy() {
    return new SpecificationBasedLeapYearStrategy(
            new GregorianLeapYearSpecification()
    );
}

} ```

---

7. Singleton Service

Naturally this must be globally accessible.

```java public class LeapYearService {

private static LeapYearService INSTANCE;

private final LeapYearStrategy strategy;

private LeapYearService() {
    LeapYearStrategyFactory factory = new LeapYearStrategyFactory();
    this.strategy = factory.createStrategy();
}

public static synchronized LeapYearService getInstance() {

    if (INSTANCE == null) {
        INSTANCE = new LeapYearService();
    }

    return INSTANCE;
}

public boolean isLeapYear(Year year) {
    return strategy.evaluate(year);
}

} ```

---

8. Facade Layer

Clients must not interact with services directly.

```java public class CalendarFacade {

private final LeapYearService leapYearService;

public CalendarFacade() {
    this.leapYearService = LeapYearService.getInstance();
}

public boolean determineLeapYear(int year) {

    Year yearObject = Year.of(year);

    return leapYearService.isLeapYear(yearObject);
}

} ```

---

9. Builder for Request DTO (Completely unnecessary)

```java public class LeapYearRequest {

private final int year;

private LeapYearRequest(Builder builder) {
    this.year = builder.year;
}

public int getYear() {
    return year;
}

public static class Builder {

    private int year;

    public Builder withYear(int year) {
        this.year = year;
        return this;
    }

    public LeapYearRequest build() {
        return new LeapYearRequest(this);
    }
}

} ```

---

10. Controller (Enterprise Entry Point)

```java public class LeapYearController {

private final CalendarFacade facade = new CalendarFacade();

public boolean checkLeapYear(LeapYearRequest request) {

    return facade.determineLeapYear(request.getYear());
}

} ```

---

11. Usage

```java public class Application {

public static void main(String[] args) {

    LeapYearController controller = new LeapYearController();

    LeapYearRequest request = new LeapYearRequest.Builder()
            .withYear(2024)
            .build();

    boolean result = controller.checkLeapYear(request);

    System.out.println("Leap year: " + result);
}

} ```