рефакторинг DI

protocol/src/main/java/mc/protocol/NettyServer.java

@@ -13,15 +13,14 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import mc.protocol.api.ConnectionContext;
 import mc.protocol.api.Server;
+import mc.protocol.event.EventBus;
 import mc.protocol.io.codec.ProtocolDecoder;
 import mc.protocol.io.codec.ProtocolEncoder;
 import mc.protocol.io.codec.ProtocolSplitter;
 import mc.protocol.packets.ClientSidePacket;
-import mc.protocol.event.EventBus;
-import mc.protocol.pool.PacketPool;
-import org.apache.commons.pool2.ObjectPool;
 
 import javax.annotation.Nonnull;
+import javax.inject.Provider;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.function.Consumer;
@@ -30,8 +29,8 @@ import java.util.function.Consumer;
 @RequiredArgsConstructor
 public class NettyServer implements Server {
 
-	private final ObjectPool<NettyConnectionContext> poolNettyConnectionContext;
-	private final PacketPool packetPool;
+	private final Provider<ProtocolDecoder> protocolDecoderProvider;
+	private final Provider<PacketInboundHandler> packetInboundHandlerProvider;
 	private final EventBus eventBus;
 	private Consumer<ConnectionContext> consumerNewConnection;
 	private Consumer<ConnectionContext> consumerDisconnect;
@@ -90,9 +89,14 @@ public class NettyServer implements Server {
 
 		map.put("packet_splitter", new ProtocolSplitter());
 		map.put("logger", new LoggingHandler(LogLevel.DEBUG));
-		map.put("packet_decoder", new ProtocolDecoder(true, poolNettyConnectionContext, packetPool, consumerNewConnection, consumerDisconnect));
+
+		ProtocolDecoder protocolDecoder = protocolDecoderProvider.get();
+		protocolDecoder.setConsumerNewConnection(consumerNewConnection);
+		protocolDecoder.setConsumerDisconnect(consumerDisconnect);
+		map.put("packet_decoder", protocolDecoder);
+
 		map.put("packet_encoder", new ProtocolEncoder());
-		map.put("packet_handler", new PacketInboundHandler(poolNettyConnectionContext, packetPool, eventBus));
+		map.put("packet_handler", packetInboundHandlerProvider.get());
 
 		return map;
 	}

protocol/src/main/java/mc/protocol/di/PoolModule.java

@@ -0,0 +1,42 @@
+package mc.protocol.di;
+
+import dagger.Module;
+import dagger.Provides;
+import mc.protocol.NettyConnectionContext;
+import mc.protocol.State;
+import mc.protocol.packets.ClientSidePacket;
+import mc.protocol.packets.UnknownPacket;
+import mc.protocol.pool.NettyConnectionContextFactory;
+import mc.protocol.pool.PacketFactory;
+import mc.protocol.pool.PacketPool;
+import org.apache.commons.pool2.ObjectPool;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Module
+public class PoolModule {
+
+	@Provides
+	@ServerScope
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	PacketPool providePacketPool() {
+		Map<Class<? extends ClientSidePacket>, ObjectPool> map = Stream.of(State.values())
+				.flatMap(state -> state.getClientSidePackets().values().stream())
+				.distinct()
+				.collect(Collectors.toMap(
+						packetClass -> packetClass,
+						packetClass -> new GenericObjectPool(new PacketFactory<>(packetClass))));
+		map.put(UnknownPacket.class, new GenericObjectPool(new PacketFactory<>(UnknownPacket.class)));
+
+		return new PacketPool(map);
+	}
+
+	@Provides
+	@ServerScope
+	ObjectPool<NettyConnectionContext> providePoolNettyConnectionContext() {
+		return new GenericObjectPool<>(new NettyConnectionContextFactory());
+	}
+}

protocol/src/main/java/mc/protocol/di/ProtocolComponent.java

@@ -3,7 +3,10 @@ package mc.protocol.di;
 import dagger.Component;
 import mc.protocol.api.Server;
 
-@Component(modules = ProtocolModule.class)
+@Component(modules = {
+		ProtocolModule.class,
+		PoolModule.class
+})
 @ServerScope
 public interface ProtocolComponent {
 

protocol/src/main/java/mc/protocol/di/ProtocolModule.java

@@ -2,46 +2,52 @@ package mc.protocol.di;
 
 import dagger.Module;
 import dagger.Provides;
+import lombok.RequiredArgsConstructor;
 import mc.protocol.NettyConnectionContext;
 import mc.protocol.NettyServer;
-import mc.protocol.State;
+import mc.protocol.PacketInboundHandler;
 import mc.protocol.api.Server;
-import mc.protocol.packets.ClientSidePacket;
-import mc.protocol.packets.UnknownPacket;
 import mc.protocol.event.EventBus;
-import mc.protocol.pool.NettyConnectionContextFactory;
-import mc.protocol.pool.PacketFactory;
-import mc.protocol.pool.PacketPool;
 import mc.protocol.event.SimpleEventBus;
+import mc.protocol.io.codec.ProtocolDecoder;
+import mc.protocol.pool.PacketPool;
 import org.apache.commons.pool2.ObjectPool;
-import org.apache.commons.pool2.impl.GenericObjectPool;
 
-import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+import javax.inject.Provider;
 
 @Module
+@RequiredArgsConstructor
 public class ProtocolModule {
 
+	private final boolean readUnknownPackets;
+
 	@Provides
 	@ServerScope
-	Server provideServer(ObjectPool<NettyConnectionContext> poolNettyConnectionContext, PacketPool packetPool, EventBus eventBus) {
-		return new NettyServer(poolNettyConnectionContext, packetPool, eventBus);
+	Server provideServer(
+			Provider<ProtocolDecoder> protocolDecoderProvider,
+			Provider<PacketInboundHandler> packetInboundHandlerProvider,
+			EventBus eventBus
+	) {
+		return new NettyServer(protocolDecoderProvider, packetInboundHandlerProvider, eventBus);
 	}
 
 	@Provides
 	@ServerScope
-	@SuppressWarnings({ "rawtypes", "unchecked" })
-	PacketPool providePacketPool() {
-		Map<Class<? extends ClientSidePacket>, ObjectPool> map = Stream.of(State.values())
-				.flatMap(state -> state.getClientSidePackets().values().stream())
-				.distinct()
-				.collect(Collectors.toMap(
-						packetClass -> packetClass,
-						packetClass -> new GenericObjectPool(new PacketFactory<>(packetClass))));
-		map.put(UnknownPacket.class, new GenericObjectPool(new PacketFactory<>(UnknownPacket.class)));
+	ProtocolDecoder provideProtocolDecoder(
+			ObjectPool<NettyConnectionContext> poolNettyConnectionContext,
+			PacketPool poolPackets
+	) {
+		return new ProtocolDecoder(readUnknownPackets, poolNettyConnectionContext, poolPackets);
+	}
 
-		return new PacketPool(map);
+	@Provides
+	@ServerScope
+	PacketInboundHandler providePacketInboundHandler(
+			ObjectPool<NettyConnectionContext> poolNettyConnectionContext,
+			PacketPool packetPool,
+			EventBus eventBus
+	) {
+		return new PacketInboundHandler(poolNettyConnectionContext, packetPool, eventBus);
 	}
 
 	@Provides
@@ -50,9 +56,4 @@ public class ProtocolModule {
 		return new SimpleEventBus();
 	}
 
-	@Provides
-	@ServerScope
-	ObjectPool<NettyConnectionContext> providePoolNettyConnectionContext() {
-		return new GenericObjectPool<>(new NettyConnectionContextFactory());
-	}
 }

protocol/src/main/java/mc/protocol/io/codec/ProtocolDecoder.java

@@ -4,6 +4,7 @@ import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
 import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import mc.protocol.NettyConnectionContext;
 import mc.protocol.NetworkAttributes;
@@ -27,8 +28,11 @@ public class ProtocolDecoder extends ByteToMessageDecoder {
 	private final boolean readUnknownPackets;
 	private final ObjectPool<NettyConnectionContext> poolNettyConnectionContext;
 	private final PacketPool poolPackets;
-	private final Consumer<ConnectionContext> consumerNewConnection;
-	private final Consumer<ConnectionContext> consumerDisconnect;
+
+	@Setter
+	private Consumer<ConnectionContext> consumerNewConnection;
+	@Setter
+	private Consumer<ConnectionContext> consumerDisconnect;
 
 	@Override
 	public void channelActive(@Nonnull ChannelHandlerContext ctx) throws Exception {