refactoring object pool

protocol/src/main/java/mc/protocol/packets/play/server/ChunkDataPacket.java

@@ -4,8 +4,8 @@ import io.netty.buffer.Unpooled;
 import lombok.Data;
 import mc.protocol.buffer.NetByteBuf;
 import mc.protocol.packets.ServerSidePacket;
+import mc.protocol.pool.ObjectPool;
 import mc.protocol.pool.ProtocolObjectPool;
-import mc.protocol.pool.SneakyObjectPool;
 
 /**
  * Данные чанка.
@@ -80,7 +80,7 @@ public class ChunkDataPacket implements ServerSidePacket {
 	}
 
 	static {
-		SneakyObjectPool<NetByteBuf> pool = ProtocolObjectPool.getNetByteBufPool();
+		ObjectPool<NetByteBuf> pool = ProtocolObjectPool.getNetByteBufPool();
 
 		voidData = pool.borrowObject().setByteBuf(Unpooled.buffer());
 		voidData.writeBoolean(true); // Is Full chunk

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

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

protocol/src/main/java/mc/protocol/pool/MultiPassivateObjectPool.java

@@ -1,28 +0,0 @@
-package mc.protocol.pool;
-
-import org.apache.commons.pool2.ObjectPool;
-import org.apache.commons.pool2.impl.GenericObjectPool;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class MultiPassivateObjectPool<T extends Passivable> {
-
-	@SuppressWarnings("rawtypes")
-	private final Map<Class, ObjectPool> mapPool = new HashMap<>();
-
-	@SuppressWarnings("unchecked")
-	public <P extends T> P borrowObject(Class<P> clazz) throws Exception {
-		return (P) pool(clazz).borrowObject();
-	}
-
-	@SuppressWarnings("unchecked")
-	public <P extends T> void returnObject(P obj) throws Exception {
-		pool(obj.getClass()).returnObject(obj);
-	}
-
-	@SuppressWarnings({ "rawtypes", "unchecked" })
-	private ObjectPool pool(Class clazz) {
-		return mapPool.computeIfAbsent(clazz, tClass -> new GenericObjectPool(new PassivatePooledObjectFactory(clazz)));
-	}
-}

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

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

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

@@ -0,0 +1,27 @@
+package mc.protocol.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);
+	}
+}

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

@@ -0,0 +1,27 @@
+package mc.protocol.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);
+	}
+}

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

@@ -2,9 +2,9 @@ package mc.protocol.pool;
 
 import org.apache.commons.pool2.PooledObject;
 
-public class PassivatePooledObjectFactory<T extends Passivable> extends SimplePooledObjectFactory<T> {
+class PassivablePooledObjectFactory<T extends Passivable> extends SimplePooledObjectFactory<T> {
 
-	public PassivatePooledObjectFactory(Class<T> clazz) {
+	PassivablePooledObjectFactory(Class<T> clazz) {
 		super(clazz);
 	}
 

protocol/src/main/java/mc/protocol/pool/ProtocolObjectPool.java

@@ -1,26 +1,25 @@
 package mc.protocol.pool;
 
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import mc.protocol.buffer.NetByteBuf;
 import mc.protocol.model.Location;
 import mc.protocol.model.Look;
 import mc.protocol.packets.ClientSidePacket;
 
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class ProtocolObjectPool {
 
 	@Getter
-	private static final SneakyObjectPool<Location> locationPool = new SneakyObjectPool<>(new SimplePooledObjectFactory<>(Location.class));
+	private static final ObjectPool<Location> locationPool = new SimpleObjectPool<>(Location.class);
 
 	@Getter
-	private static final SneakyObjectPool<Look> lookPool = new SneakyObjectPool<>(new SimplePooledObjectFactory<>(Look.class));
+	private static final ObjectPool<Look> lookPool = new SimpleObjectPool<>(Look.class);
 
 	@Getter
-	private static final SneakyObjectPool<NetByteBuf> netByteBufPool = new SneakyObjectPool<>(new PassivatePooledObjectFactory<>(NetByteBuf.class));
+	private static final ObjectPool<NetByteBuf> netByteBufPool = new PassivableObjectPool<>(NetByteBuf.class);
 
 	@Getter
-	private static final MultiPassivateObjectPool<ClientSidePacket> packetPool = new MultiPassivateObjectPool<>();
+	private static final MultiObjectPool<ClientSidePacket> packetPool = new PassivableMultiObjectPool<>();
-
-	private ProtocolObjectPool() {
-		throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
-	}
 }

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

@@ -0,0 +1,27 @@
+package mc.protocol.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);
+	}
+}

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

@@ -6,7 +6,7 @@ import org.apache.commons.pool2.PooledObject;
 import org.apache.commons.pool2.impl.DefaultPooledObject;
 
 @RequiredArgsConstructor
-public class SimplePooledObjectFactory<T> extends BasePooledObjectFactory<T> {
+class SimplePooledObjectFactory<T> extends BasePooledObjectFactory<T> {
 
 	private final Class<T> clazz;
 

protocol/src/main/java/mc/protocol/pool/SneakyObjectPool.java

@@ -1,18 +0,0 @@
-package mc.protocol.pool;
-
-import lombok.SneakyThrows;
-import org.apache.commons.pool2.PooledObjectFactory;
-import org.apache.commons.pool2.impl.GenericObjectPool;
-
-public class SneakyObjectPool<T> extends GenericObjectPool<T> {
-
-	public SneakyObjectPool(PooledObjectFactory<T> factory) {
-		super(factory);
-	}
-
-	@Override
-	@SneakyThrows
-	public T borrowObject() {
-		return super.borrowObject();
-	}
-}