Recurso reusável

src/main/java/br/com/softsite/pstmtnullsafe/resource/ReuseLastPool.java

+package br.com.softsite.pstmtnullsafe.resource;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+public class ReuseLastPool<K, T> implements Pool<K, T> {
+
+	private final Function<K, T> resourceGetter;
+	private final HashMap<K, Agrupamento<T>> agrupamentos = new HashMap<>();
+	private K lastKey;
+	private final HashSet<K> keys = new HashSet<>();
+	private ReusableResourceWrapper<T> lastResource;
+
+	public ReuseLastPool(Function<K, T> resourceGetter) {
+		this.resourceGetter = resourceGetter;
+	}
+
+	@Override
+	public ResourceWrapper<T> getResource(K key) {
+		if (lastKey != null && key.equals(lastKey)) {
+			return lastResource;
+		}
+		lastKey = key;
+		keys.add(key);
+		Agrupamento<T> agrupamento = agrupamentos.computeIfAbsent(key, __ -> new Agrupamento<>());
+		lastResource = agrupamento.getElemento(() -> resourceGetter.apply(key));
+		return lastResource;
+	}
+
+	@Override
+	public List<ResourceWrapper<T>> getAllResources() {
+		return agrupamentos.values().stream()
+				.flatMap(agrup -> agrup.elementos.stream())
+				.collect(Collectors.toList());
+	}
+
+	@Override
+	public List<ResourceWrapper<T>> getAllocatedResources() {
+		return agrupamentos.entrySet().stream()
+				.filter(es -> keys.contains(es.getKey()))
+				.map(Entry::getValue)
+				.flatMap(agrup -> agrup.elementos.stream())
+				.filter(r -> r.used)
+				.collect(Collectors.toList());
+	}
+
+	@Override
+	public void releaseAll() {
+		agrupamentos.values()
+			.stream()
+			.forEach(Agrupamento::reset);
+	}
+
+	private static class Agrupamento<T> {
+		private int livres;
+		private final ArrayList<ReusableResourceWrapper<T>> elementos = new ArrayList<>();
+
+		void add(ReusableResourceWrapper<T> e) {
+			elementos.add(e);
+		}
+
+		void reset() {
+			livres = elementos.size();
+			elementos.forEach(ReusableResourceWrapper::release);
+		}
+
+		ReusableResourceWrapper<T> getElemento(Supplier<T> lazyGenerator) {
+			if (livres != 0) {
+				for (ReusableResourceWrapper<T> e: elementos) {
+					if (!e.used) {
+						e.used = true;
+						livres--;
+						return e;
+					}
+				}
+			}
+			T wrapped = lazyGenerator.get();
+			ReusableResourceWrapper<T> e = new ReusableResourceWrapper<>(wrapped);
+			add(e);
+			return e;
+		}
+	}
+
+	private static class ReusableResourceWrapper<T> implements ResourceWrapper<T> {
+
+		private final T value;
+		boolean used;
+
+		private ReusableResourceWrapper(T value) {
+			this.value = value;
+			this.used = true; // quando cria um recurso, a priori ele tá sendo usado
+		}
+
+		@Override
+		public T getWrapped() {
+			return value;
+		}
+
+		@Override
+		public void release() {
+			used = false;
+		}
+	}
+}