deps: Refactor dependencies (#3224)

* remove spring dep
move junit, logging, mockito under dep mgmt

* upgrade anti-corruption-layer deps

* async method invocation

* balking, bloc

* bridge to bytecode

* caching

* callback - cqrs

* component - health check

* hexagonal - metadata mapping

* rest of the patterns

* remove checkstyle, take spotless into use

twin/pom.xml

@@ -34,6 +34,14 @@
   </parent>
   <artifactId>twin</artifactId>
   <dependencies>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>ch.qos.logback</groupId>
+      <artifactId>logback-classic</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-engine</artifactId>

twin/src/main/java/com/iluwatar/twin/App.java

@@ -32,7 +32,6 @@ package com.iluwatar.twin;
  * BallThread} class represent the twin objects to coordinate with each other (via the twin
  * reference) like a single class inheriting from {@link GameItem} and {@link Thread}.
  */
-
 public class App {
 
   /**

twin/src/main/java/com/iluwatar/twin/BallItem.java

@@ -37,8 +37,7 @@ public class BallItem extends GameItem {
 
   private boolean isSuspended;
 
-  @Setter
-  private BallThread twin;
+  @Setter private BallThread twin;
 
   @Override
   public void doDraw() {
@@ -62,4 +61,3 @@ public class BallItem extends GameItem {
     }
   }
 }
-

twin/src/main/java/com/iluwatar/twin/BallThread.java

@@ -31,20 +31,16 @@ import lombok.extern.slf4j.Slf4j;
  * This class is a UI thread for drawing the {@link BallItem}, and provide the method for suspend
  * and resume. It holds the reference of {@link BallItem} to delegate the draw task.
  */
-
 @Slf4j
 public class BallThread extends Thread {
 
-  @Setter
-  private BallItem twin;
+  @Setter private BallItem twin;
 
   private volatile boolean isSuspended;
 
   private volatile boolean isRunning = true;
 
-  /**
-   * Run the thread.
-   */
+  /** Run the thread. */
   public void run() {
 
     while (isRunning) {
@@ -75,4 +71,3 @@ public class BallThread extends Thread {
     this.isSuspended = true;
   }
 }
-

twin/src/main/java/com/iluwatar/twin/GameItem.java

@@ -26,15 +26,11 @@ package com.iluwatar.twin;
 
 import lombok.extern.slf4j.Slf4j;
 
-/**
- * GameItem is a common class which provides some common methods for game object.
- */
+/** GameItem is a common class which provides some common methods for game object. */
 @Slf4j
 public abstract class GameItem {
 
-  /**
-   * Template method, do some common logic before draw.
-   */
+  /** Template method, do some common logic before draw. */
   public void draw() {
     LOGGER.info("draw");
     doDraw();
@@ -42,6 +38,5 @@ public abstract class GameItem {
 
   public abstract void doDraw();
 
-
   public abstract void click();
 }

twin/src/test/java/com/iluwatar/twin/AppTest.java

@@ -24,17 +24,15 @@
  */
 package com.iluwatar.twin;
 
-import org.junit.jupiter.api.Test;
-
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
-/**
- * Application test
- */
+import org.junit.jupiter.api.Test;
+
+/** Application test */
 class AppTest {
 
   @Test
   void shouldExecuteWithoutException() {
-    assertDoesNotThrow(() -> App.main(new String[]{}));
+    assertDoesNotThrow(() -> App.main(new String[] {}));
   }
 }

twin/src/test/java/com/iluwatar/twin/BallItemTest.java

@@ -41,10 +41,7 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 
-/**
- * BallItemTest
- *
- */
+/** BallItemTest */
 class BallItemTest {
 
   private InMemoryAppender appender;
@@ -67,12 +64,14 @@ class BallItemTest {
 
     final var inOrder = inOrder(ballThread);
 
-    IntStream.range(0, 10).forEach(i -> {
-      ballItem.click();
-      inOrder.verify(ballThread).suspendMe();
-      ballItem.click();
-      inOrder.verify(ballThread).resumeMe();
-    });
+    IntStream.range(0, 10)
+        .forEach(
+            i -> {
+              ballItem.click();
+              inOrder.verify(ballThread).suspendMe();
+              ballItem.click();
+              inOrder.verify(ballThread).resumeMe();
+            });
 
     inOrder.verifyNoMoreInteractions();
   }
@@ -104,9 +103,7 @@ class BallItemTest {
     assertEquals(1, appender.getLogSize());
   }
 
-  /**
-   * Logging Appender Implementation
-   */
+  /** Logging Appender Implementation */
   static class InMemoryAppender extends AppenderBase<ILoggingEvent> {
     private final List<ILoggingEvent> log = new LinkedList<>();
 
@@ -128,5 +125,4 @@ class BallItemTest {
       return log.size();
     }
   }
-
 }

twin/src/test/java/com/iluwatar/twin/BallThreadTest.java

@@ -37,84 +37,81 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import org.junit.jupiter.api.Test;
 
-/**
- * BallThreadTest
- *
- */
+/** BallThreadTest */
 class BallThreadTest {
 
-  /**
-   * Verify if the {@link BallThread} can be resumed
-   */
+  /** Verify if the {@link BallThread} can be resumed */
   @Test
   void testSuspend() {
-    assertTimeout(ofMillis(5000), () -> {
-      final var ballThread = new BallThread();
+    assertTimeout(
+        ofMillis(5000),
+        () -> {
+          final var ballThread = new BallThread();
 
-      final var ballItem = mock(BallItem.class);
-      ballThread.setTwin(ballItem);
+          final var ballItem = mock(BallItem.class);
+          ballThread.setTwin(ballItem);
 
-      ballThread.start();
-      sleep(200);
-      verify(ballItem, atLeastOnce()).draw();
-      verify(ballItem, atLeastOnce()).move();
-      ballThread.suspendMe();
+          ballThread.start();
+          sleep(200);
+          verify(ballItem, atLeastOnce()).draw();
+          verify(ballItem, atLeastOnce()).move();
+          ballThread.suspendMe();
 
-      sleep(1000);
+          sleep(1000);
 
-      ballThread.stopMe();
-      ballThread.join();
+          ballThread.stopMe();
+          ballThread.join();
 
-      verifyNoMoreInteractions(ballItem);
-    });
+          verifyNoMoreInteractions(ballItem);
+        });
   }
 
-  /**
-   * Verify if the {@link BallThread} can be resumed
-   */
+  /** Verify if the {@link BallThread} can be resumed */
   @Test
   void testResume() {
-    assertTimeout(ofMillis(5000), () -> {
-      final var ballThread = new BallThread();
+    assertTimeout(
+        ofMillis(5000),
+        () -> {
+          final var ballThread = new BallThread();
 
-      final var ballItem = mock(BallItem.class);
-      ballThread.setTwin(ballItem);
+          final var ballItem = mock(BallItem.class);
+          ballThread.setTwin(ballItem);
 
-      ballThread.suspendMe();
-      ballThread.start();
+          ballThread.suspendMe();
+          ballThread.start();
 
-      sleep(1000);
+          sleep(1000);
 
-      verifyNoMoreInteractions(ballItem);
+          verifyNoMoreInteractions(ballItem);
 
-      ballThread.resumeMe();
-      sleep(300);
-      verify(ballItem, atLeastOnce()).draw();
-      verify(ballItem, atLeastOnce()).move();
+          ballThread.resumeMe();
+          sleep(300);
+          verify(ballItem, atLeastOnce()).draw();
+          verify(ballItem, atLeastOnce()).move();
 
-      ballThread.stopMe();
-      ballThread.join();
+          ballThread.stopMe();
+          ballThread.join();
 
-      verifyNoMoreInteractions(ballItem);
-    });
+          verifyNoMoreInteractions(ballItem);
+        });
   }
 
-  /**
-   * Verify if the {@link BallThread} is interruptible
-   */
+  /** Verify if the {@link BallThread} is interruptible */
   @Test
   void testInterrupt() {
-    assertTimeout(ofMillis(5000), () -> {
-      final var ballThread = new BallThread();
-      final var exceptionHandler = mock(UncaughtExceptionHandler.class);
-      ballThread.setUncaughtExceptionHandler(exceptionHandler);
-      ballThread.setTwin(mock(BallItem.class));
-      ballThread.start();
-      ballThread.interrupt();
-      ballThread.join();
+    assertTimeout(
+        ofMillis(5000),
+        () -> {
+          final var ballThread = new BallThread();
+          final var exceptionHandler = mock(UncaughtExceptionHandler.class);
+          ballThread.setUncaughtExceptionHandler(exceptionHandler);
+          ballThread.setTwin(mock(BallItem.class));
+          ballThread.start();
+          ballThread.interrupt();
+          ballThread.join();
 
-      verify(exceptionHandler).uncaughtException(eq(ballThread), any(RuntimeException.class));
-      verifyNoMoreInteractions(exceptionHandler);
-    });
+          verify(exceptionHandler).uncaughtException(eq(ballThread), any(RuntimeException.class));
+          verifyNoMoreInteractions(exceptionHandler);
+        });
   }
-}
+}