BAEL-9439 Update pom.xml

core-java-modules/core-java-lang-oop-patterns-2/pom.xml

@@ -12,6 +12,10 @@
         <groupId>com.baeldung.core-java-modules</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
+
+    <properties>
+        <logback.configurationFileName>logback.xml</logback.configurationFileName>
+    </properties>
 
     <dependencies>
         <dependency>
@@ -24,6 +28,27 @@
             <artifactId>jackson-databind</artifactId>
             <version>${jackson.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>2.0.7</version>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>1.4.11</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-aop</artifactId>
+            <version>6.0.11</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>6.0.11</version>
+        </dependency>
     </dependencies>
 
-</project>
+</project>

core-java-modules/core-java-lang-oop-patterns-2/src/main/java/com/baeldung/overridemethod/Calculator.java

@@ -0,0 +1,6 @@
+package com.baeldung.overridemethod;
+
+public interface Calculator {
+    int add(int a, int b);
+    int subtract(int a, int b);
+}

core-java-modules/core-java-lang-oop-patterns-2/src/main/java/com/baeldung/overridemethod/SimpleCalculator.java

@@ -0,0 +1,20 @@
+package com.baeldung.overridemethod;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SimpleCalculator implements Calculator {
+    private static final Logger log = LoggerFactory.getLogger(SimpleCalculator.class);
+
+    @Override
+    public int add(int a, int b) {
+        log.info("SimpleCalculator: Adding {} and {}", a, b); // Use parameterized logging {}
+        return a + b;
+    }
+
+    @Override
+    public int subtract(int a, int b) {
+        log.info("SimpleCalculator: Subtracting {} from {}", b, a);
+        return a - b;
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/main/java/com/baeldung/overridemethod/decorator/MeteredCalculatorDecorator.java

@@ -0,0 +1,37 @@
+package com.baeldung.overridemethod.decorator;
+
+import com.baeldung.overridemethod.Calculator;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MeteredCalculatorDecorator implements Calculator {
+    private final Calculator wrappedCalculator;
+    private final Map<String, Integer> methodCalls;
+
+    public MeteredCalculatorDecorator(Calculator calculator) {
+        this.wrappedCalculator = calculator;
+        this.methodCalls = new HashMap<>();
+        // Initialize counts for clarity
+        methodCalls.put("add", 0);
+        methodCalls.put("subtract", 0);
+    }
+
+    @Override
+    public int add(int a, int b) {
+        // Track the call count
+        methodCalls.merge("add", 1, Integer::sum);
+        return wrappedCalculator.add(a, b); // Delegation
+    }
+
+    @Override
+    public int subtract(int a, int b) {
+        // Track the call count
+        methodCalls.merge("subtract", 1, Integer::sum);
+        return wrappedCalculator.subtract(a, b); // Delegation
+    }
+
+    // Public method to expose the call counts for testing
+    public int getCallCount(String methodName) {
+        return methodCalls.getOrDefault(methodName, 0);
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/main/java/com/baeldung/overridemethod/proxy/jdk/LoggingInvocationHandler.java

@@ -0,0 +1,27 @@
+package com.baeldung.overridemethod.proxy.jdk;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LoggingInvocationHandler implements InvocationHandler {
+    private static final Logger log = LoggerFactory.getLogger(LoggingInvocationHandler.class);
+    private final Object target;
+
+    public LoggingInvocationHandler(Object target) {
+        this.target = target;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+
+        log.debug("PROXY LOG: Intercepting method: {}", method.getName());
+
+        Object result = method.invoke(target, args);
+
+        log.debug("PROXY LOG: Method {} executed.", method.getName());
+
+        return result;
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/main/java/com/baeldung/overridemethod/proxy/spring/LoggingMethodInterceptor.java

@@ -0,0 +1,22 @@
+package com.baeldung.overridemethod.proxy.spring;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LoggingMethodInterceptor implements MethodInterceptor {
+    private static final Logger log = LoggerFactory.getLogger(LoggingMethodInterceptor.class);
+
+    @Override
+    public Object invoke(MethodInvocation invocation) throws Throwable {
+
+        log.debug("SPRING PROXY: Intercepting method: {}", invocation.getMethod().getName());
+
+        Object result = invocation.proceed();
+
+        log.debug("SPRING PROXY: Method {} completed.", invocation.getMethod().getName());
+
+        return result;
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/main/java/com/baeldung/overridemethod/subclass/LoggingCalculator.java

@@ -0,0 +1,25 @@
+package com.baeldung.overridemethod.subclass;
+
+import com.baeldung.overridemethod.SimpleCalculator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LoggingCalculator extends SimpleCalculator {
+    private static final Logger log = LoggerFactory.getLogger(LoggingCalculator.class);
+
+    @Override
+    public int add(int a, int b) {
+        log.debug("LOG: Before addition.");
+        int result = super.add(a, b);
+        log.debug("LOG: After addition. Result: {}", result);
+        return result;
+    }
+
+    @Override
+    public int subtract(int a, int b) {
+        log.debug("LOG: Before subtraction.");
+        int result = super.subtract(a, b);
+        log.debug("LOG: After subtraction. Result: {}", result);
+        return result;
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/main/resources/logback.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+    <logger name="com.baeldung.overridemethod" level="DEBUG" additivity="false">
+        <appender-ref ref="STDOUT"/>
+    </logger>
+
+</configuration>

core-java-modules/core-java-lang-oop-patterns-2/src/test/java/com/baeldung/overridemethod/decorator/DecoratorPatternTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.overridemethod.decorator;
+
+import com.baeldung.overridemethod.Calculator;
+import com.baeldung.overridemethod.SimpleCalculator;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class DecoratorPatternTest {
+
+    @Test
+    void givenACalculator_whenUsingMeteredDecorator_thenMethodCallsAreCountedCorrectly() {
+        // ARRANGE
+        Calculator simpleCalc = new SimpleCalculator();
+
+        // Use the MeteredCalculatorDecorator decorator
+        MeteredCalculatorDecorator decoratedCalc = new MeteredCalculatorDecorator(simpleCalc);
+
+        // ACT
+        // Call add twice
+        decoratedCalc.add(10, 5);
+        decoratedCalc.add(2, 3);
+
+        // Call subtract once
+        decoratedCalc.subtract(10, 5);
+
+        // ASSERT Core Functionality (optional, but good practice)
+        assertEquals(15, decoratedCalc.add(10, 5), "Core functionality must still work.");
+
+        // ASSERT the call counts
+        // 1. Assert 'add' was called 3 times (2 from ACT + 1 from ASSERT Core)
+        assertEquals(3, decoratedCalc.getCallCount("add"), "The 'add' method should have been called 3 times.");
+
+        // 2. Assert 'subtract' was called 1 time
+        assertEquals(1, decoratedCalc.getCallCount("subtract"), "The 'subtract' method should have been called 1 time.");
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/test/java/com/baeldung/overridemethod/proxy/jdk/DynamicProxyTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.overridemethod.proxy.jdk;
+
+import com.baeldung.overridemethod.Calculator;
+import com.baeldung.overridemethod.SimpleCalculator;
+import org.junit.jupiter.api.Test;
+import java.lang.reflect.Proxy;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class DynamicProxyTest {
+
+    @Test
+    void givenACalculator_whenUsingJdkDynamicProxy_thenJdkDynamicProxyCanBeUsed() {
+        Calculator simpleCalc = new SimpleCalculator();
+        LoggingInvocationHandler handler = new LoggingInvocationHandler(simpleCalc);
+
+        Calculator proxyCalc = (Calculator) Proxy.newProxyInstance(
+            Calculator.class.getClassLoader(),
+            new Class<?>[] { Calculator.class },
+            handler
+        );
+
+        assertEquals(30, proxyCalc.add(20, 10));
+        assertEquals(10, proxyCalc.subtract(20, 10));
+    }
+}
+

core-java-modules/core-java-lang-oop-patterns-2/src/test/java/com/baeldung/overridemethod/proxy/spring/SpringProxyFactoryTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.overridemethod.proxy.spring;
+
+import com.baeldung.overridemethod.Calculator;
+import com.baeldung.overridemethod.SimpleCalculator;
+import org.junit.jupiter.api.Test;
+import org.springframework.aop.framework.ProxyFactory;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class SpringProxyFactoryTest {
+
+    @Test
+    void givenACalculator_whenUsingSpringProxyFactory_thenSpringProxyFactoryCanBeUsed() {
+        SimpleCalculator simpleCalc = new SimpleCalculator();
+        ProxyFactory factory = new ProxyFactory();
+
+        factory.setTarget(simpleCalc);
+        factory.addAdvice(new LoggingMethodInterceptor());
+
+        Calculator proxyCalc = (Calculator) factory.getProxy();
+
+        assertEquals(60, proxyCalc.add(50, 10));
+        assertEquals(40, proxyCalc.subtract(50, 10));
+    }
+}

core-java-modules/core-java-lang-oop-patterns-2/src/test/java/com/baeldung/overridemethod/subclass/SubclassingTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.overridemethod.subclass;
+
+import com.baeldung.overridemethod.Calculator;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class SubclassingTest {
+
+    @Test
+    void givenACalculatorClass_whenSubclassingToAddLogging_thenLoggingCalculatorCanBeUsed() {
+        Calculator calculator = new LoggingCalculator();
+        assertEquals(8, calculator.add(5, 3));
+        assertEquals(2, calculator.subtract(5, 3));
+    }
+}