Add support for configuring the bean and json node EL Resolvers

flowable · Sep 25, 2023 · 6c5b934 · 6c5b934
1 parent 09fe1bd
commit 6c5b934
Show file tree

Hide file tree

Showing 8 changed files with 138 additions and 6 deletions.
diff --git a/...les/flowable-app-engine/src/main/java/org/flowable/app/engine/AppEngineConfiguration.java b/...les/flowable-app-engine/src/main/java/org/flowable/app/engine/AppEngineConfiguration.java
@@ -17,6 +17,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Consumer;
 
 import javax.sql.DataSource;
 
@@ -134,6 +135,7 @@ public class AppEngineConfiguration extends AbstractEngineConfiguration implemen
     protected DeploymentCache<AppDefinitionCacheEntry> appDefinitionCache;
 
     protected ExpressionManager expressionManager;
+    protected Collection<Consumer<ExpressionManager>> expressionManagerConfigurers;
     protected SchemaManager identityLinkSchemaManager;
     protected SchemaManager variableSchemaManager;
 
@@ -284,6 +286,10 @@ public void initMybatisTypeHandlers(Configuration configuration) {
     public void initExpressionManager() {
         if (expressionManager == null) {
             expressionManager = new DefaultExpressionManager(beans);
+
+            if (expressionManagerConfigurers != null) {
+                expressionManagerConfigurers.forEach(configurer -> configurer.accept(expressionManager));
+            }
         }
     }
 
@@ -688,6 +694,19 @@ public AppEngineConfiguration setExpressionManager(ExpressionManager expressionM
         return this;
     }
 
+    public Collection<Consumer<ExpressionManager>> getExpressionManagerConfigurers() {
+        return expressionManagerConfigurers;
+    }
+
+    @Override
+    public AbstractEngineConfiguration addExpressionManagerConfigurer(Consumer<ExpressionManager> configurer) {
+        if (this.expressionManagerConfigurers == null) {
+            this.expressionManagerConfigurers = new ArrayList<>();
+        }
+        this.expressionManagerConfigurers.add(configurer);
+        return this;
+    }
+
     public SchemaManager getIdentityLinkSchemaManager() {
         return identityLinkSchemaManager;
     }

diff --git a/.../flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/CmmnEngineConfiguration.java b/.../flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/CmmnEngineConfiguration.java
@@ -28,6 +28,7 @@
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
+import java.util.function.Consumer;
 
 import javax.sql.DataSource;
 
@@ -418,6 +419,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
     protected boolean enableCaseDefinitionHistoryLevel;
 
     protected ExpressionManager expressionManager;
+    protected Collection<Consumer<ExpressionManager>> expressionManagerConfigurers;
     protected List<FlowableFunctionDelegate> flowableFunctionDelegates;
     protected List<FlowableFunctionDelegate> customFlowableFunctionDelegates;
     protected List<FlowableAstFunctionCreator> astFunctionCreators;
@@ -949,6 +951,10 @@ public void initExpressionManager() {
                 cmmnExpressionManager.setExpressionCache(new DefaultDeploymentCache<>(expressionCacheSize));
                 cmmnExpressionManager.setExpressionTextLengthCacheLimit(expressionTextLengthCacheLimit);
             }
+
+            if (expressionManagerConfigurers != null) {
+                expressionManagerConfigurers.forEach(configurer -> configurer.accept(cmmnExpressionManager));
+            }
 
             expressionManager = cmmnExpressionManager;
         }
@@ -2638,6 +2644,19 @@ public CmmnEngineConfiguration setExpressionManager(ExpressionManager expression
         return this;
     }
 
+    public Collection<Consumer<ExpressionManager>> getExpressionManagerConfigurers() {
+        return expressionManagerConfigurers;
+    }
+
+    @Override
+    public AbstractEngineConfiguration addExpressionManagerConfigurer(Consumer<ExpressionManager> configurer) {
+        if (this.expressionManagerConfigurers == null) {
+            this.expressionManagerConfigurers = new ArrayList<>();
+        }
+        this.expressionManagerConfigurers.add(configurer);
+        return this;
+    }
+
     public boolean isExpressionCacheEnabled() {
         return isExpressionCacheEnabled;
     }

diff --git a/...les/flowable-dmn-engine/src/main/java/org/flowable/dmn/engine/DmnEngineConfiguration.java b/...les/flowable-dmn-engine/src/main/java/org/flowable/dmn/engine/DmnEngineConfiguration.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Consumer;
 
 import javax.sql.DataSource;
 
@@ -149,6 +150,7 @@ public class DmnEngineConfiguration extends AbstractEngineConfiguration
 
     // EXPRESSION MANAGER /////////////////////////////////////////////
     protected ExpressionManager expressionManager;
+    protected Collection<Consumer<ExpressionManager>> expressionManagerConfigurers;
     protected List<FlowableFunctionDelegate> flowableFunctionDelegates;
     protected List<FlowableFunctionDelegate> customFlowableFunctionDelegates;
     protected Collection<ELResolver> preDefaultELResolvers;
@@ -451,6 +453,10 @@ public void initExpressionManager() {
                 postDefaultELResolvers.forEach(dmnExpressionManager::addPostDefaultResolver);
             }
 
+            if (expressionManagerConfigurers != null) {
+                expressionManagerConfigurers.forEach(configurer -> configurer.accept(dmnExpressionManager));
+            }
+
             expressionManager = dmnExpressionManager;
         }
 
@@ -819,6 +825,19 @@ public DmnEngineConfiguration setExpressionManager(ExpressionManager expressionM
         return this;
     }
 
+    public Collection<Consumer<ExpressionManager>> getExpressionManagerConfigurers() {
+        return expressionManagerConfigurers;
+    }
+
+    @Override
+    public AbstractEngineConfiguration addExpressionManagerConfigurer(Consumer<ExpressionManager> configurer) {
+        if (this.expressionManagerConfigurers == null) {
+            this.expressionManagerConfigurers = new ArrayList<>();
+        }
+        this.expressionManagerConfigurers.add(configurer);
+        return this;
+    }
+
     public List<FlowableFunctionDelegate> getFlowableFunctionDelegates() {
         return flowableFunctionDelegates;
     }

diff --git a/...rc/main/java/org/flowable/common/engine/impl/HasExpressionManagerEngineConfiguration.java b/...rc/main/java/org/flowable/common/engine/impl/HasExpressionManagerEngineConfiguration.java
@@ -12,6 +12,8 @@
  */
 package org.flowable.common.engine.impl;
 
+import java.util.function.Consumer;
+
 import org.flowable.common.engine.impl.el.ExpressionManager;
 
 /**
@@ -22,4 +24,6 @@ public interface HasExpressionManagerEngineConfiguration {
     ExpressionManager getExpressionManager();
 
     AbstractEngineConfiguration setExpressionManager(ExpressionManager expressionManager);
+
+    AbstractEngineConfiguration addExpressionManagerConfigurer(Consumer<ExpressionManager> configurer);
 }
diff --git a/...ine-common/src/main/java/org/flowable/common/engine/impl/el/DefaultExpressionManager.java b/...ine-common/src/main/java/org/flowable/common/engine/impl/el/DefaultExpressionManager.java
@@ -57,8 +57,10 @@ public class DefaultExpressionManager implements ExpressionManager {
     protected int expressionTextLengthCacheLimit = -1;
 
     protected List<ELResolver> preDefaultResolvers;
+    protected ELResolver jsonNodeResolver;
     protected List<ELResolver> postDefaultResolvers;
     protected List<ELResolver> preBeanResolvers;
+    protected ELResolver beanResolver;
 
     protected ELResolver staticElResolver;
 
@@ -134,7 +136,10 @@ protected List<ELResolver> createDefaultElResolvers() {
         elResolvers.add(new ArrayELResolver());
         elResolvers.add(new ListELResolver());
         elResolvers.add(new MapELResolver());
-        elResolvers.add(new JsonNodeELResolver());
+        ELResolver jsonNodeElResolver = createJsonNodeElResolver();
+        if (jsonNodeElResolver != null) {
+            elResolvers.add(jsonNodeElResolver);
+        }
         if (preBeanResolvers != null) {
             elResolvers.addAll(preBeanResolvers);
         }
@@ -156,9 +161,13 @@ protected List<ELResolver> createDefaultElResolvers() {
     protected ELResolver createVariableElResolver() {
         return new VariableContainerELResolver();
     }
+
+    protected ELResolver createJsonNodeElResolver() {
+        return jsonNodeResolver == null ? new JsonNodeELResolver() : jsonNodeResolver;
+    }
 
     protected ELResolver createBeanElResolver() {
-        return new BeanELResolver();
+        return beanResolver == null ? new BeanELResolver() : beanResolver;
     }
 
     @Override
@@ -243,6 +252,16 @@ public void addPreDefaultResolver(ELResolver elResolver) {
         this.preDefaultResolvers.add(elResolver);
     }
 
+    public ELResolver getJsonNodeResolver() {
+        return jsonNodeResolver;
+    }
+
+    public void setJsonNodeResolver(ELResolver jsonNodeResolver) {
+        // When the bean resolver is modified we need to reset the el resolver
+        this.staticElResolver = null;
+        this.jsonNodeResolver = jsonNodeResolver;
+    }
+
     public void addPostDefaultResolver(ELResolver elResolver) {
         if (this.postDefaultResolvers == null) {
             this.postDefaultResolvers = new ArrayList<>();
@@ -258,5 +277,14 @@ public void addPreBeanResolver(ELResolver elResolver) {
 
         this.preBeanResolvers.add(elResolver);
     }
-
+
+    public ELResolver getBeanResolver() {
+        return beanResolver;
+    }
+
+    public void setBeanResolver(ELResolver beanResolver) {
+        // When the bean resolver is modified we need to reset the el resolver
+        this.staticElResolver = null;
+        this.beanResolver = beanResolver;
+    }
 }
diff --git a/...-engine-common/src/main/java/org/flowable/common/engine/impl/javax/el/BeanELResolver.java b/...-engine-common/src/main/java/org/flowable/common/engine/impl/javax/el/BeanELResolver.java
@@ -284,7 +284,7 @@ public Object getValue(ELContext context, Object base, Object property) {
 				Method method = beanProperty.getReadMethod(base);
 				if (method != null) {
 					try {
-						result = method.invoke(base);
+						result = invoke(method, base);
 					} catch (InvocationTargetException e) {
 						throw new ELException(e.getCause());
 					} catch (Exception e) {
@@ -385,7 +385,7 @@ public void setValue(ELContext context, Object base, Object property, Object val
 					throw new PropertyNotWritableException("Cannot write property: " + property);
 				}
 				try {
-					method.invoke(base, value);
+					invoke(method, base, value);
 				} catch (InvocationTargetException e) {
 					throw new ELException("Cannot write property: " + property, e.getCause());
 				} catch (IllegalArgumentException e) {
@@ -473,7 +473,7 @@ public Object invoke(ELContext context, Object base, Object method, Class<?>[] p
 
 			Object[] parameters = Util.buildParameters(target.getParameterTypes(), target.isVarArgs(), params, factory);
 			try {
-				result = target.invoke(base, parameters);
+				result = invoke(target, base, parameters);
 			} catch (InvocationTargetException e) {
 				throw new ELException(e.getCause());
 			} catch (IllegalAccessException e) {
@@ -484,6 +484,10 @@ public Object invoke(ELContext context, Object base, Object method, Class<?>[] p
 		return result;
 	}
 
+	protected Object invoke(Method target, Object base, Object... parameters) throws InvocationTargetException, IllegalAccessException {
+		return target.invoke(base, parameters);
+	}
+
 	/**
 	 * Lookup an expression factory used to coerce method parameters in context under key
 	 * <code>"javax.el.ExpressionFactory"</code>.

diff --git a/...ble-engine/src/main/java/org/flowable/engine/impl/cfg/ProcessEngineConfigurationImpl.java b/...ble-engine/src/main/java/org/flowable/engine/impl/cfg/ProcessEngineConfigurationImpl.java
@@ -31,6 +31,7 @@
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
+import java.util.function.Consumer;
 
 import javax.xml.namespace.QName;
 
@@ -47,6 +48,7 @@
 import org.flowable.common.engine.api.delegate.event.FlowableEventDispatcher;
 import org.flowable.common.engine.api.delegate.event.FlowableEventListener;
 import org.flowable.common.engine.api.scope.ScopeTypes;
+import org.flowable.common.engine.impl.AbstractEngineConfiguration;
 import org.flowable.common.engine.impl.EngineConfigurator;
 import org.flowable.common.engine.impl.EngineDeployer;
 import org.flowable.common.engine.impl.HasExpressionManagerEngineConfiguration;
@@ -721,6 +723,7 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
     protected boolean parallelMultiInstanceAsyncLeave = true;
 
     protected ExpressionManager expressionManager;
+    protected Collection<Consumer<ExpressionManager>> expressionManagerConfigurers;
     protected Collection<ELResolver> preDefaultELResolvers;
     protected Collection<ELResolver> preBeanELResolvers;
     protected Collection<ELResolver> postDefaultELResolvers;
@@ -2367,6 +2370,10 @@ public void initExpressionManager() {
                 postDefaultELResolvers.forEach(processExpressionManager::addPostDefaultResolver);
             }
 
+            if (expressionManagerConfigurers != null) {
+                expressionManagerConfigurers.forEach(configurer -> configurer.accept(processExpressionManager));
+            }
+
             expressionManager = processExpressionManager;
         }
         expressionManager.setFunctionDelegates(flowableFunctionDelegates);
@@ -3261,6 +3268,19 @@ public ProcessEngineConfigurationImpl setExpressionManager(ExpressionManager exp
         return this;
     }
 
+    public Collection<Consumer<ExpressionManager>> getExpressionManagerConfigurers() {
+        return expressionManagerConfigurers;
+    }
+
+    @Override
+    public AbstractEngineConfiguration addExpressionManagerConfigurer(Consumer<ExpressionManager> configurer) {
+        if (this.expressionManagerConfigurers == null) {
+            this.expressionManagerConfigurers = new ArrayList<>();
+        }
+        this.expressionManagerConfigurers.add(configurer);
+        return this;
+    }
+
     public boolean isExpressionCacheEnabled() {
         return isExpressionCacheEnabled;
     }

diff --git a/...istry/src/main/java/org/flowable/eventregistry/impl/EventRegistryEngineConfiguration.java b/...istry/src/main/java/org/flowable/eventregistry/impl/EventRegistryEngineConfiguration.java
@@ -18,6 +18,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Consumer;
 
 import org.flowable.common.engine.api.scope.ScopeTypes;
 import org.flowable.common.engine.impl.AbstractEngineConfiguration;
@@ -123,6 +124,7 @@ public class EventRegistryEngineConfiguration extends AbstractEngineConfiguratio
     protected EventResourceEntityManager resourceEntityManager;
 
     protected ExpressionManager expressionManager;
+    protected Collection<Consumer<ExpressionManager>> expressionManagerConfigurers;
     protected Collection<ELResolver> preDefaultELResolvers;
     protected Collection<ELResolver> preBeanELResolvers;
     protected Collection<ELResolver> postDefaultELResolvers;
@@ -291,6 +293,10 @@ public void initExpressionManager() {
                 postDefaultELResolvers.forEach(eventRegistryExpressionManager::addPostDefaultResolver);
             }
 
+            if (expressionManagerConfigurers != null) {
+                expressionManagerConfigurers.forEach(configurer -> configurer.accept(eventRegistryExpressionManager));
+            }
+
             expressionManager = eventRegistryExpressionManager;
         }
     }
@@ -906,6 +912,19 @@ public EventRegistryEngineConfiguration setExpressionManager(ExpressionManager e
         return this;
     }
 
+    public Collection<Consumer<ExpressionManager>> getExpressionManagerConfigurers() {
+        return expressionManagerConfigurers;
+    }
+
+    @Override
+    public AbstractEngineConfiguration addExpressionManagerConfigurer(Consumer<ExpressionManager> configurer) {
+        if (this.expressionManagerConfigurers == null) {
+            this.expressionManagerConfigurers = new ArrayList<>();
+        }
+        this.expressionManagerConfigurers.add(configurer);
+        return this;
+    }
+
     public Collection<ELResolver> getPreDefaultELResolvers() {
         return preDefaultELResolvers;
     }