private static ScopeCache resolveBuiltIn(Class<? extends Annotation> annoClass, Genie genie) { if (Singleton.class == annoClass) { return genie.get(ScopeCache.SingletonScope.class); } else if (RequestScoped.class == annoClass) { return genie.get(ScopeCache.RequestScope.class); } else if (SessionScoped.class == annoClass) { return genie.get(ScopeCache.SessionScope.class); } return null; } }
private void registerBuiltInProviders() { registerProvider(Collection.class, OsglListProvider.INSTANCE, false); registerProvider(Deque.class, DequeProvider.INSTANCE, false); registerProvider(ArrayList.class, ArrayListProvider.INSTANCE, false); registerProvider(LinkedList.class, LinkedListProvider.INSTANCE, false); registerProvider(C.List.class, OsglListProvider.INSTANCE, false); registerProvider(C.Set.class, OsglSetProvider.INSTANCE, false); registerProvider(C.Map.class, OsglMapProvider.INSTANCE, false); registerProvider(LinkedHashMap.class, LinkedHashMapProvider.INSTANCE, false); registerProvider(ConcurrentMap.class, ConcurrentMapProvider.INSTANCE, false); registerProvider(SortedMap.class, SortedMapProvider.INSTANCE, false); registerProvider(SortedSet.class, SortedSetProvider.INSTANCE, false); }
@Override public <T> T get(Class<T> type) { return getProvider(type).get(); }
public static Genie genie() { final Map<Class, Object> singletonRepo = new HashMap<>(); Genie genie = Genie.createWithoutPlugins(); genie.registerProvider(ScopeCache.SingletonScope.class, new Provider<ScopeCache.SingletonScope>() { @Override public ScopeCache.SingletonScope get() { return new ScopeCache.SingletonScope() { @Override public <T> T get(Class<T> aClass) { return (T) singletonRepo.get(aClass); } @Override public <T> void put(Class<T> aClass, T t) { singletonRepo.put(aClass, t); } }; } }); return genie; }
if (null == genie) { InjectListener listener = new GenieListener(this); genie = Genie.create(listener, modules.toArray(new Object[modules.size()])); for (Map.Entry<Class, DependencyInjectionBinder> entry : binders.entrySet()) { genie.registerProvider(entry.getKey(), entry.getValue()); genie.registerQualifiers(Bind.class, Param.class); genie.registerScopeAlias(Singleton.class, Stateless.class); genie.registerScopeAlias(Singleton.class, InheritedStateless.class); genie.registerScopeAlias(StopInheritedScope.class, Stateful.class); List<ActionMethodParamAnnotationHandler> list = Act.pluginManager().pluginList(ActionMethodParamAnnotationHandler.class); for (ActionMethodParamAnnotationHandler h : list) { Set<Class<? extends Annotation>> set = h.listenTo(); for (Class<? extends Annotation> c : set) { genie.registerQualifiers(c); ActProviders.registerBuiltInNamedProviders(GenieProviders.class, namedProviderRegister); for (Class<? extends Annotation> injectTag : injectTags) { genie.registerInjectTag(injectTag); genie.registerProvider(Genie.class, new Provider<Genie>() { @Override public Genie get() {
final void applyTo(Genie genie) { if (!configured) { configure(); } configured = true; validate(genie); for (Binder<?> binder : binders) { binder.register(genie); } genie.registerQualifiers(qualifiers); for (Map.Entry<Class<?>, GenericTypedBeanLoader<?>> entry : genericTypedBeanLoaders.entrySet()) { genie.registerGenericTypedBeanLoader(entry.getKey(), (GenericTypedBeanLoader) entry.getValue()); } }
Type type = typeParams.get(0); if (type instanceof Class) { registerProvider((Class) type, (Provider) module); } else { logger.warn("Unknown Provider: " + moduleClass); isClass = false; registerFactoryMethod(isStatic ? null : module, method);
private List<FieldInjector> fieldInjectors(BeanSpec target, Set<BeanSpec> chain) { List<FieldInjector> fieldInjectors = C.newList(); for (BeanSpec fieldSpec : target.nonStaticFields()) { if (subjectToInject(fieldSpec)) { fieldSpec.makeFieldAccessible(); fieldInjectors.add(fieldInjector(fieldSpec, chain)); } } return fieldInjectors; }
static ScopeCache resolve(Class<? extends Annotation> annoClass, Genie genie) { ScopeCache cache = resolveBuiltIn(annoClass, genie); if (null != cache) { return cache; } Class<? extends Annotation> alias = genie.scopeByAlias(annoClass); if (null != alias) { cache = resolveBuiltIn(alias, genie); } if (null == cache) { cache = genie.scopeCache(annoClass); } return cache; }
private List<MethodInjector> methodInjectors(BeanSpec target, Set<BeanSpec> chain) { BeanSpec current = target; List<MethodInjector> methodInjectors = C.newList(); while (null != current && !current.isObject()) { for (Method method : current.getDeclaredMethods()) { if (subjectToInject(method)) { method.setAccessible(true); methodInjectors.add(methodInjector(method, chain)); } } current = current.parent(); } return methodInjectors; }
private Constructor constructor(Class target) { Constructor[] ca = target.getDeclaredConstructors(); for (Constructor c : ca) { if (subjectToInject(c)) { c.setAccessible(true); return c; } } return null; }
@Override public void register(Genie genie) { genie.registerScopeAlias(Singleton.class, com.google.inject.Singleton.class); genie.registerScopeAlias(SessionScoped.class, com.google.inject.servlet.SessionScoped.class); genie.registerScopeAlias(RequestScoped.class, com.google.inject.servlet.RequestScoped.class); // TODO support Guice Module } }
@Override public Class<? extends Annotation> scopeByAlias(Class<? extends Annotation> aClass) { return genie().scopeByAlias(aClass); }
@SubClassFinder public static void foundGenericTypedBeanLoader(Class<? extends GenericTypedBeanLoader> loaderClass) { App app = App.instance(); GenieInjector genieInjector = app.injector(); Type[] ta = loaderClass.getGenericInterfaces(); for (Type t : ta) { if (t instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) t; if (GenericTypedBeanLoader.class == pt.getRawType()) { Type compoentType = pt.getActualTypeArguments()[0]; genieInjector.genie().registerGenericTypedBeanLoader((Class) compoentType, app.getInstance(loaderClass)); } } } }
/** * Create a Genie instance with modules specified * * @param modules * modules that provides binding or @Provides methods * @return an new Genie instance with modules */ public static Genie createWithoutPlugins(Object... modules) { return new Genie(true, modules); }
if (null == genie) { InjectListener listener = new GenieListener(this); genie = Genie.create(listener, modules.toArray(new Object[modules.size()])); for (Map.Entry<Class, DependencyInjectionBinder> entry : binders.entrySet()) { genie.registerProvider(entry.getKey(), entry.getValue()); genie.registerQualifiers(Bind.class, Param.class); genie.registerScopeAlias(Singleton.class, Stateless.class); genie.registerScopeAlias(Singleton.class, InheritedStateless.class); genie.registerScopeAlias(StopInheritedScope.class, Stateful.class); List<ActionMethodParamAnnotationHandler> list = Act.pluginManager().pluginList(ActionMethodParamAnnotationHandler.class); for (ActionMethodParamAnnotationHandler h : list) { Set<Class<? extends Annotation>> set = h.listenTo(); for (Class<? extends Annotation> c : set) { genie.registerQualifiers(c); ActProviders.registerBuiltInNamedProviders(GenieProviders.class, namedProviderRegister); for (Class<? extends Annotation> injectTag : injectTags) { genie.registerInjectTag(injectTag); genie.registerProvider(Genie.class, new Provider<Genie>() { @Override public Genie get() {
final void applyTo(Genie genie) { if (!configured) { configure(); } configured = true; validate(genie); for (Binder<?> binder : binders) { binder.register(genie); } genie.registerQualifiers(qualifiers); for (Map.Entry<Class<?>, GenericTypedBeanLoader<?>> entry : genericTypedBeanLoaders.entrySet()) { genie.registerGenericTypedBeanLoader(entry.getKey(), (GenericTypedBeanLoader) entry.getValue()); } }
Type type = typeParams.get(0); if (type instanceof Class) { registerProvider((Class) type, (Provider) module); } else { logger.warn("Unknown Provider: " + moduleClass); isClass = false; registerFactoryMethod(isStatic ? null : module, method);
private List<FieldInjector> fieldInjectors(BeanSpec target, Set<BeanSpec> chain) { List<FieldInjector> fieldInjectors = C.newList(); for (BeanSpec fieldSpec : target.nonStaticFields()) { if (subjectToInject(fieldSpec)) { fieldSpec.makeFieldAccessible(); fieldInjectors.add(fieldInjector(fieldSpec, chain)); } } return fieldInjectors; }
static ScopeCache resolve(Class<? extends Annotation> annoClass, Genie genie) { ScopeCache cache = resolveBuiltIn(annoClass, genie); if (null != cache) { return cache; } Class<? extends Annotation> alias = genie.scopeByAlias(annoClass); if (null != alias) { cache = resolveBuiltIn(alias, genie); } if (null == cache) { cache = genie.scopeCache(annoClass); } return cache; }