/** * Construct a new PropertyValuePresenterRegistry * @param loadDefaults <code>true</code> to load default {@link PropertyValuePresenter}s from * <code>META-INF/services</code> using <code>com.holonplatform.core.property.PropertyValuePresenter</code> * files using default ClassLoader. Every default presenter will be registered using an always * <code>true</code> condition. */ public DefaultPropertyValuePresenterRegistry(boolean loadDefaults) { this(loadDefaults, ClassUtils.getDefaultClassLoader()); }
/** * Construct a new PropertyRendererRegistry * @param loadDefaults <code>true</code> to load default {@link PropertyRenderer}s from * <code>META-INF/services</code> using <code>com.holonplatform.core.property.PropertyRenderer</code> files * using default ClassLoader. Every default renderer will be registered using an always <code>true</code> * condition. */ public DefaultPropertyRendererRegistry(boolean loadDefaults) { this(loadDefaults, ClassUtils.getDefaultClassLoader()); }
/** * Obtains the default {@link ClassLoader} to use. * <p> * By default {@link ClassUtils#getDefaultClassLoader()} is used. * </p> * @return the default {@link ClassLoader} */ public ClassLoader getDefaultClassLoader() { return classLoader == null ? ClassUtils.getDefaultClassLoader() : classLoader; }
/** * Get default Holon configuration properties provider using default {@link ClassUtils#getDefaultClassLoader()} * ClassLoader. * @return Holon configuration properties providers, or an empty list if none available */ public static List<ConfigPropertyProvider> defaultConfigPropertyProviders() { return defaultConfigPropertyProviders(ClassUtils.getDefaultClassLoader()); }
/** * Create a new {@link RestClient} instance using default {@link ClassLoader} and the implementation whith given * fully qualified class name. * @param fullyQualifiedClassName The {@link RestClient} implementation fully qualified class name to obtain * @return A new {@link RestClient} instance * @throws RestClientCreationException If the implementation which corresponds to given fully qualified class name * is not available or a instance creation error occurred */ static RestClient create(String fullyQualifiedClassName) { return create(fullyQualifiedClassName, ClassUtils.getDefaultClassLoader()); }
/** * Return the default {@link PropertyValuePresenter}s using given <code>classLoader</code>. * <p> * The default {@link PropertyValuePresenter}s are loaded using fully qualified name of its implementation class * name to a <code>com.holonplatform.core.property.PropertyValuePresenter</code> file in the * <code>META-INF/services</code> directory. * </p> * @param classLoader ClassLoader to use, or <code>null</code> for the default ClassLoader * @return Default PropertyValuePresenters, or an empty List if none */ public static List<PropertyValuePresenter> getDefaultPresenters(ClassLoader classLoader) { return ensureInited((classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader()); }
/** * Return the default {@link PropertyRenderer}s using given <code>classLoader</code>. * <p> * The default {@link PropertyRenderer}s are loaded using fully qualified name of its implementation class name to a * <code>com.holonplatform.core.property.PropertyRenderer</code> file in the <code>META-INF/services</code> * directory. * </p> * @param classLoader ClassLoader to use, or <code>null</code> for the default ClassLoader * @return Default PropertyRenderers, or an empty List if none */ public static List<PropertyRenderer> getDefaultRenderers(ClassLoader classLoader) { return ensureInited((classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader()); }
/** * Return the default {@link PropertyRendererRegistry} using given <code>classLoader</code>. * <p> * The default registry is inited loading {@link PropertyRenderer}s using fully qualified name of its implementation * class name to a <code>com.holonplatform.core.property.PropertyRenderer</code> file in the * <code>META-INF/services</code> directory. * </p> * @param classLoader ClassLoader to use, or <code>null</code> for the default ClassLoader * @return Default PropertyRendererRegistry */ public static PropertyRendererRegistry getDefault(ClassLoader classLoader) { return ensureInited((classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader()); }
/** * Return the default {@link PropertyValuePresenterRegistry} using given <code>classLoader</code>. * <p> * The default registry is inited loading {@link PropertyValuePresenter}s using fully qualified name of its * implementation class name to a <code>com.holonplatform.core.property.PropertyValuePresenter</code> file in the * <code>META-INF/services</code> directory. * </p> * @param classLoader ClassLoader to use, or <code>null</code> for the default ClassLoader * @return Default PropertyValuePresenterRegistry */ public static PropertyValuePresenterRegistry getDefault(ClassLoader classLoader) { return ensureInited((classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader()); }
/** * Get the default {@link JsonProvider}, if any, for given ClassLoader. The default {@link JsonProvider} is the * first registered provider, i.e. the one with higher priority. * @param classLoader ClassLoader to use * @return Optional default {@link JsonProvider} */ public static Optional<JsonProvider> getDefaultJsonProvider(ClassLoader classLoader) { ClassLoader cl = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); List<JsonProvider> providers = getJsonProviders(cl); if (!providers.isEmpty()) { return Optional.of(providers.get(0)); } return Optional.empty(); }
/** * Create class instance using given class name and {@link #getDefaultClassLoader()} ClassLoader * @param name Class name * @return Class instance * @throws ClassNotFoundException Class definition with given name was not found */ public static Class<?> forName(String name) throws ClassNotFoundException { return forName(name, getDefaultClassLoader()); }
/** * Try to obtain a {@link Json} implementation, either from {@link Context}, if available using * {@link #CONTEXT_KEY}, or relying on registered {@link JsonProvider}s and using the one with higher priority. * @return The {@link Json} implementation, if available */ static Optional<Json> get() { return get(ClassUtils.getDefaultClassLoader()); }
/** * Create a new {@link RestClient} instance using default {@link ClassLoader} and default implementation, if * available. If more than one {@link RestClient} implementation is found using given ClassLoader, the one returned * by the {@link RestClientFactory} with the higher priority is returned. * @return A new {@link RestClient} instance * @throws RestClientCreationException If a {@link RestClient} implementation is not available or a instance * creation error occurred */ static RestClient create() { return create(null, ClassUtils.getDefaultClassLoader()); }
/** * Get the default {@link JsonProvider}, if any. The default {@link JsonProvider} is the first registered provider, * i.e. the one with higher priority. * @return Optional default {@link JsonProvider} */ public static Optional<JsonProvider> getDefaultJsonProvider() { return getDefaultJsonProvider(ClassUtils.getDefaultClassLoader()); }
/** * Checks whether the JPA API is available from classpath using current {@link ClassLoader}. * @return <code>true</code> if present */ public static boolean isJpaApiPresent() { return isJpaApiPresent(ClassUtils.getDefaultClassLoader()); }
@Override public Builder<C> withDefaultPropertySources(ClassLoader classLoader) { DefaultConfig .defaultConfigPropertyProviders( (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader()) .forEach((p) -> withPropertySource(p)); return this; }
@Override public void processBeanPropertySet(BeanPropertySet.Builder<?, ?> propertySet, Class<?> beanClass) { if (JpaAPIUtils.isJpaApiPresent( (beanClass != null) ? beanClass.getClassLoader() : ClassUtils.getDefaultClassLoader())) { processJpaBeanPropertySet(propertySet, beanClass); } else { LOGGER.debug(() -> "JPA API not detected in classpath: skip bean property set processing by class [" + getClass().getName() + "]"); } }
@Override public Builder<?> processBeanProperty(Builder<?> property, Class<?> beanOrNestedClass) { if (JpaAPIUtils.isJpaApiPresent((beanOrNestedClass != null) ? beanOrNestedClass.getClassLoader() : ClassUtils.getDefaultClassLoader())) { return processJpaBeanProperty(property, beanOrNestedClass); } LOGGER.debug(() -> "JPA API not detected in classpath: skip bean property processing by class [" + getClass().getName() + "]"); return property; }
public void configPropertyProviders() throws IOException { // tag::provider[] Map<String, Object> values = new HashMap<>(); ConfigPropertyProvider provider = ConfigPropertyProvider.using(values); // <1> Properties properties = new Properties(); provider = ConfigPropertyProvider.using(properties); // <2> provider = ConfigPropertyProvider.using("config.properties", ClassUtils.getDefaultClassLoader()); // <3> provider = ConfigPropertyProvider.usingSystemProperties(); // <4> // end::provider[] }
@Override public Optional<EntityPathExpression> resolve(DataTarget expression, ResolutionContext context) throws InvalidExpressionException { // intermediate resolution and validation DataTarget target = context.resolve(expression, DataTarget.class, context).orElse(expression); target.validate(); // resolve entity class JpaEntity<?> expr = context.resolve(expression, JpaEntity.class, context) .orElseThrow(() -> new InvalidExpressionException( "Failed to resolve expression [" + expression + "] into a JPA entity class")); expr.validate(); return Optional.of( EntityPathExpression.create(resolvePath(ClassUtils.getDefaultClassLoader(), expr.getEntityClass()))); }