AOP

package at.aydin.lab.aop.legacy;

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

// Design Pattern: Proxy
// Zweck: Querschnittslogik wird vor und nach einem Methodenaufruf ausgeführt.
public final class LoggingProxy implements InvocationHandler {
    private final Object target;
    private LoggingProxy(Object target) {
        this.target = target;
    }

    public static <T> T wrap(Class<T> contract, T target) {
        Object proxy = Proxy.newProxyInstance(contract.getClassLoader(), new Class<?>[] {
            contract
        }, new LoggingProxy(target));
        return contract.cast(proxy);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long started = System.nanoTime();
        System.out.printf("START %s %s%n", method.getName(), Arrays.toString(args));
        try {
            return method.invoke(target, args);
        } finally {
            System.out.printf("ENDE %s %d µs%n", method.getName(), (System.nanoTime() - started) / 1_000);
        }
    }
}

package at.aydin.lab.aop.modern;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
// Design Pattern: Interceptor / Aspect
// Zweck: Monitoring bleibt getrennt von der Geschäftslogik.
public class TrackingAspect {
    @Around("@annotation(Tracked)")
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable {
        long started = System.nanoTime();
        try {
            return joinPoint.proceed();
        } finally {
            long micros = (System.nanoTime() - started) / 1_000;
            System.out.printf("%s dauerte %d µs%n", joinPoint.getSignature().toShortString(), micros);
        }
    }
}

package at.aydin.lab.aop.modern;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public
@interface
Tracked {
}

package at.aydin.lab.aop.legacy;

public final class SimpleCalculator implements Calculator {
    @Override
    public int add(int left, int right) {
        return left + right;
    }
}

package at.aydin.lab.aop.modern;

import org.springframework.stereotype.Service;

@Service
public class TrackedCalculator implements Calculator {
    @Override
    @Tracked
    public int add(int left, int right) {
        return left + right;
    }
}

package at.aydin.lab.aop.legacy;

public final class AopLegacyApplication {
    private AopLegacyApplication() {
    }

    public static void main(String[] args) {
        Calculator calculator = LoggingProxy.wrap(Calculator.class, new SimpleCalculator());
        System.out.println("Ergebnis: " + calculator.add(4, 7));
    }
}

package at.aydin.lab.aop.modern;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AopModernApplication {
    public static void main(String[] args) {
        SpringApplication.run(AopModernApplication.class, args);
    }
}

package at.aydin.lab.aop.modern;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class CalculatorRunner implements CommandLineRunner {
    private final Calculator calculator;
    public CalculatorRunner(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public void run(String ... args) {
        System.out.println("Ergebnis: " + calculator.add(4, 7));
    }
}