public interface DBLogging {
    String MONGO_DB_NAME = "ABC_Mongo_Datastore";
    String NEO4J_DB_NAME = "ABC_Neo4J_Datastore";
    String CASSANDRA_DB_NAME = "ABC_Cassandra_Datastore";

    default void logInfo(String message) { log(message, "INFO"); }
    default void logWarn(String message) { log(message, "WARN"); }
    default void logError(String message) { log(message, "ERROR"); }
    default void logFatal(String message) { log(message, "FATAL"); }

    private void log(String message, String msgPrefix) {
        // Step 1: Connect to DataStore
        // Step 2: Log Message with Prefix and styles etc.
        // Step 3: Close the DataStore connection
    }
}

class Base {
    public static void staticDisplay() {
        System.out.println("Static method from Base");
    }
    public void print() {
        System.out.println("Non-static method from Base");
    }
}

class Derived extends Base {
    public static void staticDisplay() {
        System.out.println("Static method from Derived");
    }
    @Override
    public void print() {
        System.out.println("Non-static method from Derived");
    }
}

public class Test {
    public static void main(String args[]) {
        Base obj1 = new Derived();

        obj1.staticDisplay(); // Output: Static method from Base
        obj1.print();         // Output: Non-static method from Derived
    }
}

public class OuterStatic {
    private static String staticOuterField = "Static Outer Field";
    private String instanceOuterField = "Instance Outer Field";

    public static class StaticNested {
        public static String staticInnerField = "Static Inner Field";

        public void display() {
            System.out.println(staticOuterField);
            // COMPILER ERROR: Cannot access instance members of the outer class directly
            // System.out.println(instanceOuterField);
        }
    }
}

OuterStatic.StaticNested nested = new OuterStatic.StaticNested();
nested.display();
System.out.println(OuterStatic.StaticNested.staticInnerField);

public class OuterNonStatic {
    private String instanceOuterField = "Instance Outer Field";

    public class InnerClass {
        // Cannot define static fields unless they are final constants
        public static final int CONSTANT_FIELD = 42;

        // Cannot define static methods
        // public static void staticMethod() {}

        public void display() {
            System.out.println("Accessing: " + instanceOuterField);
        }
    }
}

OuterNonStatic outer = new OuterNonStatic();
OuterNonStatic.InnerClass inner = outer.new InnerClass();
inner.display();

// Option 1: Wrap in try-catch inside the lambda
list.forEach(item -> {
    try {
        process(item); // throws IOException
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
});

// Option 2: Create a wrapper utility
@FunctionalInterface
interface ThrowingConsumer<T> {
    void accept(T t) throws Exception;
}

static <T> Consumer<T> wrap(ThrowingConsumer<T> consumer) {
    return t -> {
        try { consumer.accept(t); }
        catch (Exception e) { throw new RuntimeException(e); }
    };
}

list.forEach(wrap(item -> process(item)));

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecute {
    String name() default "";
}

public class Employee {
    @LogExecute(name = "hello")
    public void print() {
        System.out.println("Hello");
    }
}

Method method = Employee.class.getMethod("print");
if (method.isAnnotationPresent(LogExecute.class)) {
    LogExecute annotation = method.getAnnotation(LogExecute.class);
    System.out.println("Logging for: " + annotation.name());
}

Class<?> clazz = Class.forName("com.example.Employee");

// Get all methods
Method[] methods = clazz.getDeclaredMethods();

// Invoke a method dynamically
Method method = clazz.getMethod("getName");
Object instance = clazz.getDeclaredConstructor().newInstance();
Object result = method.invoke(instance);

// Access private field
Field field = clazz.getDeclaredField("salary");
field.setAccessible(true);
field.set(instance, 50000);

// Serializable (marker interface)
public class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password; // excluded from serialization
}

// Externalizable (explicit control)
public class Employee implements Externalizable {
    private String name;
    private int age;

    public Employee() {} // Required!

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = in.readInt();
    }
}

// NIO non-blocking server (simplified)
Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select(); // blocks until at least one channel is ready
    Set<SelectionKey> keys = selector.selectedKeys();
    // process ready channels...
}

String multilineString = "Baeldung helps \n \n developers \n explore Java.";
List<String> lines = multilineString.lines()
    .filter(line -> !line.isBlank())
    .map(String::strip)
    .collect(Collectors.toList());

// ["Baeldung helps", "developers", "explore Java."]

List<String> sampleList = Arrays.asList("Java", "Kotlin");
String[] sampleArray = sampleList.toArray(String[]::new);

List<String> sampleList = Arrays.asList("Java", "Kotlin");
String resultString = sampleList.stream()
    .map((@Nonnull var x) -> x.toUpperCase())
    .collect(Collectors.joining(", "));

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

public class HttpClientExample {

    private static final HttpClient httpClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();

    public static void main(String[] args) {
        String url = "https://jsonplaceholder.typicode.com/posts/1";

        HttpRequest request = HttpRequest.newBuilder()
                .GET()
                .uri(URI.create(url))
                .header("Accept", "application/json")
                .build();

        System.out.println("Sending asynchronous GET request...");

        CompletableFuture<HttpResponse<String>> responseFuture = httpClient.sendAsync(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        responseFuture.thenAccept(response -> {
            int statusCode = response.statusCode();
            String responseBody = response.body();
            System.out.println("\nStatus Code: " + statusCode);
            System.out.println("Response Body:\n" + responseBody);
        }).exceptionally(ex -> {
            System.err.println("An error occurred: " + ex.getMessage());
            return null;
        });

        responseFuture.join();
    }
}

List<String> strings = new ArrayList<>();
List<Integer> ints = new ArrayList<>();
// At runtime: both are just List
System.out.println(strings.getClass() == ints.getClass()); // true

<T extends Comparable<T>>   // upper bound
<? super Integer>            // lower bound (wildcard)
<? extends Number>           // upper bound (wildcard)

// Method 1: Collections Wrapper
List<String> namesList = Collections.synchronizedList(new ArrayList<>());
// Note: Manual looping blocks still require explicit synchronized block.

// Method 2: Copy-On-Write
List<String> cowList = new CopyOnWriteArrayList<>();
// Iterators are thread-safe; each modification creates a new array clone.

int[][] a1 = {{10, 20}, {40, 50}};
int[][] a3 = {{10, 20}, {40, 50}};

Arrays.equals(a1, a3);     // false (top-level reference pointers)
Arrays.deepEquals(a1, a3); // true (evaluates all inner dimensions)

// IdentityHashMap
String a = new String("key");
String b = new String("key");
Map<String, Integer> map = new IdentityHashMap<>();
map.put(a, 1);
map.put(b, 2); // Different key — a != b (reference comparison)
// map.size() == 2

// WeakHashMap
Map<Object, String> map = new WeakHashMap<>();
Object key = new Object();
map.put(key, "value");
key = null; // No strong reference → eligible for GC
System.gc();
// map may be empty after GC

private volatile boolean running = true;

// Thread 1 writes:
running = false;

// Thread 2 reads — guaranteed to see 'false' due to volatile
while (running) { /* ... */ }

public class UserRequestContext {
    private static final ThreadLocal<String> userSecurityToken = new ThreadLocal<>();

    public static void setToken(String token) {
        userSecurityToken.set(token);
    }

    public static String getToken() {
        return userSecurityToken.get();
    }

    public static void clear() {
        userSecurityToken.remove();
    }
}

package com.example.demo;
import lombok.AllArgsConstructor;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DemoApplication {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Enable enable = new Enable(true);

        OddEvenThread odd = new OddEvenThread(1, lock, true, enable);
        OddEvenThread even = new OddEvenThread(2, lock, false, enable);

        new Thread(odd).start();
        new Thread(even).start();
    }
}

@AllArgsConstructor class Enable { boolean enable; }

@AllArgsConstructor
class OddEvenThread implements Runnable {
    private int start;
    private Lock lock;
    boolean enableVal;
    Enable enable;

    @Override
    public void run() {
        while (start < 100) {
            lock.lock();
            if (enableVal == enable.enable) {
                System.out.println(start);
                start += 2;
                enable.enable = !enable.enable;
            }
            lock.unlock();
        }
    }
}

public class Printer {
    Semaphore odd = new Semaphore(1);
    Semaphore even = new Semaphore(0);

    public void printEven(int num) throws InterruptedException {
        even.acquire();
        System.out.println(num);
        odd.release();
    }

    public void printOdd(int num) throws InterruptedException {
        odd.acquire();
        System.out.println(num);
        even.release();
    }
}

class Printer {
    private boolean isOddTurn;

    public Printer(boolean startWithOdd) {
        this.isOddTurn = startWithOdd;
    }

    public synchronized void printEven(int num) throws InterruptedException {
        while (isOddTurn) { wait(); }
        System.out.println(Thread.currentThread().getName() + ": " + num);
        isOddTurn = true;
        notify();
    }

    public synchronized void printOdd(int num) throws InterruptedException {
        while (!isOddTurn) { wait(); }
        System.out.println(Thread.currentThread().getName() + ": " + num);
        isOddTurn = false;
        notify();
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer(true);
        int maxNumber = 10;

        Thread oddThread = new Thread(() -> {
            for (int i = 1; i <= maxNumber; i += 2) {
                try { printer.printOdd(i); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "Odd-Thread");

        Thread evenThread = new Thread(() -> {
            for (int i = 2; i <= maxNumber; i += 2) {
                try { printer.printEven(i); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "Even-Thread");

        oddThread.start();
        evenThread.start();
    }
}

class X {
    private final ReentrantLock lock = new ReentrantLock();
    public void m() {
        lock.lock();
        try {
            // Method body execution
        } finally {
            lock.unlock();
        }
    }
}

public class SharedBuffer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int CAPACITY = 5;

    public synchronized void produce(int item) throws InterruptedException {
        while (queue.size() == CAPACITY) { wait(); }
        queue.add(item);
        System.out.println("Produced: " + item);
        notifyAll();
    }

    public synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) { wait(); }
        int item = queue.poll();
        System.out.println("Consumed: " + item);
        notifyAll();
        return item;
    }
}

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
// Producer:
queue.put(item);    // blocks if full
// Consumer:
int item = queue.take(); // blocks if empty

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CustomBlockingQueue<E> {
    private final Queue<E> queue = new LinkedList<>();
    private final Lock lock = new ReentrantLock();
    private final Condition isNotEmpty = lock.newCondition();

    public void enqueue(E element) {
        lock.lock();
        try {
            queue.add(element);
            isNotEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public E dequeue() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) { isNotEmpty.await(); }
            return queue.poll();
        } finally {
            lock.unlock();
        }
    }
}

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBlockingQueue<E> {
    private final Queue<E> queue = new LinkedList<>();
    private final int capacity;
    private final Lock lock = new ReentrantLock();
    private final Condition isNotEmpty = lock.newCondition();
    private final Condition isNotFull = lock.newCondition();

    public BoundedBlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public void enqueue(E element) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) { isNotFull.await(); }
            queue.add(element);
            isNotEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public E dequeue() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) { isNotEmpty.await(); }
            E element = queue.poll();
            isNotFull.signal();
            return element;
        } finally {
            lock.unlock();
        }
    }
}

public class CustomCountDownLatch {
    private int count;

    public CustomCountDownLatch(int count) {
        if (count < 0) {
            throw new IllegalArgumentException("Count cannot be negative.");
        }
        this.count = count;
    }

    public synchronized void await() throws InterruptedException {
        while (count > 0) { wait(); }
    }

    public synchronized void countDown() {
        if (count > 0) {
            count--;
            if (count == 0) { notifyAll(); }
        }
    }

    public synchronized int getCount() {
        return count;
    }
}

import java.util.ArrayList;
import java.util.List;

public class CustomThreadPool {
    private final BoundedBlockingQueue<Runnable> taskQueue;
    private final List<WorkerThread> workers;
    private boolean isShutdown = false;

    public CustomThreadPool(int threadCount, int maxTasks) {
        this.taskQueue = new BoundedBlockingQueue<>(maxTasks);
        this.workers = new ArrayList<>(threadCount);

        for (int i = 0; i < threadCount; i++) {
            WorkerThread worker = new WorkerThread();
            workers.add(worker);
            worker.start();
        }
    }

    public void execute(Runnable task) throws InterruptedException {
        if (this.isShutdown) {
            throw new IllegalStateException("ThreadPool has been shut down.");
        }
        taskQueue.enqueue(task);
    }

    public void shutdown() {
        this.isShutdown = true;
        for (WorkerThread worker : workers) {
            worker.interrupt();
        }
    }

    private class WorkerThread extends Thread {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Runnable task = taskQueue.dequeue();
                    task.run();
                } catch (InterruptedException e) {
                    break;
                }
            }
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public class LRUCache {
    private final int capacity;
    private final Map<Integer, Node> map;
    private final Node head;
    private final Node tail;

    private static class Node {
        int key;
        int value;
        Node prev;
        Node next;
        Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    public synchronized int get(int key) {
        Node node = map.get(key);
        if (node == null) return -1;
        moveToHead(node);
        return node.value;
    }

    public synchronized void put(int key, int value) {
        Node node = map.get(key);
        if (node != null) {
            node.value = value;
            moveToHead(node);
        } else {
            if (map.size() >= capacity) {
                map.remove(tail.prev.key);
                removeNode(tail.prev);
            }
            Node newNode = new Node(key, value);
            map.put(key, newNode);
            addNode(newNode);
        }
    }

    private void addNode(Node node) {
        node.next = head.next;
        node.next.prev = node;
        node.prev = head;
        head.next = node;
    }

    private void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void moveToHead(Node node) {
        removeNode(node);
        addNode(node);
    }
}

// Basic async computation
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return fetchDataFromDB(); // runs in ForkJoinPool thread
});

// Chain transformations
future.thenApply(data -> transform(data))         // sync, same thread
      .thenApplyAsync(data -> transform(data))    // async, new thread
      .thenAccept(result -> System.out.println(result));

// Combine multiple futures
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "World");
CompletableFuture<String> combined = f1.thenCombine(f2, (a, b) -> a + " " + b);

// Wait for all / any
CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2);
all.join();
CompletableFuture<Object> first = CompletableFuture.anyOf(f1, f2);

// Exception handling
future.exceptionally(ex -> {
    log.error("Error: ", ex);
    return "fallback";
});

future.handle((result, ex) -> {
    if (ex != null) return "error";
    return result;
});

// Sequential
list.stream().filter(n -> n > 5).map(n -> n * 2).collect(toList());

// Parallel
list.parallelStream().filter(n -> n > 5).map(n -> n * 2).collect(toList());

List<List<String>> dynamicNestedList = Arrays.asList(
    Arrays.asList("A", "B"),
    Arrays.asList("C", "D")
);

// flatMap() flattens internal structures: Stream<String> -> ["A", "B", "C", "D"]
List<String> flatResult = dynamicNestedList.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

class SumTask extends RecursiveTask<Long> {
    private final int[] arr;
    private final int start, end;
    static final int THRESHOLD = 1000;

    protected Long compute() {
        if (end - start <= THRESHOLD) {
            long sum = 0;
            for (int i = start; i < end; i++) sum += arr[i];
            return sum;
        }
        int mid = (start + end) / 2;
        SumTask left = new SumTask(arr, start, mid);
        SumTask right = new SumTask(arr, mid, end);
        left.fork();
        return right.compute() + left.join();
    }
}

// Violation: One class handles both user data AND email sending
class User {
    void saveToDatabase() { ... }
    void sendWelcomeEmail() { ... }
}

// Fix: Separate concerns
class User { void saveToDatabase() { ... } }
class EmailService { void sendWelcomeEmail(User user) { ... } }

interface Shape { double area(); }
class Circle implements Shape { ... }
class Rectangle implements Shape { ... }
// Adding Triangle does NOT modify existing code
class Triangle implements Shape { ... }

// Violation: Square extends Rectangle but breaks the contract
class Rectangle { void setWidth(int w); void setHeight(int h); }
class Square extends Rectangle {
    // Must set both — breaks caller assumptions
}

// Violation
interface Animal { void eat(); void fly(); void swim(); }

// Fix
interface Eatable { void eat(); }
interface Flyable { void fly(); }
interface Swimmable { void swim(); }
class Duck implements Eatable, Flyable, Swimmable { ... }
class Dog implements Eatable, Swimmable { ... }

// Violation
class OrderService {
    private MySQLDatabase db = new MySQLDatabase();
}

// Fix
interface Database { void save(Order o); }
class OrderService {
    private final Database db;
    OrderService(Database db) { this.db = db; }
}

// Violation: tax calc repeated inline
double priceWithTax1 = price * 1.18;
double priceWithTax2 = total * 1.18;

// Fix
double applyTax(double amount) { return amount * 1.18; }

// Over-engineered
AbstractVisitorFactoryStrategyBuilder.getInstance()
    .withStrategy(new DefaultStrategy())
    .build()
    .process(data);

// KISS
process(data);

import java.util.Date;

public final class ImmutableEmployee {
    private final String name;
    private final int id;
    private final Date joiningDate;

    public ImmutableEmployee(String name, int id, Date joiningDate) {
        this.name = name;
        this.id = id;
        this.joiningDate = new Date(joiningDate.getTime());
    }

    public String getName() { return name; }
    public int getId() { return id; }

    public Date getJoiningDate() {
        return new Date(joiningDate.getTime());
    }
}

// 1. Constructor Injection (preferred — immutable, testable)
@Service
public class OrderService {
    private final PaymentService paymentService;

    @Autowired // optional in modern Spring if single constructor
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

// 2. Setter Injection (optional dependencies)
@Autowired
public void setEmailService(EmailService emailService) { ... }

// 3. Field Injection (discouraged — hard to test)
@Autowired
private PaymentService paymentService;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint jp) {
        System.out.println("Before: " + jp.getSignature().getName());
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint jp) { ... }

    @AfterReturning(pointcut = "execution(* com.example.*.*(..))", returning = "result")
    public void logReturn(Object result) { ... }

    @AfterThrowing(pointcut = "execution(* com.example.*.*(..))", throwing = "ex")
    public void logException(Exception ex) { ... }

    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long elapsed = System.currentTimeMillis() - start;
        System.out.println("Execution time: " + elapsed + "ms");
        return result;
    }
}

@Service
public class OrderService {

    @Transactional
    public void checkoutOrder(Order order) {
        saveOrderDetails(order);

        // SELF-INVOCATION TRAP: Bypasses the proxy wrapper!
        // REQUIRES_NEW on chargePayment() will be ignored.
        chargePayment(order);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void chargePayment(Order order) {
        // Payment logic
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface ProcessingService {
    void executeBusinessLogic() throws InterruptedException;
}

class ProcessingServiceImpl implements ProcessingService {
    @Override
    public void executeBusinessLogic() throws InterruptedException {
        Thread.sleep(250);
    }
}

class ProfilingInvocationHandler implements InvocationHandler {
    private final Object targetInstance;

    public ProfilingInvocationHandler(Object targetInstance) {
        this.targetInstance = targetInstance;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();
        Object result = method.invoke(targetInstance, args);
        long endTime = System.nanoTime();
        System.out.println("Execution of " + method.getName() + " took: " + (endTime - startTime) + " ns");
        return result;
    }
}

public class ProxyDemo {
    public static void main(String[] args) throws InterruptedException {
        ProcessingService realService = new ProcessingServiceImpl();

        ProcessingService proxyInstance = (ProcessingService) Proxy.newProxyInstance(
            ProcessingService.class.getClassLoader(),
            new Class<?>[]{ProcessingService.class},
            new ProfilingInvocationHandler(realService)
        );

        proxyInstance.executeBusinessLogic();
    }
}

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    @Autowired
    private EmployeeService service;

    @GetMapping
    public List<Employee> getAllEmployees() {
        return service.findAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Employee> getEmployeeById(@PathVariable Long id) {
        return service.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
}

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class SecurityInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String securityToken = request.getHeader("X-Security-Token");
        if (securityToken == null || !securityToken.equals("VALID_SYSTEM_TOKEN")) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // Post-processing
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // Cleanup
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LocaleChangeInterceptor());
        registry.addInterceptor(new ThemeChangeInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/admin/**");
        registry.addInterceptor(new SecurityInterceptor())
                .addPathPatterns("/secure/**");
    }
}

@ControllerAdvice
public class RestResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(value = { IllegalArgumentException.class, IllegalStateException.class })
    protected ResponseEntity<Object> handleConflict(RuntimeException ex, WebRequest request) {
        String bodyOfResponse = "Invalid request parameters.";
        return handleExceptionInternal(ex, bodyOfResponse, new HttpHeaders(), HttpStatus.CONFLICT, request);
    }
}

@ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "Resource does not exist.")
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

// 1. Login → generate JWT
SecretKey key = Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8));
String token = Jwts.builder()
    .subject(username)
    .expiration(new Date(System.currentTimeMillis() + 86400000))
    .signWith(key)
    .compact();

// 2. Validate JWT in filter
Claims claims = Jwts.parser()
    .verifyWith(key)
    .build()
    .parseSignedClaims(token)
    .getPayload();
String username = claims.getSubject();

// Header
{ "alg": "HS256", "typ": "JWT" }

// Payload
{
  "sub": "user123",
  "name": "John",
  "roles": ["ADMIN"],
  "iat": 1720000000,
  "exp": 1720086400
}

@Transactional(isolation = Isolation.REPEATABLE_READ)
public void performOperation() { ... }

// N+1: For each Order, a separate query fetches items
List<Order> orders = orderRepository.findAll(); // 1 query
orders.forEach(o -> o.getItems().size()); // N queries

@Query("SELECT o FROM Order o JOIN FETCH o.items")
List<Order> findAllWithItems();

@EntityGraph(attributePaths = {"items"})
List<Order> findAll();

@BatchSize(size = 20)
@OneToMany(fetch = FetchType.LAZY)
List<OrderItem> items;

@OneToMany(fetch = FetchType.LAZY)
@ManyToOne(fetch = FetchType.EAGER)

// LazyInitializationException fix: ensure access within transaction
@Transactional
public OrderDTO getOrder(Long id) {
    Order order = orderRepo.findById(id).get();
    order.getItems().size(); // safe — still in transaction
    return mapper.toDTO(order);
}

@Query(value = "SELECT * FROM employees WHERE department = :dept", nativeQuery = true)
List<Employee> findByDepartment(@Param("dept") String department);

@RestController
@RequestMapping("/api/v1/employees")
public class EmployeeController {

    @GetMapping
    public List<Employee> getAll() { return service.findAll(); }

    @GetMapping("/{id}")
    public ResponseEntity<Employee> getById(@PathVariable Long id) {
        return ResponseEntity.ok(service.findById(id));
    }

    @PostMapping
    public ResponseEntity<Employee> create(@RequestBody @Valid Employee emp) {
        Employee saved = service.save(emp);
        URI location = URI.create("/api/v1/employees/" + saved.getId());
        return ResponseEntity.created(location).body(saved);
    }

    @PutMapping("/{id}")
    public Employee update(@PathVariable Long id, @RequestBody Employee emp) {
        return service.update(id, emp);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        service.delete(id);
        return ResponseEntity.noContent().build();
    }
}

@Configuration
public class SwaggerConfig {
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
            .info(new Info().title("Employee API").version("1.0"));
    }
}

@Operation(summary = "Get employee by ID")
@ApiResponse(responseCode = "200", description = "Employee found")
@ApiResponse(responseCode = "404", description = "Not found")
@GetMapping("/{id}")
public Employee getById(@PathVariable Long id) { ... }

# Spring Cloud Gateway example
spring:
  cloud:
    gateway:
      routes:
        - id: employee-service
          uri: lb://EMPLOYEE-SERVICE
          predicates:
            - Path=/api/employees/**
          filters:
            - StripPrefix=1

// Eureka Server
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApp { public static void main(String[] args) { SpringApplication.run(...); } }

// Eureka Client (in each microservice)
@SpringBootApplication
@EnableEurekaClient
public class EmployeeServiceApp { ... }

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: employee-service

resilience4j:
  circuitbreaker:
    instances:
      inventoryService:
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10s
        permittedNumberOfCallsInHalfOpenState: 3

@CircuitBreaker(name = "inventoryService", fallbackMethod = "fallback")
public String callInventory(String productId) {
    return inventoryClient.check(productId);
}

public String fallback(String productId, Exception ex) {
    return "Product temporarily unavailable";
}

// Producer (requester)
@Autowired ReplyingKafkaTemplate<String, Request, Response> replyingTemplate;

RequestReplyFuture<String, Request, Response> future =
    replyingTemplate.sendAndReceive(new ProducerRecord<>("request-topic", request));

Response response = future.get(10, TimeUnit.SECONDS).value();

// Consumer (responder)
@KafkaListener(topics = "request-topic")
@SendTo("response-topic")
public Response handleRequest(Request request) {
    return process(request);
}

// Sending with Spring JMS
@Autowired JmsTemplate jmsTemplate;
jmsTemplate.convertAndSend("payment-queue", paymentRequest);

// Receiving
@JmsListener(destination = "payment-queue")
public void handlePayment(PaymentRequest request) {
    process(request);
}

# .github/workflows/ci.yml (simplified)
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build with Maven
        run: mvn -B package --file pom.xml
      - name: SonarQube Scan
        run: mvn sonar:sonar -Dsonar.host.url=$SONAR_URL
      - name: OWASP Dependency Check
        run: mvn org.owasp:dependency-check-maven:check
      - name: Build & Push Docker
        run: |
          docker build -t myapp:${{ github.sha }} .
          docker push myregistry/myapp:${{ github.sha }}

# Multi-stage Dockerfile for Spring Boot
FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

// Step 1: RED — write failing test
@Test
void shouldReturnTaxInclusivePrice() {
    PriceCalculator calc = new PriceCalculator();
    assertEquals(118.0, calc.priceWithTax(100.0), 0.001);
}

// Step 2: GREEN — minimal implementation
public class PriceCalculator {
    public double priceWithTax(double amount) {
        return amount * 1.18;
    }
}

// Step 3: REFACTOR — extract constant
public class PriceCalculator {
    private static final double TAX_RATE = 0.18;
    public double priceWithTax(double amount) {
        return amount * (1 + TAX_RATE);
    }
}

Feature: Price Calculation
  Scenario: Calculate price with tax
    Given a product price of 100.0
    When I calculate the tax-inclusive price
    Then the result should be 118.0

@ExtendWith(MockitoExtension.class)
class EmployeeServiceTest {

    @Mock
    EmployeeRepository repository;

    @InjectMocks
    EmployeeService service;

    @Test
    void shouldReturnEmployeeById() {
        Employee emp = new Employee(1L, "John");
        when(repository.findById(1L)).thenReturn(Optional.of(emp));

        Employee result = service.findById(1L);

        assertEquals("John", result.getName());
        verify(repository, times(1)).findById(1L);
    }

    @Test
    void shouldThrowWhenEmployeeNotFound() {
        when(repository.findById(99L)).thenReturn(Optional.empty());
        assertThrows(EmployeeNotFoundException.class, () -> service.findById(99L));
    }
}

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 5, 8, 13})
void shouldBePositive(int number) {
    assertTrue(number > 0);
}

@ParameterizedTest
@CsvSource({
    "100.0, 118.0",
    "200.0, 236.0",
    "0.0,   0.0"
})
void shouldCalculateTax(double input, double expected) {
    assertEquals(expected, calculator.priceWithTax(input), 0.001);
}

@ParameterizedTest
@MethodSource("provideEmployees")
void shouldValidateEmployee(Employee emp, boolean expected) {
    assertEquals(expected, validator.isValid(emp));
}

static Stream<Arguments> provideEmployees() {
    return Stream.of(
        Arguments.of(new Employee("John", 30), true),
        Arguments.of(new Employee("", 30), false)
    );
}

@SpringBootTest          // Full application context
@WebMvcTest              // Only MVC layer
@DataJpaTest             // Only JPA layer
@MockBean                // Replace a Spring bean with a mock