public boolean isConfigurable() { if(null == configurable) { configurable = Classes.isAnnotationPresent(beanClass,Configurable.class); } return configurable; }
@Override public boolean isExplicitNonEntity(MetadataContext context,Class<?> javaType) { return Classes.isAnnotationPresent(javaType, NonEntity.class); }
@Override public boolean isRemoteEntity(MetadataContext context, Class<?> javaType) { return Classes.isAnnotationPresent(javaType, RestEntity.class); }
/** * Returns true if the annotation type exists. */ default boolean isAnnotationPresent(Class<? extends Annotation> annotationType) { return Classes.isAnnotationPresent(getAnnotations(), annotationType); }
@Override public boolean isExplicitEntity(MetadataContext context,Class<?> javaType) { if(isExplicitNonEntity(context, javaType)) { return false; } if(Model.class.isAssignableFrom(javaType) && !Modifier.isAbstract(javaType.getModifiers())) { return true; } for(Annotation a : Classes.getAnnotations(javaType)){ if(Classes.isAnnotationPresent(a.annotationType(), AEntity.class)){ return true; } } return false; }
public void load(final BeanContainer container, Class<?>[] classes) { if(null == container.getAppConfig()){ return; } String basePackage = container.getAppConfig().getBasePackage() + "."; //TODO : currently only supports classes in base-package for(Class<?> cls : classes){ boolean needLoad = cls.getName().startsWith(basePackage); for(String additionalPackage : container.getAppConfig().getAdditionalPackages()){ if(needLoad){ break; } needLoad = needLoad || cls.getName().startsWith(additionalPackage); } boolean isBean = Classes.isAnnotationPresent(cls, Bean.class); if (isBean && needLoad) { readBean(container, cls); } } }
@Override public Validator tryCreateValidator(Annotation constraint, Class<?> valueType) { Args.notNull(constraint,"constraint annotation"); Args.notNull(valueType,"value type"); Class<? extends Annotation> constraintType = constraint.annotationType(); String constraintName = Strings.lowerFirst(constraintType.getSimpleName()); ValidatorFactory factory = beanFactory.tryGetBean(ValidatorFactory.class, constraintName); if(null != factory){ return factory.tryCreateValidator(constraint, valueType); } Validator validator = null; for(ValidatorFactory vf : this.validatorFactories){ if((validator = vf.tryCreateValidator(constraint, valueType)) != null){ return validator; } } ValidatedBy constraintAnnotation = constraint.annotationType().getAnnotation(ValidatedBy.class); if(null != constraintAnnotation){ return createConstraintValidator(constraint, valueType, constraintAnnotation); } validator = tryGetOrCreateDefaultValidator(constraint,valueType); if(null == validator && Classes.isAnnotationPresent(constraintType, ConstraintAnnotation.class)){ throw new IllegalStateException("Cannot create validator for constraint '" + constraintType.getName() + "'"); } return validator; }
@Override public void postInitBean(AppContext context, BeanFactory factory, BeanDefinitionConfigurator c) throws Throwable { if(c.definition().isExportMBean() || Classes.isAnnotationPresent(c.definition().getBeanClass(), Managed.class)){ c.setLazyInit(false); } }
boolean annotated = Classes.isAnnotationPresent(cls, DataSource.class); if(null != modelsConfigs) { OrmModelsConfig models = modelsConfigs.getModelsConfig(ds);
boolean annotated = Classes.isAnnotationPresent(cls, DataSource.class); if(null != modelsConfigs){ Optional<OrmModelsConfig> ormConfig = modelsConfigs.getModelsConfigMap().values().stream()
boolean nullable = Classes.isAnnotationPresent(annotations, NotNull.class) || Classes.isAnnotationPresent(annotations, M.class); boolean required = Classes.isAnnotationPresent(annotations, NotEmpty.class) || Classes.isAnnotationPresent(annotations, R.class);
protected ArgumentBuilder addArgument(RestdContext context, FuncActionBuilder action, Class<?> type, String name, Boolean required) { ArgumentBuilder a = new ArgumentBuilder(); a.setName(name); a.setType(type); a.setRequired(required); if(Classes.isAnnotationPresent(type, ParamsWrapper.class)) { BeanType bt = BeanType.of(type); for (BeanProperty bp : bt.getProperties()) { if (bp.isField() && !bp.isAnnotationPresent(NonParam.class)) { ArgumentBuilder wrapped = new ArgumentBuilder(validationManager, bp); a.addWrappedArgument(wrapped); } } } for(RestdArgumentSupport vs : argumentSupports) { vs.processArgument(context, a); } action.addArgument(a); return a; }