Revert back to java 8

Author: alturkovic

README.adoc

@@ -3,7 +3,7 @@
 Distributed lock ensures your method cannot be run in parallel from multiple JVMs (cluster of servers, microservices, ...).
 It uses a common store to keep track of used locks and your method needs to acquire one or more locks to run.
 
-By default, locks follow methods lifecycle. They are obtained at the start of the method and released at the end of the method.
+By default, locks follow methods lifecycle.They are obtained at the start of the method and released at the end of the method.
 Manual controlling is supported and explained later in this document.
 
 All locks acquired by lock implementations in this project will expire after 10 seconds, timeout after 1 second if unable to acquire lock and sleep for 50 ms between retries.
@@ -19,9 +19,9 @@ This will import the configuration that will autoconfigure the
 
 Project provides the following out-of-the-box lock implementations:
 
- * JDBC
- * Mongo
- * Redis
+* JDBC
+* Mongo
+* Redis
 
 === JDBC locks
 
@@ -124,6 +124,10 @@ public class LockConfiguration {
 
 Started tracking the changes since 1.2.0 so no changelogs available for earlier versions.
 
+==== 1.4.0
+
+- CHANGE: Switched back to Java 1.8 from 11 since most projects don't yet use 11
+
 ==== 1.3.0
 
 - CHANGE: Updated Java from 1.8 to 11

distributed-lock-api/pom.xml

@@ -8,7 +8,7 @@
   <parent>
     <groupId>com.github.alturkovic</groupId>
     <artifactId>distributed-lock</artifactId>
-    <version>1.3.0</version>
+    <version>1.4.0</version>
   </parent>
 
   <artifactId>distributed-lock-api</artifactId>

distributed-lock-core/pom.xml

@@ -8,7 +8,7 @@
   <parent>
     <groupId>com.github.alturkovic</groupId>
     <artifactId>distributed-lock</artifactId>
-    <version>1.3.0</version>
+    <version>1.4.0</version>
   </parent>
 
   <artifactId>distributed-lock-core</artifactId>

distributed-lock-core/src/main/java/com/github/alturkovic/lock/AbstractSimpleLock.java

@@ -41,7 +41,7 @@ public abstract class AbstractSimpleLock implements Lock {
   public String acquire(final List<String> keys, final String storeId, final long expiration) {
     Assert.isTrue(keys.size() == 1, "Cannot acquire lock for multiple keys with this lock");
 
-    final var token = tokenSupplier.get();
+    final String token = tokenSupplier.get();
     if (StringUtils.isEmpty(token)) {
       throw new IllegalStateException("Cannot lock with empty token");
     }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/advice/LockBeanPostProcessor.java

@@ -29,6 +29,7 @@
 import com.github.alturkovic.lock.key.KeyGenerator;
 import com.github.alturkovic.lock.retry.RetriableLockFactory;
 import lombok.AllArgsConstructor;
+import org.aopalliance.intercept.Interceptor;
 import org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor;
 import org.springframework.aop.support.DefaultPointcutAdvisor;
 import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;
@@ -48,8 +49,8 @@ public class LockBeanPostProcessor extends AbstractAdvisingBeanPostProcessor imp
 
   @Override
   public void afterPropertiesSet() {
-    final var pointcut = new AnnotationMatchingPointcut(null, Locked.class, true);
-    final var interceptor = new LockMethodInterceptor(keyGenerator, lockTypeResolver, intervalConverter, retriableLockFactory, taskScheduler);
+    final AnnotationMatchingPointcut pointcut = new AnnotationMatchingPointcut(null, Locked.class, true);
+    final Interceptor interceptor = new LockMethodInterceptor(keyGenerator, lockTypeResolver, intervalConverter, retriableLockFactory, taskScheduler);
 
     this.advisor = new DefaultPointcutAdvisor(pointcut, interceptor);
   }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/advice/LockMethodInterceptor.java

@@ -54,7 +54,7 @@ public class LockMethodInterceptor implements MethodInterceptor {
 
   @Override
   public Object invoke(final MethodInvocation invocation) throws Throwable {
-    final var context = new LockContext(invocation);
+    final LockContext context = new LockContext(invocation);
     try {
       return executeLockedMethod(invocation, context);
     } finally {
@@ -63,7 +63,7 @@ public Object invoke(final MethodInvocation invocation) throws Throwable {
   }
 
   private Object executeLockedMethod(final MethodInvocation invocation, final LockContext context) throws Throwable {
-    final var expiration = intervalConverter.toMillis(context.getLocked().expiration());
+    final long expiration = intervalConverter.toMillis(context.getLocked().expiration());
     try {
       context.setToken(retriableLockFactory.generate(context.getLock(), context.getLocked()).acquire(context.getKeys(), context.getLocked().storeId(), expiration));
     } catch (final Exception e) {
@@ -77,7 +77,7 @@ private Object executeLockedMethod(final MethodInvocation invocation, final Lock
   }
 
   private void scheduleLockRefresh(final LockContext context, final long expiration) {
-    final var refresh = intervalConverter.toMillis(context.getLocked().refresh());
+    final long refresh = intervalConverter.toMillis(context.getLocked().refresh());
     if (refresh > 0) {
       context.setScheduledFuture(taskScheduler.scheduleAtFixedRate(constructRefreshRunnable(context, expiration), refresh));
     }
@@ -88,13 +88,13 @@ private Runnable constructRefreshRunnable(final LockContext context, final long
   }
 
   private void cleanAfterExecution(final LockContext context) {
-    final var scheduledFuture = context.getScheduledFuture();
+    final ScheduledFuture<?> scheduledFuture = context.getScheduledFuture();
     if (scheduledFuture != null && !scheduledFuture.isCancelled() && !scheduledFuture.isDone()) {
       scheduledFuture.cancel(true);
     }
 
     if (StringUtils.hasText(context.getToken()) && !context.getLocked().manuallyReleased()) {
-      final var released = context.getLock().release(context.getKeys(), context.getLocked().storeId(), context.getToken());
+      final boolean released = context.getLock().release(context.getKeys(), context.getLocked().storeId(), context.getToken());
       if (released) {
         log.debug("Released lock for keys {} with token {} in store {}", context.getKeys(), context.getToken(), context.getLocked().storeId());
       } else {

distributed-lock-core/src/main/java/com/github/alturkovic/lock/configuration/DistributedLockConfiguration.java

@@ -54,7 +54,7 @@ public LockBeanPostProcessor lockBeanPostProcessor(final KeyGenerator keyGenerat
                                                      final IntervalConverter intervalConverter,
                                                      final RetriableLockFactory retriableLockFactory,
                                                      @Autowired(required = false) final TaskScheduler taskScheduler) {
-    final var processor = new LockBeanPostProcessor(keyGenerator, configurableBeanFactory::getBean, intervalConverter, retriableLockFactory, taskScheduler);
+    final LockBeanPostProcessor processor = new LockBeanPostProcessor(keyGenerator, configurableBeanFactory::getBean, intervalConverter, retriableLockFactory, taskScheduler);
     processor.setBeforeExistingAdvisors(true);
     return processor;
   }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/interval/BeanFactoryAwareIntervalConverter.java

@@ -42,7 +42,7 @@ public long toMillis(final Interval interval) {
   }
 
   private String resolveMilliseconds(final Interval interval) {
-    final var value = beanFactory.resolveEmbeddedValue(interval.value());
+    final String value = beanFactory.resolveEmbeddedValue(interval.value());
     if (!StringUtils.hasText(value)) {
       throw new IllegalArgumentException("Cannot convert interval " + interval + " to milliseconds");
     }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/key/SpelKeyGenerator.java

@@ -27,6 +27,7 @@
 import com.github.alturkovic.lock.exception.EvaluationConvertException;
 import java.lang.reflect.Method;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -47,9 +48,8 @@
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class SpelKeyGenerator extends CachedExpressionEvaluator implements KeyGenerator {
-  private final ConversionService conversionService;
   private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<>();
-  private final Map<AnnotatedElementKey, Method> targetMethodCache = new ConcurrentHashMap<>();
+  private final ConversionService conversionService;
 
   @Override
   public List<String> resolveKeys(final String lockKeyPrefix, final String expression, final Object object, final Method method, final Object[] args) {
@@ -74,7 +74,7 @@ protected List<String> convertResultToList(final Object expressionValue) {
     } else if (expressionValue.getClass().isArray()) {
       list = arrayToList(expressionValue);
     } else {
-      list = List.of(expressionValue.toString());
+      list = Collections.singletonList(expressionValue.toString());
     }
 
     if (CollectionUtils.isEmpty(list)) {
@@ -99,17 +99,17 @@ private Object evaluateExpression(final String expression, final Object object,
 
   private List<String> iterableToList(final Object expressionValue) {
     final TypeDescriptor genericCollection = TypeDescriptor.collection(Collection.class, TypeDescriptor.valueOf(Object.class));
-    final TypeDescriptor stringList = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
-
-    //noinspection unchecked
-    return (List<String>) conversionService.convert(expressionValue, genericCollection, stringList);
+    return toList(expressionValue, genericCollection);
   }
 
   private List<String> arrayToList(final Object expressionValue) {
     final TypeDescriptor genericArray = TypeDescriptor.array(TypeDescriptor.valueOf(Object.class));
-    final TypeDescriptor stringList = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
+    return toList(expressionValue, genericArray);
+  }
 
+  private List<String> toList(final Object expressionValue, final TypeDescriptor from) {
+    final TypeDescriptor listTypeDescriptor = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
     //noinspection unchecked
-    return (List<String>) conversionService.convert(expressionValue, genericArray, stringList);
+    return (List<String>) conversionService.convert(expressionValue, from, listTypeDescriptor);
   }
 }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/retry/DefaultRetryTemplateConverter.java

@@ -27,7 +27,7 @@
 import com.github.alturkovic.lock.Locked;
 import com.github.alturkovic.lock.exception.LockNotAvailableException;
 import com.github.alturkovic.lock.interval.IntervalConverter;
-import java.util.Map;
+import java.util.Collections;
 import lombok.Data;
 import org.springframework.retry.RetryPolicy;
 import org.springframework.retry.backoff.FixedBackOffPolicy;
@@ -42,34 +42,34 @@ public class DefaultRetryTemplateConverter implements RetryTemplateConverter {
 
   @Override
   public RetryTemplate construct(final Locked locked) {
-    final var retryTemplate = new RetryTemplate();
+    final RetryTemplate retryTemplate = new RetryTemplate();
     retryTemplate.setRetryPolicy(resolveLockRetryPolicy(locked));
     retryTemplate.setBackOffPolicy(resolveBackOffPolicy(locked));
     return retryTemplate;
   }
 
   private CompositeRetryPolicy resolveLockRetryPolicy(final Locked locked) {
-    final var compositeRetryPolicy = new CompositeRetryPolicy();
+    final CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();
 
-    final var timeoutRetryPolicy = resolveTimeoutRetryPolicy(locked);
-    final var exceptionTypeRetryPolicy = resolveExceptionTypeRetryPolicy();
+    final RetryPolicy timeoutRetryPolicy = resolveTimeoutRetryPolicy(locked);
+    final RetryPolicy exceptionTypeRetryPolicy = resolveExceptionTypeRetryPolicy();
 
     compositeRetryPolicy.setPolicies(new RetryPolicy[]{timeoutRetryPolicy, exceptionTypeRetryPolicy});
     return compositeRetryPolicy;
   }
 
   private RetryPolicy resolveTimeoutRetryPolicy(final Locked locked) {
-    final var timeoutRetryPolicy = new TimeoutRetryPolicy();
+    final TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy();
     timeoutRetryPolicy.setTimeout(intervalConverter.toMillis(locked.timeout()));
     return timeoutRetryPolicy;
   }
 
   private RetryPolicy resolveExceptionTypeRetryPolicy() {
-    return new SimpleRetryPolicy(Integer.MAX_VALUE, Map.of(LockNotAvailableException.class, true));
+    return new SimpleRetryPolicy(Integer.MAX_VALUE, Collections.singletonMap(LockNotAvailableException.class, true));
   }
 
   private FixedBackOffPolicy resolveBackOffPolicy(final Locked locked) {
-    final var fixedBackOffPolicy = new FixedBackOffPolicy();
+    final FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
     fixedBackOffPolicy.setBackOffPeriod(intervalConverter.toMillis(locked.retry()));
     return fixedBackOffPolicy;
   }