/** * Constructs a {@link ExpressionFactory} via {@link Thread#getContextClassLoader() Thread.currentThread().getContextClassLoader()} * or the provided {@link ClassLoader} * * @param classLoader class loader to resolve {@link ExpressionFactory} * @return {@link ExpressionFactory} instance * @throws IllegalStateException if javax.el is not on the class path or a {@link ExpressionFactory} instance could not be constructed */ public static ExpressionFactory newInstance(ClassLoader classLoader) throws IllegalStateException { resolveClassForName(); return resolveViaClassLoaderOrTCCL(classLoader); }
private ELEngine getELEngine() { if (elEngine == null) { if (ELExpressionFactory.isSupported()) { if (RuntimeUtils.isOSGi()) { ClassLoader classLoader = getClass().getClassLoader(); return new TcclELEngine(ELExpressionFactory.newInstance(classLoader), classLoader); } else { return new DefaultELEngine(ELExpressionFactory.newInstance()); } } else { return new NoopELEngine(); } } else { return elEngine; } }
/** * Checks whether javax.el is on the classpath and a {@link ExpressionFactory} can be constructed * * @return if javax.el can be used */ public static Boolean isSupported() { return isSupported(ELExpressionFactory.class.getClassLoader()); }
@Override public String getNodeValue(Element element) { String expression = super.getNodeValue(element); return elEngine.resolve(expression); } }
/** * Checks whether javax.el is on the classpath and a {@link ExpressionFactory} can be constructed * * @param classLoader class loader to resolve {@link ExpressionFactory} * @return if javax.el can be used */ public static Boolean isSupported(ClassLoader classLoader) { if (isJavaxEL == null) { try { isJavaxEL = newInstance(classLoader) != null; LOG.info("javax.el support is {}", isJavaxEL); } catch (IllegalStateException ex) { LOG.warn("javax.el is not supported; {}", ex.getMessage()); isJavaxEL = false; } } return isJavaxEL; }
public DefaultELEngine(ExpressionFactory expressionFactory) { ELResolver resolver = new CompositeELResolver() { { add(new ArrayELResolver()); add(new ListELResolver()); add(new MapELResolver()); add(new BeanELResolver()); add(new ResourceBundleELResolver()); } }; this.elContext = new SimpleELContext(resolver); this.expressionFactory = expressionFactory; }
@Override public void build() { if (!StringUtils.isBlank(name) && !StringUtils.isBlank(clazz)) { elEngine.setVariable(name, clazz); } super.build(); } }
/** * Note, this method does nothing * * @param key key to store * @param value value to resolve * @param <T> generic type of value */ @Override public <T> void setVariable(String key, T value) { setVariable(key, value, value.getClass()); }
/** * {@inheritDoc} */ @Override public <T> void setVariable(String key, T value) { setVariable(key, value, value.getClass()); }
@Override public String getAttribute(Element element, String attribute) { String expression = super.getAttribute(element, attribute); return elEngine.resolve(expression); }
/** * Constructs a {@link ExpressionFactory} via {@link Thread#getContextClassLoader() Thread.currentThread().getContextClassLoader()} * or the provided {@link ClassLoader} * * @param classLoader class loader to resolve {@link ExpressionFactory} * @return {@link ExpressionFactory} instance * @throws IllegalStateException if javax.el is not on the class path or a {@link ExpressionFactory} instance could not be constructed */ public static ExpressionFactory newInstance(ClassLoader classLoader) throws IllegalStateException { resolveClassForName(); return resolveViaClassLoaderOrTCCL(classLoader); }
private static ExpressionFactory resolveViaClassLoaderOrTCCL(ClassLoader classLoader) { ExpressionFactory answer; ClassLoader tccl = Thread.currentThread().getContextClassLoader(); try { ClassLoader newTccl = classLoader == null ? tccl : classLoader; Thread.currentThread().setContextClassLoader(newTccl); answer = newInstance(); } catch (ClassCastException ex) { throw new IllegalStateException("Failed to resolve ExpressionFactory, " + ex.getMessage(), ex); } finally { Thread.currentThread().setContextClassLoader(tccl); } return answer; }
private void parseVariables(Element element) { NodeList nl = element.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element)node; debugElement(ele); if (VARIABLE_ELEMENT.equals(ele.getNodeName())) { ELEngine engine = beanContainer.getElEngine(); if (engine != null) { String name = getAttribute(ele, NAME_ATTRIBUTE); String value = getNodeValue(ele); engine.setVariable(name, value); } } } } }
@Override public ClassMap build(Configuration configuration, BeanContainer beanContainer, DestBeanCreator destBeanCreator, PropertyDescriptorFactory propertyDescriptorFactory) { if (!StringUtils.isBlank(beanFactory)) { setBeanFactory(elEngine.resolve(beanFactory)); } return super.build(configuration, beanContainer, destBeanCreator, propertyDescriptorFactory); } }
@Override public Configuration build(BeanContainer beanContainer) { if (!StringUtils.isBlank(beanFactory)) { setBeanFactory(elEngine.resolve(beanFactory)); } return super.build(beanContainer); } }
@Override public CustomConverterDescription build(BeanContainer beanContainer) { if (!StringUtils.isBlank(type)) { setType(elEngine.resolve(type)); } return super.build(beanContainer); } }
@Override public List<Class<RuntimeException>> build(BeanContainer beanContainer) { List<String> resolved = new ArrayList<>(); if (exceptions != null) { for (String current : exceptions) { resolved.add(elEngine.resolve(current)); } } setExceptions(resolved); return super.build(beanContainer); } }
@Override public List<CopyByReference> build() { List<String> resolved = new ArrayList<>(); if (copyByReference != null) { for (String current : copyByReference) { resolved.add(elEngine.resolve(current)); } } setCopyByReference(resolved); return super.build(); } }
@Override public FieldMap build(ClassMap classMap, BeanContainer beanContainer, DestBeanCreator destBeanCreator, PropertyDescriptorFactory propertyDescriptorFactory) { if (!StringUtils.isBlank(aHint)) { setAHint(elEngine.resolve(aHint)); setBHint(elEngine.resolve(bHint)); setADeepIndexHint(elEngine.resolve(aDeepIndexHint)); setBDeepIndexHint(elEngine.resolve(bDeepIndexHint)); setMapId(elEngine.resolve(mapId)); setCustomConverter(elEngine.resolve(customConverter)); setCustomConverterId(elEngine.resolve(customConverterId)); setCustomConverterParam(elEngine.resolve(customConverterParam));