Switch to JDBI 3

pom.xml

@@ -64,7 +64,9 @@
         <maven.gpg.plugin.version>1.6</maven.gpg.plugin.version>
 
         <!--Application-->
-        <dropwizard.jdbi.version>1.3.29</dropwizard.jdbi.version>
+        <dropwizard.jdbi.version>2.0.22</dropwizard.jdbi.version>
+        <com.google.guava.version>30.1.1-jre</com.google.guava.version>
+        <org.apache.commons.version>3.12.0</org.apache.commons.version>
         <org.reflections.version>0.9.12</org.reflections.version>
         <mockito.core.version>3.9.0</mockito.core.version>
         <junit.version>4.13.2</junit.version>
@@ -82,10 +84,22 @@
     <dependencies>
         <dependency>
             <groupId>io.dropwizard</groupId>
-            <artifactId>dropwizard-jdbi</artifactId>
+            <artifactId>dropwizard-jdbi3</artifactId>
             <version>${dropwizard.jdbi.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${com.google.guava.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${org.apache.commons.version}</version>
+        </dependency>
+
         <dependency>
             <groupId>org.reflections</groupId>
             <artifactId>reflections</artifactId>
@@ -276,4 +290,4 @@
             </build>
         </profile>
     </profiles>
-</project>
+</project>

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/JdbiUnitOfWork.java

@@ -32,4 +32,4 @@
 @Retention(RUNTIME)
 @Documented
 public @interface JdbiUnitOfWork {
-}
+}

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/core/DefaultJdbiHandleManager.java

@@ -13,8 +13,8 @@
  */
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
-import org.skife.jdbi.v2.DBI;
-import org.skife.jdbi.v2.Handle;
+import org.jdbi.v3.core.Handle;
+import org.jdbi.v3.core.Jdbi;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -32,15 +32,15 @@
 public class DefaultJdbiHandleManager implements JdbiHandleManager {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultJdbiHandleManager.class);
-    private final DBI dbi;
+    private final Jdbi jdbi;
 
-    public DefaultJdbiHandleManager(DBI dbi) {
-        this.dbi = dbi;
+    public DefaultJdbiHandleManager(Jdbi jdbi) {
+        this.jdbi = jdbi;
     }
 
     @Override
     public Handle get() {
-        Handle handle = dbi.open();
+        Handle handle = jdbi.open();
         log.debug("handle [{}] : Thread Id [{}]", handle.hashCode(), Thread.currentThread().getId());
         return handle;
     }
@@ -49,4 +49,4 @@ public Handle get() {
     public void clear() {
         log.debug("No Op");
     }
-}
+}

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/core/JdbiHandleManager.java

@@ -13,10 +13,10 @@
  */
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
-import org.skife.jdbi.v2.Handle;
-
 import java.util.concurrent.ThreadFactory;
 
+import org.jdbi.v3.core.Handle;
+
 /**
  * A {@link JdbiHandleManager} is used to provide the lifecycle of a {@link Handle} with respect
  * to a given scope. A scope may be session based, request based or may be invoked on every run.
@@ -65,4 +65,4 @@ default ThreadFactory createThreadFactory() {
     default String getConversationId() {
         return String.valueOf(Thread.currentThread().getId());
     }
-}
+}

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/core/JdbiTransactionAspect.java

@@ -13,7 +13,7 @@
  */
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
-import org.skife.jdbi.v2.Handle;
+import org.jdbi.v3.core.Handle;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -84,4 +84,4 @@ public void terminateHandle() {
             handle = null;
         }
     }
-}
+}

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/core/LinkedRequestScopedJdbiHandleManager.java

@@ -15,8 +15,8 @@
 
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import org.apache.commons.lang3.StringUtils;
-import org.skife.jdbi.v2.DBI;
-import org.skife.jdbi.v2.Handle;
+import org.jdbi.v3.core.Handle;
+import org.jdbi.v3.core.Jdbi;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -46,10 +46,10 @@ public class LinkedRequestScopedJdbiHandleManager implements JdbiHandleManager {
     private static final Logger log = LoggerFactory.getLogger(LinkedRequestScopedJdbiHandleManager.class);
     private static final String NAME_FORMAT = "[%s]-%%d";
     private final Map<String, Handle> parentThreadHandleMap = new ConcurrentHashMap<>();
-    private final DBI dbi;
+    private final Jdbi jdbi;
 
-    public LinkedRequestScopedJdbiHandleManager(DBI dbi) {
-        this.dbi = dbi;
+    public LinkedRequestScopedJdbiHandleManager(Jdbi jdbi) {
+        this.jdbi = jdbi;
     }
 
     @Override
@@ -94,8 +94,8 @@ private Handle getHandle() {
         if (parentThreadHandleMap.containsKey(threadIdentity)) {
             return parentThreadHandleMap.get(threadIdentity);
         }
-        Handle handle = dbi.open();
+        Handle handle = jdbi.open();
         parentThreadHandleMap.putIfAbsent(threadIdentity, handle);
         return handle;
     }
-}
+}

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/core/ManagedHandleInvocationHandler.java

@@ -13,7 +13,7 @@
  */
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
-import org.skife.jdbi.v2.Handle;
+import org.jdbi.v3.core.Handle;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -73,4 +73,4 @@ private Object handleInvocation(Method method, Object[] args) throws IllegalAcce
     public String toString() {
         return "Proxy[" + underlying.getSimpleName() + "]";
     }
-}
+}

src/main/java/com/github/isopropylcyanide/jdbiunitofwork/core/RequestScopedJdbiHandleManager.java

@@ -13,8 +13,8 @@
  */
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
-import org.skife.jdbi.v2.DBI;
-import org.skife.jdbi.v2.Handle;
+import org.jdbi.v3.core.Handle;
+import org.jdbi.v3.core.Jdbi;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -30,17 +30,17 @@
 public class RequestScopedJdbiHandleManager implements JdbiHandleManager {
 
     private static final Logger log = LoggerFactory.getLogger(RequestScopedJdbiHandleManager.class);
-    private final DBI dbi;
+    private final Jdbi jdbi;
     private final ThreadLocal<Handle> threadLocal = new ThreadLocal<>();
 
-    public RequestScopedJdbiHandleManager(DBI dbi) {
-        this.dbi = dbi;
+    public RequestScopedJdbiHandleManager(Jdbi jdbi) {
+        this.jdbi = jdbi;
     }
 
     @Override
     public Handle get() {
         if (threadLocal.get() == null) {
-            threadLocal.set(dbi.open());
+            threadLocal.set(jdbi.open());
         }
         Handle handle = threadLocal.get();
         log.debug("handle [{}] : Thread Id [{}]", handle.hashCode(), Thread.currentThread().getId());
@@ -58,4 +58,4 @@ public void clear() {
             log.debug("Clearing handle member for thread [{}] ", Thread.currentThread().getId());
         }
     }
-}
+}

src/test/java/com/github/isopropylcyanide/jdbiunitofwork/core/DefaultJdbiHandleManagerTest.java

@@ -1,10 +1,10 @@
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
+import org.jdbi.v3.core.Handle;
+import org.jdbi.v3.core.Jdbi;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.stubbing.Answer;
-import org.skife.jdbi.v2.DBI;
-import org.skife.jdbi.v2.Handle;
 
 import static org.junit.Assert.assertNotEquals;
 import static org.mockito.Mockito.mock;
@@ -15,33 +15,33 @@
 
 public class DefaultJdbiHandleManagerTest {
 
-    private DBI dbi;
+    private Jdbi jdbi;
 
     private DefaultJdbiHandleManager manager;
 
     @Before
     public void setUp() {
-        dbi = mock(DBI.class);
-        this.manager = new DefaultJdbiHandleManager(dbi);
+        jdbi = mock(Jdbi.class);
+        this.manager = new DefaultJdbiHandleManager(jdbi);
     }
 
     @Test
     public void testGetSetsTheHandlePerInvocation() throws InterruptedException {
-        when(dbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
+        when(jdbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
         Handle firstHandle = manager.get();
         Handle secondHandle = manager.get();
         assertNotEquals(firstHandle, secondHandle);
 
         Thread newHandleInvokerThread = new Thread(() -> assertNotEquals(firstHandle, manager.get()));
         newHandleInvokerThread.start();
         newHandleInvokerThread.join();
-        verify(dbi, times(3)).open();
+        verify(jdbi, times(3)).open();
     }
 
     @Test
     public void testClear() {
         manager.clear();
-        verify(dbi, never()).open();
+        verify(jdbi, never()).open();
     }
 
     @Test(expected = UnsupportedOperationException.class)

src/test/java/com/github/isopropylcyanide/jdbiunitofwork/core/JdbiTransactionAspectTest.java

@@ -1,8 +1,8 @@
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
+import org.jdbi.v3.core.Handle;
 import org.junit.Before;
 import org.junit.Test;
-import org.skife.jdbi.v2.Handle;
 
 import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.doReturn;

src/test/java/com/github/isopropylcyanide/jdbiunitofwork/core/LinkedRequestScopedJdbiHandleManagerTest.java

@@ -1,10 +1,10 @@
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
+import org.jdbi.v3.core.Handle;
+import org.jdbi.v3.core.Jdbi;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.stubbing.Answer;
-import org.skife.jdbi.v2.DBI;
-import org.skife.jdbi.v2.Handle;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
@@ -21,40 +21,40 @@
 
 public class LinkedRequestScopedJdbiHandleManagerTest {
 
-    private DBI dbi;
+    private Jdbi jdbi;
 
     private LinkedRequestScopedJdbiHandleManager manager;
 
     @Before
     public void setUp() {
-        dbi = mock(DBI.class);
-        this.manager = new LinkedRequestScopedJdbiHandleManager(dbi);
+        jdbi = mock(Jdbi.class);
+        this.manager = new LinkedRequestScopedJdbiHandleManager(jdbi);
     }
 
     @Test
     public void testGetSetsSameHandleForMultipleInvocationsInSameThread() {
-        when(dbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
+        when(jdbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
         Handle firstHandle = manager.get();
         Handle secondHandle = manager.get();
         assertEquals(firstHandle, secondHandle);
 
-        verify(dbi, times(1)).open();
+        verify(jdbi, times(1)).open();
     }
 
     @Test
     public void testGetSetsNewHandleForEachThread() throws InterruptedException {
-        when(dbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
+        when(jdbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
         Handle handleThreadA = manager.get();
 
         Thread newHandleInvokerThread = new Thread(() -> assertNotEquals(handleThreadA, manager.get()));
         newHandleInvokerThread.start();
         newHandleInvokerThread.join();
-        verify(dbi, times(2)).open();
+        verify(jdbi, times(2)).open();
     }
 
     @Test
     public void testGetSetsSameHandleForChildThreadsIfTheThreadFactoryIsPlaced() throws InterruptedException {
-        when(dbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
+        when(jdbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
         Handle parentHandle = manager.get();
         ThreadFactory threadFactory = manager.createThreadFactory();
 
@@ -71,12 +71,12 @@ public void testGetSetsSameHandleForChildThreadsIfTheThreadFactoryIsPlaced() thr
         }
         service.shutdown();
         endGate.await();
-        verify(dbi, times(1)).open();
+        verify(jdbi, times(1)).open();
     }
 
     @Test
     public void testGetSetsNewHandleForChildThreadsIfTheThreadFactoryIsNotPlaced() throws InterruptedException {
-        when(dbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
+        when(jdbi.open()).thenAnswer((Answer<Handle>) invocation -> mock(Handle.class));
         Handle parentHandle = manager.get();
 
         final int NUM_THREADS = 5;
@@ -92,23 +92,23 @@ public void testGetSetsNewHandleForChildThreadsIfTheThreadFactoryIsNotPlaced() t
         }
         service.shutdown();
         endGate.await();
-        verify(dbi, times(NUM_THREADS + 1)).open();
+        verify(jdbi, times(NUM_THREADS + 1)).open();
     }
 
     @Test
     public void testClearClosesHandleAndClearsHandle() {
         Handle mockHandle = mock(Handle.class);
-        when(dbi.open()).thenReturn(mockHandle);
+        when(jdbi.open()).thenReturn(mockHandle);
 
         manager.get();
         manager.clear();
-        verify(dbi, times(1)).open();
+        verify(jdbi, times(1)).open();
         verify(mockHandle, times(1)).close();
     }
 
     @Test
     public void testClearDoesNothingWhenHandleIsNull() {
         manager.clear();
-        verify(dbi, never()).open();
+        verify(jdbi, never()).open();
     }
 }

src/test/java/com/github/isopropylcyanide/jdbiunitofwork/core/ManagedHandleInvocationHandlerTest.java

@@ -1,9 +1,9 @@
 package com.github.isopropylcyanide.jdbiunitofwork.core;
 
 import com.google.common.reflect.Reflection;
+import org.jdbi.v3.core.Handle;
 import org.junit.Before;
 import org.junit.Test;
-import org.skife.jdbi.v2.Handle;
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;