Overview
Custom patterns are reusable solutions to common problems that aren't covered by traditional Gang of Four patterns. These patterns address modern challenges in software development.
1. Repository Pattern with Caching
Generic Repository Interface
public interface Repository<T, ID> {
Optional<T> findById(ID id);
List<T> findAll();
T save(T entity);
void deleteById(ID id);
boolean existsById(ID id);
long count();
}
Cached Repository Implementation
public class CachedRepository<T, ID> implements Repository<T, ID> {
private final Repository<T, ID> delegate;
private final Cache<ID, T> cache;
private final Cache<String, List<T>> queryCache;
public CachedRepository(Repository<T, ID> delegate,
CacheConfig cacheConfig) {
this.delegate = delegate;
this.cache = Caffeine.newBuilder()
.maximumSize(cacheConfig.getMaxSize())
.expireAfterWrite(cacheConfig.getTtl())
.build();
this.queryCache = Caffeine.newBuilder()
.maximumSize(100)
.expireAfterWrite(5, TimeUnit.MINUTES)
.build();
}
@Override
public Optional<T> findById(ID id) {
T cached = cache.getIfPresent(id);
if (cached != null) {
return Optional.of(cached);
}
Optional<T> result = delegate.findById(id);
result.ifPresent(entity -> cache.put(id, entity));
return result;
}
@Override
public List<T> findAll() {
String cacheKey = "findAll";
List<T> cached = queryCache.getIfPresent(cacheKey);
if (cached != null) {
return cached;
}
List<T> result = delegate.findAll();
queryCache.put(cacheKey, result);
return result;
}
@Override
public T save(T entity) {
T saved = delegate.save(entity);
// Invalidate relevant caches
cache.invalidateAll();
queryCache.invalidateAll();
return saved;
}
@Override
public void deleteById(ID id) {
delegate.deleteById(id);
cache.invalidate(id);
queryCache.invalidateAll();
}
// Cache management methods
public void evictById(ID id) {
cache.invalidate(id);
}
public void evictAll() {
cache.invalidateAll();
queryCache.invalidateAll();
}
}
2. Pipeline Pattern
Pipeline Interface
public interface Pipeline<T> {
T execute(T input);
Pipeline<T> addStep(PipelineStep<T> step);
Pipeline<T> addConditionalStep(Predicate<T> condition, PipelineStep<T> step);
}
Pipeline Implementation
public class ProcessingPipeline<T> implements Pipeline<T> {
private final List<PipelineStep<T>> steps;
private final List<ConditionalStep<T>> conditionalSteps;
public ProcessingPipeline() {
this.steps = new ArrayList<>();
this.conditionalSteps = new ArrayList<>();
}
@Override
public T execute(T input) {
T current = input;
// Execute regular steps
for (PipelineStep<T> step : steps) {
current = step.execute(current);
}
// Execute conditional steps
for (ConditionalStep<T> conditional : conditionalSteps) {
if (conditional.getCondition().test(current)) {
current = conditional.getStep().execute(current);
}
}
return current;
}
@Override
public Pipeline<T> addStep(PipelineStep<T> step) {
steps.add(step);
return this;
}
@Override
public Pipeline<T> addConditionalStep(Predicate<T> condition, PipelineStep<T> step) {
conditionalSteps.add(new ConditionalStep<>(condition, step));
return this;
}
// Builder for fluent pipeline creation
public static <T> Builder<T> builder() {
return new Builder<>();
}
public static class Builder<T> {
private final ProcessingPipeline<T> pipeline;
private Builder() {
this.pipeline = new ProcessingPipeline<>();
}
public Builder<T> withStep(PipelineStep<T> step) {
pipeline.addStep(step);
return this;
}
public Builder<T> withConditionalStep(Predicate<T> condition, PipelineStep<T> step) {
pipeline.addConditionalStep(condition, step);
return this;
}
public ProcessingPipeline<T> build() {
return pipeline;
}
}
}
Pipeline Steps
@FunctionalInterface
public interface PipelineStep<T> {
T execute(T input);
default PipelineStep<T> andThen(PipelineStep<T> next) {
return input -> next.execute(this.execute(input));
}
}
// Concrete pipeline steps
public class ValidationStep<T> implements PipelineStep<T> {
private final Validator<T> validator;
public ValidationStep(Validator<T> validator) {
this.validator = validator;
}
@Override
public T execute(T input) {
ValidationResult result = validator.validate(input);
if (!result.isValid()) {
throw new ValidationException("Validation failed: " + result.getErrors());
}
return input;
}
}
public class TransformationStep<T> implements PipelineStep<T> {
private final Function<T, T> transformer;
public TransformationStep(Function<T, T> transformer) {
this.transformer = transformer;
}
@Override
public T execute(T input) {
return transformer.apply(input);
}
}
public class LoggingStep<T> implements PipelineStep<T> {
private final Logger logger;
private final String stepName;
public LoggingStep(Logger logger, String stepName) {
this.logger = logger;
this.stepName = stepName;
}
@Override
public T execute(T input) {
logger.info("Executing step: {} with input: {}", stepName, input);
T result = input; // Pass-through for logging
logger.info("Step {} completed with result: {}", stepName, result);
return result;
}
}
3. Specification Pattern
Specification Interface
public interface Specification<T> {
boolean isSatisfiedBy(T candidate);
default Specification<T> and(Specification<T> other) {
return new AndSpecification<>(this, other);
}
default Specification<T> or(Specification<T> other) {
return new OrSpecification<>(this, other);
}
default Specification<T> not() {
return new NotSpecification<>(this);
}
static <T> Specification<T> of(Predicate<T> predicate) {
return predicate::test;
}
}
Composite Specifications
public class AndSpecification<T> implements Specification<T> {
private final Specification<T> left;
private final Specification<T> right;
public AndSpecification(Specification<T> left, Specification<T> right) {
this.left = left;
this.right = right;
}
@Override
public boolean isSatisfiedBy(T candidate) {
return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
}
}
public class OrSpecification<T> implements Specification<T> {
private final Specification<T> left;
private final Specification<T> right;
public OrSpecification(Specification<T> left, Specification<T> right) {
this.left = left;
this.right = right;
}
@Override
public boolean isSatisfiedBy(T candidate) {
return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
}
}
public class NotSpecification<T> implements Specification<T> {
private final Specification<T> specification;
public NotSpecification(Specification<T> specification) {
this.specification = specification;
}
@Override
public boolean isSatisfiedBy(T candidate) {
return !specification.isSatisfiedBy(candidate);
}
}
Concrete Specifications
public class UserSpecifications {
public static Specification<User> isActive() {
return candidate -> candidate.isActive();
}
public static Specification<User> hasRole(String role) {
return candidate -> candidate.getRoles().contains(role);
}
public static Specification<User> createdAfter(Instant date) {
return candidate -> candidate.getCreatedAt().isAfter(date);
}
public static Specification<User> withMinimumAge(int age) {
return candidate -> Period.between(candidate.getBirthDate(), LocalDate.now())
.getYears() >= age;
}
public static Specification<User> withEmailDomain(String domain) {
return candidate -> candidate.getEmail().endsWith("@" + domain);
}
}
// Usage example
public class UserService {
public List<User> findUsers(Specification<User> spec) {
return userRepository.findAll().stream()
.filter(spec::isSatisfiedBy)
.collect(Collectors.toList());
}
// Complex query example
public List<User> findEligibleAdmins() {
Specification<User> spec = UserSpecifications.isActive()
.and(UserSpecifications.hasRole("ADMIN"))
.and(UserSpecifications.withMinimumAge(18))
.and(UserSpecifications.createdAfter(Instant.now().minus(365, ChronoUnit.DAYS)));
return findUsers(spec);
}
}
4. Retry Pattern
Retry Policy
public class RetryPolicy {
private final int maxAttempts;
private final Duration initialDelay;
private final Duration maxDelay;
private final double backoffMultiplier;
private final Predicate<Exception> retryCondition;
private RetryPolicy(Builder builder) {
this.maxAttempts = builder.maxAttempts;
this.initialDelay = builder.initialDelay;
this.maxDelay = builder.maxDelay;
this.backoffMultiplier = builder.backoffMultiplier;
this.retryCondition = builder.retryCondition;
}
public static Builder builder() {
return new Builder();
}
public static class Builder {
private int maxAttempts = 3;
private Duration initialDelay = Duration.ofSeconds(1);
private Duration maxDelay = Duration.ofMinutes(1);
private double backoffMultiplier = 2.0;
private Predicate<Exception> retryCondition = e -> true;
public Builder maxAttempts(int maxAttempts) {
this.maxAttempts = maxAttempts;
return this;
}
public Builder initialDelay(Duration initialDelay) {
this.initialDelay = initialDelay;
return this;
}
public Builder maxDelay(Duration maxDelay) {
this.maxDelay = maxDelay;
return this;
}
public Builder backoffMultiplier(double multiplier) {
this.backoffMultiplier = multiplier;
return this;
}
public Builder retryOn(Predicate<Exception> condition) {
this.retryCondition = condition;
return this;
}
public Builder retryOn(Class<? extends Exception> exceptionType) {
this.retryCondition = e -> exceptionType.isInstance(e);
return this;
}
public RetryPolicy build() {
return new RetryPolicy(this);
}
}
// Getters
public int getMaxAttempts() { return maxAttempts; }
public Duration getInitialDelay() { return initialDelay; }
public Duration getMaxDelay() { return maxDelay; }
public double getBackoffMultiplier() { return backoffMultiplier; }
public Predicate<Exception> getRetryCondition() { return retryCondition; }
}
Retry Template
public class RetryTemplate {
private final RetryPolicy retryPolicy;
private final ScheduledExecutorService scheduler;
public RetryTemplate(RetryPolicy retryPolicy) {
this.retryPolicy = retryPolicy;
this.scheduler = Executors.newSingleThreadScheduledExecutor();
}
public <T> T execute(Supplier<T> operation) {
Exception lastException = null;
for (int attempt = 1; attempt <= retryPolicy.getMaxAttempts(); attempt++) {
try {
return operation.get();
} catch (Exception e) {
lastException = e;
if (!shouldRetry(e) || attempt == retryPolicy.getMaxAttempts()) {
break;
}
Duration delay = calculateDelay(attempt);
sleep(delay);
}
}
throw new RetryExhaustedException("Operation failed after " +
retryPolicy.getMaxAttempts() + " attempts", lastException);
}
public void execute(Runnable operation) {
execute(() -> {
operation.run();
return null;
});
}
public <T> CompletableFuture<T> executeAsync(Supplier<T> operation) {
return CompletableFuture.supplyAsync(() -> execute(operation));
}
private boolean shouldRetry(Exception e) {
return retryPolicy.getRetryCondition().test(e);
}
private Duration calculateDelay(int attempt) {
long delayMillis = (long) (retryPolicy.getInitialDelay().toMillis() *
Math.pow(retryPolicy.getBackoffMultiplier(), attempt - 1));
return Duration.ofMillis(Math.min(delayMillis, retryPolicy.getMaxDelay().toMillis()));
}
private void sleep(Duration duration) {
try {
Thread.sleep(duration.toMillis());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RetryInterruptedException("Retry was interrupted", e);
}
}
}
5. Circuit Breaker Pattern
Circuit Breaker State
public enum CircuitBreakerState {
CLOSED, // Normal operation
OPEN, // Circuit is open, requests fail fast
HALF_OPEN // Testing if service has recovered
}
Circuit Breaker Implementation
public class CircuitBreaker {
private final String name;
private final int failureThreshold;
private final Duration timeout;
private final Duration resetTimeout;
private final Clock clock;
private volatile CircuitBreakerState state = CircuitBreakerState.CLOSED;
private volatile int failureCount = 0;
private volatile Instant lastFailureTime;
private volatile Instant halfOpenTime;
public CircuitBreaker(String name, int failureThreshold,
Duration timeout, Duration resetTimeout) {
this(name, failureThreshold, timeout, resetTimeout, Clock.systemUTC());
}
public CircuitBreaker(String name, int failureThreshold,
Duration timeout, Duration resetTimeout, Clock clock) {
this.name = name;
this.failureThreshold = failureThreshold;
this.timeout = timeout;
this.resetTimeout = resetTimeout;
this.clock = clock;
}
public <T> T execute(Supplier<T> supplier) {
if (!allowRequest()) {
throw new CircuitBreakerOpenException("Circuit breaker is open: " + name);
}
try {
T result = supplier.get();
onSuccess();
return result;
} catch (Exception e) {
onFailure();
throw e;
}
}
public void execute(Runnable runnable) {
execute(() -> {
runnable.run();
return null;
});
}
private boolean allowRequest() {
switch (state) {
case CLOSED:
return true;
case OPEN:
// Check if reset timeout has elapsed
if (lastFailureTime.plus(resetTimeout).isBefore(clock.instant())) {
state = CircuitBreakerState.HALF_OPEN;
halfOpenTime = clock.instant();
return true;
}
return false;
case HALF_OPEN:
// Allow limited requests in half-open state
if (halfOpenTime.plus(timeout).isBefore(clock.instant())) {
// Too much time passed, go back to open
state = CircuitBreakerState.OPEN;
return false;
}
return true;
default:
return false;
}
}
private void onSuccess() {
switch (state) {
case HALF_OPEN:
// Successful request in half-open state, reset circuit
reset();
break;
case CLOSED:
// Reset failure count on consecutive successes
if (failureCount > 0) {
failureCount = 0;
}
break;
}
}
private void onFailure() {
failureCount++;
lastFailureTime = clock.instant();
switch (state) {
case CLOSED:
if (failureCount >= failureThreshold) {
state = CircuitBreakerState.OPEN;
}
break;
case HALF_OPEN:
// Failure in half-open state, go back to open
state = CircuitBreakerState.OPEN;
break;
}
}
private void reset() {
state = CircuitBreakerState.CLOSED;
failureCount = 0;
lastFailureTime = null;
halfOpenTime = null;
}
// Getters for monitoring
public CircuitBreakerState getState() { return state; }
public int getFailureCount() { return failureCount; }
public String getName() { return name; }
public Instant getLastFailureTime() { return lastFailureTime; }
}
Circuit Breaker Registry
@Component
public class CircuitBreakerRegistry {
private final Map<String, CircuitBreaker> breakers;
private final CircuitBreakerConfig defaultConfig;
public CircuitBreakerRegistry(CircuitBreakerConfig defaultConfig) {
this.breakers = new ConcurrentHashMap<>();
this.defaultConfig = defaultConfig;
}
public CircuitBreaker getBreaker(String name) {
return breakers.computeIfAbsent(name, this::createCircuitBreaker);
}
public CircuitBreaker getBreaker(String name, CircuitBreakerConfig config) {
return breakers.computeIfAbsent(name, k -> createCircuitBreaker(k, config));
}
public Map<String, CircuitBreaker> getBreakers() {
return Collections.unmodifiableMap(breakers);
}
public CircuitBreakerStats getStats(String name) {
CircuitBreaker breaker = breakers.get(name);
if (breaker == null) {
return null;
}
return new CircuitBreakerStats(
breaker.getName(),
breaker.getState(),
breaker.getFailureCount(),
breaker.getLastFailureTime()
);
}
private CircuitBreaker createCircuitBreaker(String name) {
return createCircuitBreaker(name, defaultConfig);
}
private CircuitBreaker createCircuitBreaker(String name, CircuitBreakerConfig config) {
return new CircuitBreaker(
name,
config.getFailureThreshold(),
config.getTimeout(),
config.getResetTimeout(),
config.getClock()
);
}
}
6. Event Sourcing Pattern
Event Interface
public interface DomainEvent {
String getAggregateId();
Instant getTimestamp();
String getType();
int getVersion();
}
public abstract class BaseEvent implements DomainEvent {
private final String aggregateId;
private final Instant timestamp;
private final int version;
protected BaseEvent(String aggregateId, int version) {
this.aggregateId = aggregateId;
this.timestamp = Instant.now();
this.version = version;
}
@Override public String getAggregateId() { return aggregateId; }
@Override public Instant getTimestamp() { return timestamp; }
@Override public int getVersion() { return version; }
}
Aggregate Root
public abstract class AggregateRoot {
private final String id;
private int version = 0;
private final List<DomainEvent> changes = new ArrayList<>();
protected AggregateRoot(String id) {
this.id = id;
}
public String getId() { return id; }
public int getVersion() { return version; }
public List<DomainEvent> getUncommittedChanges() {
return Collections.unmodifiableList(changes);
}
public void markChangesAsCommitted() {
changes.clear();
}
public void loadFromHistory(List<DomainEvent> history) {
for (DomainEvent event : history) {
applyChange(event, false);
version = event.getVersion();
}
}
protected void applyChange(DomainEvent event) {
applyChange(event, true);
}
private void applyChange(DomainEvent event, boolean isNew) {
try {
Method method = getClass().getDeclaredMethod("apply", event.getClass());
method.setAccessible(true);
method.invoke(this, event);
} catch (Exception e) {
throw new RuntimeException("Error applying event", e);
}
if (isNew) {
changes.add(event);
}
}
}
Event Store
public interface EventStore {
void saveEvents(String aggregateId, List<DomainEvent> events, int expectedVersion);
List<DomainEvent> getEvents(String aggregateId);
List<DomainEvent> getEventsAfter(String aggregateId, int version);
List<String> getAggregateIds();
}
public class InMemoryEventStore implements EventStore {
private final Map<String, List<DomainEvent>> eventStore = new ConcurrentHashMap<>();
private final Map<String, Integer> currentVersions = new ConcurrentHashMap<>();
@Override
public void saveEvents(String aggregateId, List<DomainEvent> events, int expectedVersion) {
synchronized (aggregateId.intern()) {
int currentVersion = currentVersions.getOrDefault(aggregateId, -1);
if (currentVersion != expectedVersion) {
throw new ConcurrencyException("Concurrent modification detected for aggregate: " + aggregateId);
}
List<DomainEvent> aggregateEvents = eventStore.computeIfAbsent(aggregateId, k -> new ArrayList<>());
int version = expectedVersion;
for (DomainEvent event : events) {
version++;
// Create new event with correct version
aggregateEvents.add(event);
}
currentVersions.put(aggregateId, version);
}
}
@Override
public List<DomainEvent> getEvents(String aggregateId) {
return eventStore.getOrDefault(aggregateId, Collections.emptyList());
}
@Override
public List<DomainEvent> getEventsAfter(String aggregateId, int version) {
List<DomainEvent> allEvents = getEvents(aggregateId);
return allEvents.stream()
.filter(event -> event.getVersion() > version)
.collect(Collectors.toList());
}
@Override
public List<String> getAggregateIds() {
return new ArrayList<>(eventStore.keySet());
}
}
7. Builder Pattern with Fluent Interface
Advanced Builder Pattern
public class HttpRequest {
private final String url;
private final HttpMethod method;
private final Map<String, String> headers;
private final String body;
private final Duration timeout;
private final int maxRetries;
private final boolean followRedirects;
private HttpRequest(Builder builder) {
this.url = builder.url;
this.method = builder.method;
this.headers = Collections.unmodifiableMap(new HashMap<>(builder.headers));
this.body = builder.body;
this.timeout = builder.timeout;
this.maxRetries = builder.maxRetries;
this.followRedirects = builder.followRedirects;
}
public static Builder builder() {
return new Builder();
}
// Getters...
public static class Builder {
private String url;
private HttpMethod method = HttpMethod.GET;
private Map<String, String> headers = new HashMap<>();
private String body;
private Duration timeout = Duration.ofSeconds(30);
private int maxRetries = 3;
private boolean followRedirects = true;
public Builder url(String url) {
this.url = Objects.requireNonNull(url, "URL cannot be null");
return this;
}
public Builder method(HttpMethod method) {
this.method = Objects.requireNonNull(method, "Method cannot be null");
return this;
}
public Builder header(String name, String value) {
this.headers.put(Objects.requireNonNull(name), Objects.requireNonNull(value));
return this;
}
public Builder headers(Map<String, String> headers) {
this.headers.putAll(Objects.requireNonNull(headers));
return this;
}
public Builder body(String body) {
this.body = body;
return this;
}
public Builder jsonBody(Object object) {
try {
ObjectMapper mapper = new ObjectMapper();
this.body = mapper.writeValueAsString(object);
header("Content-Type", "application/json");
return this;
} catch (JsonProcessingException e) {
throw new IllegalArgumentException("Failed to serialize object to JSON", e);
}
}
public Builder timeout(Duration timeout) {
this.timeout = Objects.requireNonNull(timeout);
return this;
}
public Builder timeout(long amount, TimeUnit unit) {
return timeout(Duration.ofMillis(unit.toMillis(amount)));
}
public Builder maxRetries(int maxRetries) {
if (maxRetries < 0) {
throw new IllegalArgumentException("Max retries cannot be negative");
}
this.maxRetries = maxRetries;
return this;
}
public Builder followRedirects(boolean followRedirects) {
this.followRedirects = followRedirects;
return this;
}
public HttpRequest build() {
Objects.requireNonNull(url, "URL must be specified");
if (method == HttpMethod.POST || method == HttpMethod.PUT) {
if (body == null) {
throw new IllegalStateException("Body must be specified for " + method + " requests");
}
}
return new HttpRequest(this);
}
}
}
Usage Examples
Pipeline Pattern Usage
public class DataProcessingExample {
public static void main(String[] args) {
Pipeline<String> pipeline = ProcessingPipeline.<String>builder()
.withStep(new ValidationStep<>(new DataValidator()))
.withStep(new TransformationStep<>(String::toUpperCase))
.withStep(new LoggingStep<>(LoggerFactory.getLogger(DataProcessingExample.class), "uppercase"))
.withStep(new TransformationStep<>(s -> s.replaceAll("\\s+", "_")))
.withConditionalStep(s -> s.length() > 10, new TransformationStep<>(s -> s.substring(0, 10)))
.build();
String result = pipeline.execute("hello world");
System.out.println("Result: " + result); // "HELLO_WORL"
}
}
Circuit Breaker Usage
public class ExternalServiceClient {
private final CircuitBreaker circuitBreaker;
private final RestTemplate restTemplate;
public ExternalServiceClient(CircuitBreakerRegistry registry) {
this.circuitBreaker = registry.getBreaker("external-service",
CircuitBreakerConfig.builder()
.failureThreshold(5)
.resetTimeout(Duration.ofMinutes(1))
.build());
this.restTemplate = new RestTemplate();
}
public String callExternalService() {
return circuitBreaker.execute(() -> {
ResponseEntity<String> response = restTemplate.getForEntity(
"https://api.example.com/data", String.class);
return response.getBody();
});
}
}
These custom patterns provide robust, reusable solutions for common challenges in modern Java applications, including resilience, data processing, domain modeling, and API design.