перенос pool фабрик в модуль utils

utils/build.gradle

@@ -1 +1,5 @@
 apply from: rootDir.toPath().resolve('logic.gradle').toFile()
+
+dependencies {
+    implementation libs.objpool
+}

utils/src/main/java/mc/utils/pool/MultiObjectPool.java

@@ -0,0 +1,8 @@
+package mc.utils.pool;
+
+public interface MultiObjectPool<T> {
+
+	<P extends T> P borrowObject(Class<P> clazz);
+
+	<P extends T> void returnObject(P object);
+}

utils/src/main/java/mc/utils/pool/ObjectPool.java

@@ -0,0 +1,8 @@
+package mc.utils.pool;
+
+public interface ObjectPool<T> {
+
+	T borrowObject();
+
+	void returnObject(T object);
+}

utils/src/main/java/mc/utils/pool/Passivable.java

@@ -0,0 +1,6 @@
+package mc.utils.pool;
+
+public interface Passivable {
+
+	void passivate();
+}

utils/src/main/java/mc/utils/pool/PassivableMultiObjectPool.java

@@ -0,0 +1,27 @@
+package mc.utils.pool;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PassivableMultiObjectPool<T extends Passivable> implements MultiObjectPool<T> {
+
+	@SuppressWarnings("rawtypes")
+	private final Map<Class, ObjectPool> mapPool = new HashMap<>();
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public <P extends T> P borrowObject(Class<P> clazz) {
+		return (P) pool(clazz).borrowObject();
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public <P extends T> void returnObject(P object) {
+		pool(object.getClass()).returnObject(object);
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked", "RedundantSuppression" })
+	private ObjectPool pool(Class clazz) {
+		return mapPool.computeIfAbsent(clazz, PassivableObjectPool::new);
+	}
+}

utils/src/main/java/mc/utils/pool/PassivableObjectPool.java

@@ -0,0 +1,27 @@
+package mc.utils.pool;
+
+import lombok.SneakyThrows;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+
+import javax.annotation.Nonnull;
+
+public class PassivableObjectPool<T extends Passivable> implements ObjectPool<T> {
+
+	private final org.apache.commons.pool2.ObjectPool<T> apacheObjectPool;
+
+	public PassivableObjectPool(@Nonnull Class<T> clazz) {
+		apacheObjectPool = new GenericObjectPool<>(new PassivablePooledObjectFactory<>(clazz));
+	}
+
+	@Override
+	@SneakyThrows
+	public T borrowObject() {
+		return apacheObjectPool.borrowObject();
+	}
+
+	@Override
+	@SneakyThrows
+	public void returnObject(T object) {
+		apacheObjectPool.returnObject(object);
+	}
+}

utils/src/main/java/mc/utils/pool/PassivablePooledObjectFactory.java

@@ -0,0 +1,15 @@
+package mc.utils.pool;
+
+import org.apache.commons.pool2.PooledObject;
+
+class PassivablePooledObjectFactory<T extends Passivable> extends SimplePooledObjectFactory<T> {
+
+	PassivablePooledObjectFactory(Class<T> clazz) {
+		super(clazz);
+	}
+
+	@Override
+	public void passivateObject(PooledObject<T> pooledObject) {
+		pooledObject.getObject().passivate();
+	}
+}

utils/src/main/java/mc/utils/pool/SimpleObjectPool.java

@@ -0,0 +1,27 @@
+package mc.utils.pool;
+
+import lombok.SneakyThrows;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+
+import javax.annotation.Nonnull;
+
+public class SimpleObjectPool<T> implements ObjectPool<T> {
+
+	private final org.apache.commons.pool2.ObjectPool<T> apacheObjectPool;
+
+	public SimpleObjectPool(@Nonnull Class<T> clazz) {
+		apacheObjectPool = new GenericObjectPool<>(new SimplePooledObjectFactory<>(clazz));
+	}
+
+	@Override
+	@SneakyThrows
+	public T borrowObject() {
+		return apacheObjectPool.borrowObject();
+	}
+
+	@Override
+	@SneakyThrows
+	public void returnObject(T object) {
+		apacheObjectPool.returnObject(object);
+	}
+}

utils/src/main/java/mc/utils/pool/SimplePooledObjectFactory.java

@@ -0,0 +1,22 @@
+package mc.utils.pool;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.pool2.BasePooledObjectFactory;
+import org.apache.commons.pool2.PooledObject;
+import org.apache.commons.pool2.impl.DefaultPooledObject;
+
+@RequiredArgsConstructor
+class SimplePooledObjectFactory<T> extends BasePooledObjectFactory<T> {
+
+	private final Class<T> clazz;
+
+	@Override
+	public T create() throws Exception {
+		return clazz.getDeclaredConstructor().newInstance();
+	}
+
+	@Override
+	public PooledObject<T> wrap(T obj) {
+		return new DefaultPooledObject<>(obj);
+	}
+}