/** * Return if the bean is instance of give class. * * @param c * the class * @return `true` if the underline bean is an instance of `c` */ public boolean isInstanceOf(Class c) { return c.isAssignableFrom(rawType()); }
@Override public Dao load(BeanSpec spec) { List<Type> typeList = spec.typeParams(); int sz = typeList.size(); if (sz > 1) { Class<?> modelType = BeanSpec.rawTypeOf(typeList.get(1)); return dbServiceManager.dao(modelType); } return (Dao)Act.getInstance(spec.rawType()); }
@Override public void fireInjectedEvent(Object bean, BeanSpec spec) { Class c = spec.rawType(); List<DependencyInjectionListener> list = listeners.get(c); if (null != list) { for (DependencyInjectionListener listener : list) { listener.onInjection(bean, spec); } } }
private ProvidedValueLoader(BeanSpec beanSpec, DependencyInjector<?> injector) { Class type = beanSpec.rawType(); if (AppServiceBase.class.isAssignableFrom(type) || SingletonBase.class.isAssignableFrom(type) || type.isAnnotationPresent(Singleton.class) || type.isAnnotationPresent(ApplicationScoped.class)) { singleton = injector.get(type); } this.beanSpec = beanSpec; this.injector = injector; }
@Override public Object load(Object bean, ActContext<?> context, boolean noDefaultValue) { if (null != singleton) { return singleton; } if (null != context && context.getClass().equals(beanSpec.rawType())) { return context; } else { GenieInjector genieInjector = (GenieInjector) injector; return genieInjector.get(beanSpec); } }
@Override public Object load(Object bean, ActContext<?> context, boolean noDefaultValue) { if (null != singleton) { return singleton; } if (null != context && context.getClass().equals(beanSpec.rawType())) { return context; } else { GenieInjector genieInjector = (GenieInjector) injector; return genieInjector.get(beanSpec); } }
@Override public <T> T get(BeanSpec target) { return (T) app.singleton(target.rawType()); }
private static String toString(BeanSpec spec) { if (spec.typeParams().isEmpty()) { return spec.rawType().getName(); } else { return spec.type().toString(); } }
private Class[] paramTypes() { List<BeanSpec> paramTypes = methodInfo.paramTypes(); int sz = null == paramTypes ? 0 : paramTypes.size(); Class[] ca = new Class[sz]; for (int i = 0; i < sz; ++i) { BeanSpec spec = methodInfo.paramTypes().get(i); ca[i] = spec.rawType(); } return ca; }
private Class[] paramTypes() { List<BeanSpec> paramTypes = methodInfo.paramTypes(); int sz = null == paramTypes ? 0 : paramTypes.size(); Class[] ca = new Class[sz]; for (int i = 0; i < sz; ++i) { BeanSpec spec = methodInfo.paramTypes().get(i); ca[i] = spec.rawType(); } return ca; }
public BeanSpec parent() { Class<?> rawType = rawType(); Type type = rawType.getGenericSuperclass(); type = null == type ? rawType.getSuperclass() : type; return null == type ? null : BeanSpec.of(type, injector()); }
private List<String> checkOptions(BeanSpec spec) { Class<?> type = spec.rawType(); if (type.isEnum()) { return C.listOf(type.getEnumConstants()).map($.F.asString()); } return null; } }
static <T> Provider<T> decorate(BeanSpec spec, Provider<T> realProvider, Genie genie) { if (realProvider instanceof PostConstructorInvoker) { return realProvider; } Method postConstructor = findPostConstructor(spec.rawType()); return null == postConstructor ? realProvider : new PostConstructorInvoker<T>(realProvider, postConstructor); }
private String checkDefaultValue(BeanSpec spec) { DefaultValue def = spec.getAnnotation(DefaultValue.class); if (null != def) { return def.value(); } Class<?> type = spec.rawType(); if (type.isPrimitive()) { Object o = Act.app().resolverManager().resolve("", type); return null != o ? o.toString() : null; } return null; }
private Provider buildProvider(BeanSpec spec, Set<BeanSpec> chain) { Class target = spec.rawType(); Constructor constructor = constructor(target); return null != constructor ? buildConstructor(constructor, spec, chain) : buildFieldMethodInjector(spec, chain); }
public StringValueResolverValueLoaderBase(ParamKey key, DefaultValue def, BeanSpec spec, boolean simpleKeyOnly) { E.illegalArgumentIf(simpleKeyOnly && !key.isSimple()); this.paramSpec = spec; this.param = spec.getAnnotation(Param.class); this.paramKey = key; this.defSpec = def; this.resolverManager = Act.app().resolverManager(); this.injector = Act.app().injector(); this.requireRuntimeType = !(spec.type() instanceof Class); this.stringValueResolver = this.requireRuntimeType ? null : lookupResolver(spec, spec.rawType()); this.defVal = this.requireRuntimeType ? null : null != def ? this.stringValueResolver.resolve(def.value()) : defVal(param, spec.rawType()); }
public boolean isProvided(BeanSpec beanSpec) { Class rawType = beanSpec.rawType(); boolean provided = (ActProviders.isProvided(rawType) || null != beanSpec.getAnnotation(Inject.class) || null != beanSpec.getAnnotation(Provided.class) || null != beanSpec.getAnnotation(Context.class) || null != beanSpec.getAnnotation(Singleton.class) || beanSpec.isInstanceOf(SingletonBase.class) || subjectToInject(beanSpec) ); return provided && (!($.isSimpleType(rawType) && !beanSpec.hasAnnotation())); }
public SessionValueLoader(String name, BeanSpec beanSpec) { this.key = key(name, beanSpec); this.targetType = beanSpec.rawType(); this.stringValueResolver = App.instance().resolverManager().resolver(targetType, beanSpec); E.illegalArgumentIf(null == this.stringValueResolver, "Cannot find out StringValueResolver for %s", beanSpec); DefaultValue defValAnno = beanSpec.getAnnotation(DefaultValue.class); if (null != defValAnno) { this.defVal = stringValueResolver.resolve(defValAnno.value()); } else { this.defVal = StringValueResolverValueLoaderBase.defVal(null, targetType); } }
public boolean isProvided(BeanSpec beanSpec) { Class rawType = beanSpec.rawType(); boolean provided = (ActProviders.isProvided(rawType) || null != beanSpec.getAnnotation(Inject.class) || null != beanSpec.getAnnotation(Provided.class) || null != beanSpec.getAnnotation(Context.class) || null != beanSpec.getAnnotation(Singleton.class) || beanSpec.isInstanceOf(SingletonBase.class) || subjectToInject(beanSpec) ); return provided && (!($.isSimpleType(rawType) && !beanSpec.hasAnnotation())); }
protected StringValueResolverValueLoaderBase(ParamKey key, DefaultValue def, StringValueResolver resolver, BeanSpec paramSpec, boolean simpleKeyOnly) { E.illegalArgumentIf(simpleKeyOnly && !key.isSimple()); this.paramSpec = paramSpec; this.param = paramSpec.getAnnotation(Param.class); this.paramKey = key; this.defSpec = def; this.resolverManager = Act.app().resolverManager(); this.injector = Act.app().injector(); this.requireRuntimeType = false; this.stringValueResolver = resolver; this.defVal = null != def ? this.stringValueResolver.resolve(def.value()) : defVal(param, paramSpec.rawType()); }