Merge branch 'wip/aspect2' into jakarta-master

Author: rbygrave

blackbox-test-inject/pom.xml

@@ -5,7 +5,7 @@
   <parent>
     <artifactId>avaje-inject-parent</artifactId>
     <groupId>io.avaje</groupId>
-    <version>6.17</version>
+    <version>6.18-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
@@ -24,6 +24,18 @@
       <version>${project.version}</version>
     </dependency>
 
+    <dependency>
+      <groupId>io.github.resilience4j</groupId>
+      <artifactId>resilience4j-retry</artifactId>
+      <version>1.7.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.github.resilience4j</groupId>
+      <artifactId>resilience4j-annotations</artifactId>
+      <version>1.7.1</version>
+    </dependency>
+
     <!-- annotation processor -->
     <dependency>
       <groupId>io.avaje</groupId>

blackbox-test-inject/src/main/java/org/example/myapp/ExampleService.java

@@ -0,0 +1,25 @@
+package org.example.myapp;
+
+import jakarta.inject.Singleton;
+import org.example.myapp.aspect.MyTimed;
+
+import java.io.IOException;
+
+@MyTimed
+@Singleton
+public class ExampleService {
+
+  final HelloService helloService;
+
+  public ExampleService(HelloService helloService) {
+    this.helloService = helloService;
+  }
+
+  public String other(String param0, int param1) {//} throws IOException, IllegalStateException {
+    return "other " + param0 + " " + param1;
+  }
+
+  public void runOnly(String param) {
+    System.out.println("runOnly "+param);
+  }
+}

blackbox-test-inject/src/main/java/org/example/myapp/HelloService.java

@@ -1,17 +1,97 @@
 package org.example.myapp;
 
+import io.avaje.inject.PostConstruct;
+import io.avaje.inject.PreDestroy;
 import jakarta.inject.Singleton;
+import org.example.myapp.aspect.*;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
 
 @Singleton
 public class HelloService {
 
   private final HelloData data;
 
+  private int counter;
+  private String justRunResult;
+
   HelloService(HelloData data) {
     this.data = data;
   }
 
   public String hello() {
     return "hello+" + data.helloData();
   }
+
+  @MySkip
+  public String skipExample(String p0) {
+    // this is never called due to MySkip aspect
+    return p0;
+  }
+
+  @MyMultiInvoke
+  int counter() {
+    return counter++;
+  }
+
+  @MyBefore
+  public String foo(String param, int overloaded) {
+    return "foo+" + param;
+  }
+
+  @MyBefore
+  public String foo(String param) {
+    return "foo+" + param;
+  }
+
+  @MyAround(name="what")
+  public String bazz(String param0, int param1) throws IOException {
+    System.out.println("execute bazz ...");
+    return "bazz " + param0 + " " + param1;
+  }
+
+  @MyAround
+  public void justRun(String param0, int param1, int param2) throws IOException, ClassNotFoundException, UncheckedIOException {
+    System.out.println("justRun ...");
+    justRunResult = param0+" "+param1+" "+param2;
+  }
+
+  @MyThrowing
+  public void thisWillThrow() {
+    System.out.println("this just never gets called");
+    throw new IllegalCallerException("never happens");
+  }
+
+  @MyAround
+  public void appCodeThrowsUnchecked() {
+    throw new IllegalArgumentException("appCodeUnchecked");
+  }
+
+  /**
+   * Declared exception is NOT wrapped in InvocationException
+   */
+  @MyAround
+  public void appCodeThrowsDeclared() throws IllegalArgumentException {
+    throw new IllegalArgumentException("appCodeDeclared");
+  }
+
+  public void multiAspectsHere() {
+
+  }
+
+
+  public String justRunResult() {
+    return justRunResult;
+  }
+
+  @PostConstruct
+  void postCon() {
+
+  }
+
+  @PreDestroy
+  void preDest() {
+
+  }
 }

blackbox-test-inject/src/main/java/org/example/myapp/HelloServiceProxy.java

@@ -0,0 +1,58 @@
+package org.example.myapp;
+
+import io.avaje.inject.aop.MethodInterceptor;
+import io.avaje.inject.aop.Invocation;
+import org.example.myapp.aspect.MyAround;
+import org.example.myapp.aspect.MyAroundAspect;
+import org.example.myapp.aspect.MyBeforeAspect;
+
+import java.lang.reflect.Method;
+
+//@Proxy
+//@Singleton
+public class HelloServiceProxy extends HelloService {
+
+  final MyBeforeAspect aspect;
+  final MyAroundAspect aroundAspect;
+  private final Method fooMethod;
+  private final Method bazzMethod;
+  private final MyAround myArround;
+  private final MethodInterceptor bazzInterceptor;
+
+  public HelloServiceProxy(HelloData data, MyBeforeAspect aspect, MyAroundAspect aroundAspect) {
+    super(data);
+    this.aspect = aspect;
+    this.aroundAspect = aroundAspect;
+    try {
+      fooMethod = HelloService.class.getDeclaredMethod("foo", String.class);
+      bazzMethod = HelloService.class.getDeclaredMethod("bazz", String.class, int.class);
+      myArround = bazzMethod.getAnnotation(MyAround.class);
+
+
+      bazzInterceptor = aroundAspect.interceptor(bazzMethod, myArround);
+
+    } catch (Exception e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
+  @Override
+  public String foo(String param) {
+    //aspect.beforeInvoke(fooMethod);
+    return super.foo(param);
+  }
+
+  @Override
+  public String bazz(String param0, int param1) {
+    var call = new Invocation.Call<>(() -> super.bazz(param0, param1))
+      .with(this, bazzMethod, param0, param1);
+    try {
+      bazzInterceptor.invoke(call);
+      //aroundAspect.around3(call);
+      return call.finalResult();
+    } catch (Throwable e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+}

blackbox-test-inject/src/main/java/org/example/myapp/OtherService.java

@@ -0,0 +1,24 @@
+package org.example.myapp;
+
+import jakarta.inject.Singleton;
+import org.example.myapp.aspect.MyAround;
+import org.example.myapp.aspect.MyTimed;
+
+@Singleton
+public class OtherService {
+
+  @MyAround
+  public String other(String param0, int param1) {
+    return "other " + param0 + " " + param1;
+  }
+
+  @MyAround
+  @MyTimed
+  public void multi() {
+    System.out.println("sdsd");
+  }
+
+  public void notAopWrapped() {
+    System.out.println("just a normal method");
+  }
+}

blackbox-test-inject/src/main/java/org/example/myapp/aspect/MyAround.java

@@ -0,0 +1,16 @@
+package org.example.myapp.aspect;
+
+import io.avaje.inject.aop.Aspect;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Aspect(target = MyAroundAspect.class)
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyAround {
+
+  String name() default "";
+}

blackbox-test-inject/src/main/java/org/example/myapp/aspect/MyAroundAspect.java

@@ -0,0 +1,44 @@
+package org.example.myapp.aspect;
+
+import io.avaje.inject.aop.AspectProvider;
+import io.avaje.inject.aop.Invocation;
+import io.avaje.inject.aop.MethodInterceptor;
+import jakarta.inject.Singleton;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Singleton
+//@Aspect(target = MyAround.class)
+public class MyAroundAspect implements AspectProvider<MyAround>, MethodInterceptor {
+
+  private final List<String> trace = new ArrayList<>();
+
+  @Override
+  public MethodInterceptor interceptor(Method method, MyAround around) {
+    return this;
+  }
+
+  @Override
+  public void invoke(Invocation invoke) throws Throwable {
+    TraceAspect.add("MyAroundAspect-begin");
+    trace.add(invoke.method().getName() + " args:" + Arrays.toString(invoke.arguments()));
+    System.out.println("before args: " + Arrays.toString(invoke.arguments()) + " method: " + invoke.method());
+    try {
+      invoke.invoke();
+      invoke.invoke();
+      invoke.invoke();
+    } finally {
+      System.out.println("after");
+      TraceAspect.add("MyAroundAspect-end");
+    }
+  }
+
+  public List<String> trace() {
+    ArrayList<String> copy = new ArrayList<>(trace);
+    trace.clear();
+    return copy;
+  }
+}

blackbox-test-inject/src/main/java/org/example/myapp/aspect/MyBefore.java

@@ -0,0 +1,16 @@
+package org.example.myapp.aspect;
+
+import io.avaje.inject.aop.Aspect;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Aspect(target = MyBeforeAspect.class)
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyBefore {
+
+
+}

blackbox-test-inject/src/main/java/org/example/myapp/aspect/MyBeforeAspect.java

@@ -0,0 +1,33 @@
+package org.example.myapp.aspect;
+
+import io.avaje.inject.aop.AspectProvider;
+import io.avaje.inject.aop.Invocation;
+import io.avaje.inject.aop.MethodInterceptor;
+import jakarta.inject.Singleton;
+
+import java.lang.reflect.Method;
+
+@Singleton
+public class MyBeforeAspect implements AspectProvider<MyBefore> {
+
+  @Override
+  public MethodInterceptor interceptor(Method method, MyBefore aspectAnnotation) {
+    return new Intercept(method);
+  }
+
+  static final class Intercept implements MethodInterceptor {
+    final Method method;
+
+    Intercept(Method method) {
+      this.method = method;
+    }
+
+    @Override
+    public void invoke(Invocation invocation) throws Throwable {
+      if (method.getName().equals("foo")) {
+        throw new IllegalStateException("Can't call this method");
+      }
+    }
+  }
+
+}

blackbox-test-inject/src/main/java/org/example/myapp/aspect/MyMultiInvoke.java

@@ -0,0 +1,14 @@
+package org.example.myapp.aspect;
+
+import io.avaje.inject.aop.Aspect;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Aspect(target = MyMultiInvokeAspect.class)
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyMultiInvoke {
+}