Introduced McpServiceLoader class to handle all types of service loading

in common way.

Author: scottslewis

mcp-core/src/main/java/io/modelcontextprotocol/json/internal/DefaultMcpJsonMapperSupplier.java

@@ -1,40 +1,27 @@
 package io.modelcontextprotocol.json.internal;
 
-import java.util.Optional;
-import java.util.ServiceConfigurationError;
-import java.util.ServiceLoader;
-
 import io.modelcontextprotocol.json.McpJsonMapper;
 import io.modelcontextprotocol.json.McpJsonMapperSupplier;
+import io.modelcontextprotocol.util.McpServiceLoader;
 
 public class DefaultMcpJsonMapperSupplier {
 
-	private static McpJsonMapperSupplier jsonMapperSupplier;
+	private static McpServiceLoader<McpJsonMapperSupplier, McpJsonMapper> mcpServiceLoader;
 
-	private static McpJsonMapper defaultJsonMapper;
+	public DefaultMcpJsonMapperSupplier() {
+		mcpServiceLoader = new McpServiceLoader<McpJsonMapperSupplier, McpJsonMapper>();
+	}
 
 	void setMcpJsonMapperSupplier(McpJsonMapperSupplier supplier) {
-		jsonMapperSupplier = supplier;
+		mcpServiceLoader.setSupplier(supplier);
 	}
 
 	void unsetMcpJsonMapperSupplier(McpJsonMapperSupplier supplier) {
-		jsonMapperSupplier = null;
-		defaultJsonMapper = null;
+		mcpServiceLoader.unsetSupplier(supplier);
 	}
 
 	public synchronized static McpJsonMapper getDefaultMcpJsonMapper() {
-		if (defaultJsonMapper == null) {
-			if (jsonMapperSupplier == null) {
-				// Use serviceloader
-				Optional<McpJsonMapperSupplier> sl = ServiceLoader.load(McpJsonMapperSupplier.class).findFirst();
-				if (sl.isEmpty()) {
-					throw new ServiceConfigurationError("No JsonMapperSupplier available for creating McpJsonMapper");
-				}
-				jsonMapperSupplier = sl.get();
-			}
-			defaultJsonMapper = jsonMapperSupplier.get();
-		}
-		return defaultJsonMapper;
+		return mcpServiceLoader.getDefault();
 	}
 
 }

mcp-core/src/main/java/io/modelcontextprotocol/json/internal/DefaultMcpJsonSchemaValidatorSupplier.java

@@ -1,42 +1,27 @@
 package io.modelcontextprotocol.json.internal;
 
-import java.util.Optional;
-import java.util.ServiceConfigurationError;
-import java.util.ServiceLoader;
-
 import io.modelcontextprotocol.json.schema.JsonSchemaValidator;
 import io.modelcontextprotocol.json.schema.JsonSchemaValidatorSupplier;
+import io.modelcontextprotocol.util.McpServiceLoader;
 
 public class DefaultMcpJsonSchemaValidatorSupplier {
 
-	private static JsonSchemaValidatorSupplier jsonSchemaValidatorSupplier;
+	private static McpServiceLoader<JsonSchemaValidatorSupplier, JsonSchemaValidator> mcpServiceLoader;
 
-	private static JsonSchemaValidator defaultJsonSchemaValidator;
+	public DefaultMcpJsonSchemaValidatorSupplier() {
+		mcpServiceLoader = new McpServiceLoader<JsonSchemaValidatorSupplier, JsonSchemaValidator>();
+	}
 
 	void setJsonSchemaValidatorSupplier(JsonSchemaValidatorSupplier supplier) {
-		jsonSchemaValidatorSupplier = supplier;
+		mcpServiceLoader.setSupplier(supplier);
 	}
 
 	void unsetJsonSchemaValidatorSupplier(JsonSchemaValidatorSupplier supplier) {
-		jsonSchemaValidatorSupplier = null;
-		defaultJsonSchemaValidator = null;
+		mcpServiceLoader.unsetSupplier(supplier);
 	}
 
 	public synchronized static JsonSchemaValidator getDefaultJsonSchemaValidator() {
-		if (defaultJsonSchemaValidator == null) {
-			if (jsonSchemaValidatorSupplier == null) {
-				// Use serviceloader
-				Optional<JsonSchemaValidatorSupplier> sl = ServiceLoader.load(JsonSchemaValidatorSupplier.class)
-					.findFirst();
-				if (sl.isEmpty()) {
-					throw new ServiceConfigurationError(
-							"No JsonSchemaValidatorSupplier available for creating JsonSchemaValidator");
-				}
-				jsonSchemaValidatorSupplier = sl.get();
-			}
-			defaultJsonSchemaValidator = jsonSchemaValidatorSupplier.get();
-		}
-		return defaultJsonSchemaValidator;
+		return mcpServiceLoader.getDefault();
 	}
 
 }

mcp-core/src/main/java/io/modelcontextprotocol/util/McpServiceLoader.java

@@ -0,0 +1,79 @@
+package io.modelcontextprotocol.util;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Optional;
+import java.util.ServiceConfigurationError;
+import java.util.ServiceLoader;
+import java.util.function.Supplier;
+
+public class McpServiceLoader<S extends Supplier<R>, R> {
+
+	private Type supplierType;
+
+	private S supplier;
+
+	private R supplierResult;
+
+	protected abstract class TypeToken<T> {
+
+		private Type type;
+
+		protected TypeToken() {
+			Type superClass = getClass().getGenericSuperclass();
+			this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
+		}
+
+		public Type getType() {
+			return type;
+		}
+
+	}
+
+	protected class SupplierTypeToken extends TypeToken<S> {
+
+	};
+
+	public void setSupplier(S supplier) {
+		this.supplier = supplier;
+		this.supplierResult = null;
+	}
+
+	public void unsetSupplier(S supplier) {
+		this.supplier = null;
+		this.supplierResult = null;
+	}
+
+	public McpServiceLoader() {
+		this.supplierType = new SupplierTypeToken().getType();
+	}
+
+	protected Optional<S> serviceLoad(Class<S> type) {
+		return ServiceLoader.load(type).findFirst();
+	}
+
+	@SuppressWarnings("unchecked")
+	public synchronized R getDefault() {
+		if (this.supplierResult == null) {
+			if (this.supplier == null) {
+				// Use serviceloader
+				Optional<?> sl;
+				try {
+					sl = serviceLoad((Class<S>) Class.forName(this.supplierType.getTypeName()));
+					if (sl.isEmpty()) {
+						throw new ServiceConfigurationError(
+								"No JsonMapperSupplier available for creating McpJsonMapper");
+					}
+				}
+				catch (ClassNotFoundException e) {
+					throw new ServiceConfigurationError(
+							"ClassNotFoundException for Type=" + this.supplierType.getTypeName());
+				}
+				this.supplier = (S) sl.get();
+			}
+			this.supplierResult = this.supplier.get();
+		}
+		return supplierResult;
+	}
+
+}