Simplified IoC and bean management components.

rapidoid-commons/src/main/java/org/rapidoid/cls/Cls.java

@@ -435,7 +435,7 @@ public static <T> Constructor<T> getConstructor(Class<T> clazz, Class<?>... para
 
 	@SuppressWarnings("unchecked")
 	public static <T> T newInstance(Class<T> clazz, Map<String, Object> properties) {
-		if (properties == null) {
+		if (U.isEmpty(properties)) {
 			return newInstance(clazz);
 		}
 
@@ -444,6 +444,7 @@ public static <T> T newInstance(Class<T> clazz, Map<String, Object> properties)
 		for (Constructor<?> constr : clazz.getConstructors()) {
 			Class<?>[] paramTypes = constr.getParameterTypes();
 			Object[] args = getAssignableArgs(paramTypes, values);
+
 			if (args != null) {
 				try {
 					return (T) constr.newInstance(args);
@@ -939,8 +940,13 @@ public static boolean isDataStructure(Class<?> clazz) {
 	}
 
 	public static boolean isBeanType(Class<?> clazz) {
-		return kindOf(clazz) == TypeKind.OBJECT && !(Collection.class.isAssignableFrom(clazz))
-				&& !(Map.class.isAssignableFrom(clazz)) && !(Object[].class.isAssignableFrom(clazz))
+		return kindOf(clazz) == TypeKind.OBJECT
+				&& !clazz.isAnnotation()
+				&& !clazz.isEnum()
+				&& !clazz.isInterface()
+				&& !(Collection.class.isAssignableFrom(clazz))
+				&& !(Map.class.isAssignableFrom(clazz))
+				&& !(Object[].class.isAssignableFrom(clazz))
 				&& !clazz.getPackage().getName().startsWith("java.")
 				&& !clazz.getPackage().getName().startsWith("javax.");
 	}

rapidoid-commons/src/main/java/org/rapidoid/ioc/ClassMetadata.java

@@ -42,7 +42,7 @@ public class ClassMetadata {
 
 	final List<Field> localFields;
 
-	final Set<Object> injectors = Coll.synchronizedSet();
+	final Set<Object> providers = Coll.synchronizedSet();
 
 	final List<F3<Object, Object, Method, Object[]>> interceptors = Coll.synchronizedList();
 

rapidoid-commons/src/main/java/org/rapidoid/ioc/IoC.java

@@ -31,28 +31,36 @@ public class IoC {
 
 	private static final IoCContext DEFAULT_CONTEXT = new IoCContext();
 
-	public static synchronized IoCContext getDefault() {
+	public static IoCContext defaultContext() {
 		return DEFAULT_CONTEXT;
 	}
 
-	public static synchronized void manage(Object... classesOrInstances) {
+	public static void manage(Object... classesOrInstances) {
 		DEFAULT_CONTEXT.manage(classesOrInstances);
 	}
 
-	public static synchronized <T> T singleton(Class<T> type) {
+	public static <T> T singleton(Class<T> type) {
 		return DEFAULT_CONTEXT.singleton(type);
 	}
 
-	public static synchronized <T> T autowire(T target) {
+	public static <T> T autowire(T target) {
 		return DEFAULT_CONTEXT.autowire(target);
 	}
 
-	public static synchronized <T> T inject(T target) {
+	public static <T> T inject(T target) {
 		return DEFAULT_CONTEXT.inject(target);
 	}
 
-	public static synchronized <T> T inject(T target, Map<String, Object> properties) {
+	public static <T> T inject(T target, Map<String, Object> properties) {
 		return DEFAULT_CONTEXT.inject(target, properties);
 	}
 
+	public boolean remove(Object bean) {
+		return DEFAULT_CONTEXT.remove(bean);
+	}
+
+	public static IoCContext createContext() {
+		return new IoCContext();
+	}
+
 }

rapidoid-commons/src/main/java/org/rapidoid/ioc/IoCContext.java

@@ -30,6 +30,7 @@
 import org.rapidoid.lambda.Mapper;
 import org.rapidoid.log.Log;
 import org.rapidoid.u.U;
+import org.rapidoid.util.UTILS;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationHandler;
@@ -43,13 +44,14 @@
 @Since("5.1.0")
 public class IoCContext {
 
-	private final Map<Class<?>, Object> singletons = U.map();
+	IoCContext() {
+	}
 
-	private final Set<Class<?>> managedClasses = U.set();
+	private final Set<Class<?>> providedClasses = U.set();
 
-	private final Set<Object> managedInstances = U.set();
+	private final Set<Object> providedInstances = U.set();
 
-	private final Map<Object, Object> iocInstances = U.map();
+	private final Map<Object, Object> proxies = U.map();
 
 	private final Map<Class<?>, ClassMetadata> metadata = Coll
 			.autoExpandingMap(new Mapper<Class<?>, ClassMetadata>() {
@@ -62,10 +64,9 @@ public ClassMetadata map(Class<?> clazz) throws Exception {
 	public synchronized void reset() {
 		Log.info("Resetting IoC context", "context", this);
 
-		singletons.clear();
-		managedClasses.clear();
-		managedInstances.clear();
-		iocInstances.clear();
+		providedClasses.clear();
+		providedInstances.clear();
+		proxies.clear();
 		metadata.clear();
 	}
 
@@ -74,41 +75,42 @@ private ClassMetadata meta(Class<?> type) {
 	}
 
 	public synchronized void manage(Object... classesOrInstances) {
-		List<Class<?>> autocreate = new ArrayList<Class<?>>();
+		List<Class<?>> autoCreate = new ArrayList<Class<?>>();
 
 		for (Object classOrInstance : classesOrInstances) {
 
 			boolean isClass = isClass(classOrInstance);
 			Class<?> clazz = isClass ? (Class<?>) classOrInstance : classOrInstance.getClass();
 
 			for (Class<?> interfacee : Cls.getImplementedInterfaces(clazz)) {
-				addInjectionProvider(interfacee, classOrInstance);
+				addProvider(interfacee, classOrInstance);
 			}
 
 			if (isClass) {
 				Log.debug("configuring managed class", "class", classOrInstance);
-				managedClasses.add(clazz);
+				providedClasses.add(clazz);
 
 				if (!clazz.isInterface() && !clazz.isEnum() && !clazz.isAnnotation()) {
 					// if the class is annotated, auto-create an instance
 					if (clazz.getAnnotation(Autocreate.class) != null) {
-						autocreate.add(clazz);
+						autoCreate.add(clazz);
 					}
 				}
 			} else {
-				Log.debug("configuring managed instance", "instance", classOrInstance);
-				addInjectionProvider(clazz, classOrInstance);
-				managedInstances.add(classOrInstance);
+				Object instance = classOrInstance;
+				Log.debug("configuring provided instance", "instance", instance);
+				addProvider(clazz, instance);
+				providedInstances.add(instance);
 			}
 		}
 
-		for (Class<?> clazz : autocreate) {
+		for (Class<?> clazz : autoCreate) {
 			singleton(clazz);
 		}
 	}
 
-	private void addInjectionProvider(Class<?> type, Object provider) {
-		meta(type).injectors.add(provider);
+	private void addProvider(Class<?> type, Object provider) {
+		meta(type).providers.add(provider);
 	}
 
 	public synchronized <T> T singleton(Class<T> type) {
@@ -159,11 +161,11 @@ private <T> T provideIoCInstanceOf(Object target, Class<T> type, String name,
 		}
 
 		if (instance == null) {
-			instance = provideIoCInstanceByType(type, properties);
+			instance = provideInstanceByType(type, properties);
 		}
 
-		if (instance == null && canInjectNew(type)) {
-			instance = provideNewIoCInstanceOf(type, properties);
+		if (instance == null && Cls.isBeanType(type)) {
+			instance = provideNewInstanceOf(type, properties);
 		}
 
 		if (!optional) {
@@ -179,62 +181,47 @@ private <T> T provideIoCInstanceOf(Object target, Class<T> type, String name,
 		return instance != null ? ioc(instance, properties) : null;
 	}
 
-	private boolean canInjectNew(Class<?> type) {
-		return !type.isAnnotation() && !type.isEnum() && !type.isInterface() && !type.isPrimitive()
-				&& !type.equals(String.class) && !type.equals(Object.class) && !type.equals(Boolean.class)
-				&& !Number.class.isAssignableFrom(type);
-	}
-
 	@SuppressWarnings("unchecked")
-	private <T> T provideNewIoCInstanceOf(Class<T> type, Map<String, Object> properties) {
+	private <T> T provideNewInstanceOf(Class<T> type, Map<String, Object> properties) {
 		// instantiation if it's real class
 		if (!type.isInterface() && !type.isEnum() && !type.isAnnotation()) {
-			T instance = (T) singletons.get(type);
-
-			if (instance == null) {
-				instance = ioc(Cls.newInstance(type, properties), properties);
-			}
-
-			return instance;
+			return ioc(Cls.newInstance(type, properties), properties);
 		} else {
 			return null;
 		}
 	}
 
-	private <T> T provideIoCInstanceByType(Class<T> type, Map<String, Object> properties) {
-		Set<Object> providers = meta(type).injectors;
+	private <T> T provideInstanceByType(Class<T> type, Map<String, Object> properties) {
 
-		if (providers != null && !providers.isEmpty()) {
+		Set<Object> providers = meta(type).providers;
+		Object provider = null;
 
-			Object provider = null;
-
-			for (Object pr : providers) {
-				if (provider == null) {
-					provider = pr;
-				} else {
-					if (isClass(provider) && !isClass(pr)) {
-						provider = pr;
-					} else if (isClass(provider) || !isClass(pr)) {
-						throw U.rte("Found more than 1 injection candidates for type '%s': %s", type, providers);
-					}
+		for (Object candidate : providers) {
+			if (provider == null) {
+				provider = candidate;
+			} else {
+				if (isClass(provider) && !isClass(candidate)) {
+					provider = candidate;
+				} else if (isClass(provider) || !isClass(candidate)) {
+					throw U.rte("Found more than 1 candidates for type '%s': %s", type, providers);
 				}
 			}
+		}
 
-			if (provider != null) {
-				return provideFrom(provider, properties);
-			}
+		if (provider != null) {
+			return provideFrom(provider, properties);
 		}
 
 		return null;
 	}
 
 	@SuppressWarnings("unchecked")
-	private <T> T provideFrom(Object classOrInstance, Map<String, Object> properties) {
+	private <T> T provideFrom(Object provider, Map<String, Object> properties) {
 		T instance;
-		if (isClass(classOrInstance)) {
-			instance = provideNewIoCInstanceOf((Class<T>) classOrInstance, properties);
+		if (isClass(provider)) {
+			instance = provideNewInstanceOf((Class<T>) provider, properties);
 		} else {
-			instance = (T) classOrInstance;
+			instance = (T) provider;
 		}
 		return instance;
 	}
@@ -328,8 +315,8 @@ private <T> void invokePostConstruct(T target) {
 	}
 
 	private <T> T ioc(T target, Map<String, Object> properties) {
-		if (!isIocProcessed(target)) {
-			iocInstances.put(target, null);
+		if (!isProxyOrHasProxy(target)) {
+			proxies.put(target, null);
 
 			manage(target);
 
@@ -339,7 +326,7 @@ private <T> T ioc(T target, Map<String, Object> properties) {
 
 			T proxy = proxyWrap(target);
 
-			iocInstances.put(target, proxy);
+			proxies.put(target, proxy);
 
 			manage(proxy);
 
@@ -349,8 +336,8 @@ private <T> T ioc(T target, Map<String, Object> properties) {
 		return target;
 	}
 
-	private boolean isIocProcessed(Object target) {
-		for (Map.Entry<Object, Object> e : iocInstances.entrySet()) {
+	private boolean isProxyOrHasProxy(Object target) {
+		for (Map.Entry<Object, Object> e : proxies.entrySet()) {
 			if (e.getKey() == target || e.getValue() == target) {
 				return true;
 			}
@@ -398,4 +385,35 @@ public V map(K src) throws Exception {
 		});
 	}
 
+	public synchronized Object findInstanceOf(String className) {
+		for (Object instance : providedInstances) {
+			if (instance.getClass().getName().equals(className)) {
+				return instance;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public synchronized String toString() {
+		return UTILS.classNames(providedInstances);
+	}
+
+	public synchronized boolean remove(Object bean) {
+		boolean removed = providedInstances.remove(bean);
+		removed |= (proxies.remove(bean) != null);
+
+		if (removed) {
+			Class<?> clazz = bean.getClass();
+			providedClasses.remove(clazz);
+			metadata.remove(clazz);
+		}
+
+		return removed;
+	}
+
+	public synchronized void reload(ClassLoader classLoader) {
+		// FIXME implement
+	}
+
 }

rapidoid-commons/src/main/java/org/rapidoid/util/UTILS.java

@@ -849,4 +849,15 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
 		return ((T) Proxy.newProxyInstance(targetInterface.getClassLoader(), new Class[]{targetInterface}, handler));
 	}
 
+	public static String classNames(Collection<?> classesOrInstances) {
+		List<Object> names = U.list();
+
+		for (Object o : classesOrInstances) {
+			Class<?> clazz = (o instanceof Class<?>) ? ((Class) o) : o.getClass();
+			names.add(clazz.getSimpleName());
+		}
+
+		return "[" + U.join(", ", names) + "]";
+	}
+
 }

rapidoid-commons/src/test/java/org/rapidoid/ioc/basic/CallableInjectionTest.java

@@ -23,8 +23,8 @@
 import org.junit.Test;
 import org.rapidoid.annotation.Authors;
 import org.rapidoid.annotation.Since;
-import org.rapidoid.test.AbstractCommonsTest;
 import org.rapidoid.ioc.IoC;
+import org.rapidoid.test.AbstractCommonsTest;
 
 @Authors("Nikolche Mihajlovski")
 @Since("2.0.0")

rapidoid-commons/src/test/java/org/rapidoid/ioc/db/Database.java

@@ -34,8 +34,8 @@ public class Database {
 	@Inject
 	Transactor transactor;
 
-	final Map<String, Table> tables = IoC.getDefault().autoExpandingInjectingMap(Table.class);
+	final Map<String, Table> tables = IoC.defaultContext().autoExpandingInjectingMap(Table.class);
 
-	final Map<String, Relat> relations = IoC.getDefault().autoExpandingInjectingMap(Relat.class);
+	final Map<String, Relat> relations = IoC.defaultContext().autoExpandingInjectingMap(Relat.class);
 
 }

rapidoid-http-fast/src/main/java/org/rapidoid/http/FastHttp.java

@@ -48,7 +48,6 @@
 import org.rapidoid.u.U;
 import org.rapidoid.util.Constants;
 import org.rapidoid.util.UTILS;
-import org.rapidoid.ioc.IoC;
 import org.rapidoid.wrap.BoolWrap;
 
 import java.io.Serializable;
@@ -84,7 +83,7 @@ public class FastHttp implements Protocol, HttpMetadata {
 
 	private static final byte[] DATE_IS = "Date: ".getBytes();
 
-	private static final HttpParser HTTP_PARSER = IoC.singleton(HttpParser.class);
+	private static final HttpParser HTTP_PARSER = new HttpParser();
 
 	private static final byte[] _POST = Constants.POST.getBytes();
 	private static final byte[] _PUT = Constants.PUT.getBytes();