JAVA-2378: Segregate Netty dependency from MongoClients to avoid a runtime dependency on Netty for applications that don't require it

Author: jyemin

driver-async/src/main/com/mongodb/async/client/MongoClients.java

@@ -29,20 +29,16 @@
 import com.mongodb.connection.SslSettings;
 import com.mongodb.connection.StreamFactory;
 import com.mongodb.connection.StreamFactoryFactory;
-import com.mongodb.connection.netty.NettyStreamFactory;
 import com.mongodb.event.CommandEventMulticaster;
 import com.mongodb.event.CommandListener;
 import com.mongodb.management.JMXConnectionPoolListener;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.nio.NioEventLoopGroup;
 import org.bson.codecs.BsonValueCodecProvider;
 import org.bson.codecs.DocumentCodecProvider;
 import org.bson.codecs.IterableCodecProvider;
 import org.bson.codecs.ValueCodecProvider;
 import org.bson.codecs.configuration.CodecRegistry;
 
 import java.io.Closeable;
-import java.io.IOException;
 import java.util.List;
 
 import static java.util.Arrays.asList;
@@ -94,7 +90,7 @@ public static MongoClient create(final String connectionString) {
      * </p>
      * <p>
      * The connection string's stream type is then applied by setting the
-     * {@link com.mongodb.connection.StreamFactory} to an instance of {@link NettyStreamFactory},
+     * {@link com.mongodb.connection.StreamFactory} to an instance of NettyStreamFactory,
      * </p>
      *
      * @param connectionString the settings
@@ -175,21 +171,28 @@ public static MongoClient create(final ConnectionString connectionString, final
     private static MongoClient create(final MongoClientSettings settings, final MongoDriverInformation mongoDriverInformation,
                                       final String requestedStreamType) {
         String streamType = getStreamType(requestedStreamType);
-        EventLoopGroup eventLoopGroup = getEventLoopGroupIfNecessary(settings.getStreamFactoryFactory(), streamType);
-        StreamFactory streamFactory = getStreamFactory(settings.getStreamFactoryFactory(), settings.getSocketSettings(),
-                settings.getSslSettings(), streamType, eventLoopGroup);
-        StreamFactory heartbeatStreamFactory = getStreamFactory(settings.getStreamFactoryFactory(), settings.getHeartbeatSocketSettings(),
-                settings.getSslSettings(), streamType, eventLoopGroup);
+        if (isNetty(streamType) && settings.getStreamFactoryFactory() == null) {
+            return NettyMongoClients.create(settings, mongoDriverInformation);
+        } else {
+            StreamFactory streamFactory = getStreamFactory(settings.getStreamFactoryFactory(), settings.getSocketSettings(),
+                    settings.getSslSettings(), streamType);
+            StreamFactory heartbeatStreamFactory = getStreamFactory(settings.getStreamFactoryFactory(),
+                    settings.getHeartbeatSocketSettings(), settings.getSslSettings(), streamType);
+            return createMongoClient(settings, mongoDriverInformation, streamFactory, heartbeatStreamFactory, null);
+        }
+    }
+
+    static MongoClient createMongoClient(final MongoClientSettings settings, final MongoDriverInformation mongoDriverInformation,
+                                         final StreamFactory streamFactory, final StreamFactory heartbeatStreamFactory,
+                                         final Closeable externalResourceCloser) {
         return new MongoClientImpl(settings, new DefaultClusterFactory().create(settings.getClusterSettings(), settings.getServerSettings(),
                 settings.getConnectionPoolSettings(), streamFactory,
                 heartbeatStreamFactory,
                 settings.getCredentialList(), null, new JMXConnectionPoolListener(), null,
                 createCommandListener(settings.getCommandListeners()),
-                settings.getApplicationName(), mongoDriverInformation),
-                                          getEventLoopGroupCloser(eventLoopGroup));
+                settings.getApplicationName(), mongoDriverInformation), externalResourceCloser);
     }
 
-
     /**
      * Gets the default codec registry.  It includes the following providers:
      *
@@ -218,11 +221,9 @@ public static CodecRegistry getDefaultCodecRegistry() {
 
     private static StreamFactory getStreamFactory(final StreamFactoryFactory streamFactoryFactory,
                                                   final SocketSettings socketSettings, final SslSettings sslSettings,
-                                                  final String streamType, final EventLoopGroup eventLoopGroup) {
+                                                  final String streamType) {
         if (streamFactoryFactory != null) {
             return streamFactoryFactory.create(socketSettings, sslSettings);
-        } else if (isNetty(streamType)) {
-            return new NettyStreamFactory(socketSettings, sslSettings, eventLoopGroup);
         } else if (isNio2(streamType)) {
             return new AsynchronousSocketChannelStreamFactory(socketSettings, sslSettings);
         } else {
@@ -246,28 +247,7 @@ private static String getStreamType(final String requestedStreamType) {
         }
     }
 
-    private static Closeable getEventLoopGroupCloser(final EventLoopGroup eventLoopGroup) {
-        if (eventLoopGroup == null) {
-            return null;
-        } else {
-            return new Closeable() {
-                @Override
-                public void close() throws IOException {
-                    eventLoopGroup.shutdownGracefully().awaitUninterruptibly();
-                }
-            };
-        }
-    }
-    private static EventLoopGroup getEventLoopGroupIfNecessary(final StreamFactoryFactory streamFactoryFactory,
-                                                                  final String streamType) {
-        if (isNetty(streamType) && streamFactoryFactory == null) {
-            return new NioEventLoopGroup();
-        } else {
-            return null;
-        }
-    }
-
-    private static CommandListener createCommandListener(final List<CommandListener> commandListeners) {
+    static CommandListener createCommandListener(final List<CommandListener> commandListeners) {
         switch (commandListeners.size()) {
             case 0:
                 return null;

driver-async/src/main/com/mongodb/async/client/NettyMongoClients.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2016 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package com.mongodb.async.client;
+
+import com.mongodb.client.MongoDriverInformation;
+import com.mongodb.connection.StreamFactory;
+import com.mongodb.connection.netty.NettyStreamFactory;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+// Creation of MongoClient using NettyStreamFactory is segregated here to avoid a runtime dependency on Netty in MongoClients
+final class NettyMongoClients {
+    static MongoClient create(final MongoClientSettings settings, final MongoDriverInformation mongoDriverInformation) {
+        final EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
+        StreamFactory streamFactory = new NettyStreamFactory(settings.getSocketSettings(), settings.getSslSettings(), eventLoopGroup);
+        StreamFactory heartbeatStreamFactory = new NettyStreamFactory(settings.getHeartbeatSocketSettings(), settings.getSslSettings(),
+                                                                             eventLoopGroup);
+        return MongoClients.createMongoClient(settings, mongoDriverInformation, streamFactory, heartbeatStreamFactory,
+                new Closeable() {
+                    @Override
+                    public void close() throws IOException {
+                        eventLoopGroup.shutdownGracefully().awaitUninterruptibly();
+                    }
+                });
+    }
+
+    private NettyMongoClients() {
+    }
+}