Merge pull request #45 from codingbaraGo/refactor/config/di/#44

[Config-DI] 싱글톤을 보장하는 싱글톤 컨테이너 개발

Author: codingbaraGo

src/main/java/config/AppConfig.java

@@ -11,127 +11,202 @@
 import http.request.InputStreamHttpRequestConverter;
 import http.response.HttpResponseBufferedStreamConverter;
 import http.response.HttpResponseConverter;
-import web.dispatch.argument.ArgumentResolver;
 import web.dispatch.Dispatcher;
 import web.dispatch.HandlerAdapter;
 import web.dispatch.adapter.DefaultHandlerAdapter;
 import web.dispatch.adapter.SingleArgHandlerAdapter;
+import web.dispatch.argument.ArgumentResolver;
 import web.dispatch.argument.resolver.HttpRequestResolver;
 import web.dispatch.argument.resolver.QueryParamsResolver;
 import web.handler.StaticContentHandler;
 import web.handler.WebHandler;
-import web.renderer.StaticViewRenderer;
 import web.renderer.HttpResponseRenderer;
+import web.renderer.StaticViewRenderer;
 
 import java.util.List;
 
-public class AppConfig {
-    //Http
-    public HttpRequestConverter httpRequestConverter(){
+public class AppConfig extends SingletonContainer {
+
+    /**
+     * ===== Http =====
+     */
+    public HttpRequestConverter httpRequestConverter() {
         return inputStreamHttpRequestConverter();
     }
-    public HttpResponseConverter httpResponseConverter(){
+
+    public HttpResponseConverter httpResponseConverter() {
         return httpResponseBufferedStreamConverter();
     }
 
-    public BufferedReaderHttpRequestConverter httpBufferedReaderRequestConverter(){
-        return new BufferedReaderHttpRequestConverter();
+    public BufferedReaderHttpRequestConverter httpBufferedReaderRequestConverter() {
+        return getOrCreate(
+                "httpBufferedReaderRequestConverter",
+                BufferedReaderHttpRequestConverter::new
+        );
     }
 
-    public HttpResponseBufferedStreamConverter httpResponseBufferedStreamConverter(){
-        return new HttpResponseBufferedStreamConverter();
-    }
-    public InputStreamHttpRequestConverter inputStreamHttpRequestConverter(){
-        return new InputStreamHttpRequestConverter();
+    public HttpResponseBufferedStreamConverter httpResponseBufferedStreamConverter() {
+        return getOrCreate(
+                "httpResponseBufferedStreamConverter",
+                HttpResponseBufferedStreamConverter::new
+        );
     }
 
-
-    //Web
-    public Dispatcher dispatcher(){
-        return new Dispatcher(
-                webHandlerList(),
-                handlerAdapterList(),
-                webHandlerResponseHandlerList()
+    public InputStreamHttpRequestConverter inputStreamHttpRequestConverter() {
+        return getOrCreate(
+                "inputStreamHttpRequestConverter",
+                InputStreamHttpRequestConverter::new
         );
     }
 
-    private List<WebHandler> webHandlerList(){
-        return List.of(
-                staticContentHandler(),
-                registerWithGet(),
-                registerWithPost()
+    /**
+     * ===== Web =====
+     */
+    public Dispatcher dispatcher() {
+        return getOrCreate(
+                "dispatcher",
+                () -> new Dispatcher(
+                        webHandlerList(),
+                        handlerAdapterList(),
+                        webHandlerResponseHandlerList()
+                )
         );
     }
-    private RegisterWithGet registerWithGet(){
-        return new RegisterWithGet();
+
+    public List<WebHandler> webHandlerList() {
+        return getOrCreate(
+                "webHandlerList",
+                () -> List.of(
+                        staticContentHandler(),
+                        registerWithGet(),
+                        registerWithPost()
+                )
+        );
     }
-    private RegisterWithPost registerWithPost(){
-        return new RegisterWithPost();
+
+    public RegisterWithGet registerWithGet() {
+        return getOrCreate(
+                "registerWithGet",
+                RegisterWithGet::new
+        );
     }
 
-    private List<HttpResponseRenderer> webHandlerResponseHandlerList(){
-        return List.of(
-                staticViewResponseHandler()
+    public RegisterWithPost registerWithPost() {
+        return getOrCreate(
+                "registerWithPost",
+                RegisterWithPost::new
         );
     }
-    private StaticContentHandler staticContentHandler(){
-        return new StaticContentHandler();
+
+    public List<HttpResponseRenderer> webHandlerResponseHandlerList() {
+        return getOrCreate(
+                "webHandlerResponseHandlerList",
+                () -> List.of(
+                        staticViewResponseHandler()
+                )
+        );
     }
-    private StaticViewRenderer staticViewResponseHandler(){
-        return new StaticViewRenderer();
+
+    public StaticContentHandler staticContentHandler() {
+        return getOrCreate(
+                "staticContentHandler",
+                StaticContentHandler::new
+        );
     }
 
+    public StaticViewRenderer staticViewResponseHandler() {
+        return getOrCreate(
+                "staticViewResponseHandler",
+                StaticViewRenderer::new
+        );
+    }
 
-    //Adapter
-    public List<HandlerAdapter> handlerAdapterList(){
-        return List.of(
-                singleArgHandlerAdapter(),
-                defaultHandlerAdapter()
+    // ===== Adapter =====
+    public List<HandlerAdapter> handlerAdapterList() {
+        return getOrCreate(
+                "handlerAdapterList",
+                () -> List.of(
+                        singleArgHandlerAdapter(),
+                        defaultHandlerAdapter()
+                )
         );
     }
 
-    private SingleArgHandlerAdapter singleArgHandlerAdapter(){
-        return new SingleArgHandlerAdapter(
-                argumentResolverList()
+    public SingleArgHandlerAdapter singleArgHandlerAdapter() {
+        return getOrCreate(
+                "singleArgHandlerAdapter",
+                () -> new SingleArgHandlerAdapter(
+                        argumentResolverList()
+                )
         );
     }
-    private DefaultHandlerAdapter defaultHandlerAdapter(){
-        return new DefaultHandlerAdapter();
+
+    public DefaultHandlerAdapter defaultHandlerAdapter() {
+        return getOrCreate(
+                "defaultHandlerAdapter",
+                DefaultHandlerAdapter::new
+        );
     }
 
-    //Resolver
-    public List<ArgumentResolver<?>> argumentResolverList(){
-        return List.of(
-                httpRequestResolver(),
-                queryParamsResolver()
+    // ===== Resolver =====
+    public List<ArgumentResolver<?>> argumentResolverList() {
+        return getOrCreate(
+                "argumentResolverList",
+                () -> List.of(
+                        httpRequestResolver(),
+                        queryParamsResolver()
+                )
         );
     }
 
-    private HttpRequestResolver httpRequestResolver(){
-        return new HttpRequestResolver();
+    public HttpRequestResolver httpRequestResolver() {
+        return getOrCreate(
+                "httpRequestResolver",
+                HttpRequestResolver::new
+        );
     }
-    private QueryParamsResolver queryParamsResolver(){
-        return new QueryParamsResolver();
+
+    public QueryParamsResolver queryParamsResolver() {
+        return getOrCreate(
+                "queryParamsResolver",
+                QueryParamsResolver::new
+        );
     }
 
-    //Exception
-    public ExceptionHandlerMapping exceptionHandlerMapping(){
-        return new ExceptionHandlerMapping(
-                List.of(
-                        serviceExceptionHandler(),
-                        errorExceptionHandler(),
-                        unhandledErrorHandler()
+    /**
+     * ===== Exception =====
+     */
+    public ExceptionHandlerMapping exceptionHandlerMapping() {
+        return getOrCreate(
+                "exceptionHandlerMapping",
+                () -> new ExceptionHandlerMapping(
+                        List.of(
+                                serviceExceptionHandler(),
+                                errorExceptionHandler(),
+                                unhandledErrorHandler()
+                        )
                 )
         );
     }
 
-    private ServiceExceptionHandler serviceExceptionHandler(){
-        return new ServiceExceptionHandler();
+    public ServiceExceptionHandler serviceExceptionHandler() {
+        return getOrCreate(
+                "serviceExceptionHandler",
+                ServiceExceptionHandler::new
+        );
     }
-    private UnhandledErrorHandler unhandledErrorHandler(){
-        return new UnhandledErrorHandler();
+
+    public UnhandledErrorHandler unhandledErrorHandler() {
+        return getOrCreate(
+                "unhandledErrorHandler",
+                UnhandledErrorHandler::new
+        );
     }
-    private ErrorExceptionHandler errorExceptionHandler(){
-        return new ErrorExceptionHandler();
+
+    public ErrorExceptionHandler errorExceptionHandler() {
+        return getOrCreate(
+                "errorExceptionHandler",
+                ErrorExceptionHandler::new
+        );
     }
 }

src/main/java/config/SingletonContainer.java

@@ -0,0 +1,21 @@
+package config;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+public abstract class SingletonContainer {
+    private static final Map<String, Object> singletonMap = new HashMap<>();
+
+    @SuppressWarnings("unchecked")
+    public <T> T getOrCreate(String name, Supplier<T> factory) {
+        Object instance = singletonMap.get(name);
+        if (instance != null) {
+            return (T) instance;
+        }
+        T created = factory.get();
+        singletonMap.put(name, created);
+        return created;
+    }
+
+}