diff --git a/impl/src/main/java/org/apache/myfaces/el/resolver/MethodHandleBeanELResolver.java b/impl/src/main/java/org/apache/myfaces/el/resolver/MethodHandleBeanELResolver.java
index 8bcaa93..3c808d2 100644
--- a/impl/src/main/java/org/apache/myfaces/el/resolver/MethodHandleBeanELResolver.java
+++ b/impl/src/main/java/org/apache/myfaces/el/resolver/MethodHandleBeanELResolver.java
@@ -18,70 +18,36 @@
  */
 package org.apache.myfaces.el.resolver;
 
-import java.beans.Introspector;
-import java.beans.PropertyDescriptor;
-import java.lang.invoke.CallSite;
-import java.lang.invoke.LambdaConversionException;
-import java.lang.invoke.LambdaMetafactory;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.BiConsumer;
-import java.util.function.Function;
-import java.util.function.ObjDoubleConsumer;
-import java.util.function.ObjIntConsumer;
-import java.util.function.ObjLongConsumer;
-import java.util.logging.Logger;
 
 import javax.el.BeanELResolver;
 import javax.el.ELContext;
 import javax.el.ELException;
-import javax.el.PropertyNotFoundException;
 import javax.el.PropertyNotWritableException;
-import org.apache.myfaces.bean.ManagedBeanExtension;
+import org.apache.myfaces.util.lang.MethodHandleUtils;
 
 public class MethodHandleBeanELResolver extends BeanELResolver
 {
-    private static final Logger LOG = Logger.getLogger(ManagedBeanExtension.class.getName());
-
-    private static Method privateLookupIn;
-
-    static
-    {
-        try
-        {
-            privateLookupIn = MethodHandles.class.getMethod("privateLookupIn", Class.class,
-                    MethodHandles.Lookup.class);
-        }
-        catch (Exception e)
-        {
-            LOG.info("MethodHandles#privateLookupIn not found or accessible. Skip using "
-                    + MethodHandleBeanELResolver.class.getName());
-        }
-    }
-
-    private final ConcurrentHashMap<String, Map<String, PropertyInfo>> cache;
+    private final ConcurrentHashMap<String, Map<String, MethodHandleUtils.LambdaPropertyDescriptor>> cache;
 
     public MethodHandleBeanELResolver()
     {
-        if (privateLookupIn == null)
+        if (MethodHandleUtils.isSupported())
         {
-            cache = null;
+            cache = new ConcurrentHashMap<>(1000);
         }
         else
         {
-            cache = new ConcurrentHashMap<>(1000);
+            cache = null;
         }
     }
 
     @Override
     public Class<?> getType(ELContext context, Object base, Object property)
     {
-        if (privateLookupIn == null)
+        if (!MethodHandleUtils.isSupported())
         {
             return super.getType(context, base, property);
         }
@@ -94,14 +60,14 @@
 
         context.setPropertyResolved(base, property);
 
-        return getPropertyInfo(base, property).type;
+        return getPropertyDescriptor(base, property).getType();
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public Object getValue(ELContext context, Object base, Object property)
     {
-        if (privateLookupIn == null)
+        if (!MethodHandleUtils.isSupported())
         {
             return super.getValue(context, base, property);
         }
@@ -116,7 +82,7 @@
 
         try
         {
-            return getPropertyInfo(base, property).getter.apply(base);
+            return getPropertyDescriptor(base, property).getGetter().apply(base);
         }
         catch (Exception e)
         {
@@ -128,7 +94,7 @@
     @Override
     public void setValue(ELContext context, Object base, Object property, Object value)
     {
-        if (privateLookupIn == null)
+        if (!MethodHandleUtils.isSupported())
         {
             super.setValue(context, base, property, value);
             return;
@@ -142,8 +108,8 @@
 
         context.setPropertyResolved(base, property);
 
-        PropertyInfo propertyInfo = getPropertyInfo(base, property);
-        if (propertyInfo.setter == null)
+        MethodHandleUtils.LambdaPropertyDescriptor propertyDescriptor = getPropertyDescriptor(base, property);
+        if (propertyDescriptor.getSetter() == null)
         {
             throw new PropertyNotWritableException("Property \"" + (String) property
                     + "\" in \"" + base.getClass().getName() + "\" is not writable!");
@@ -151,7 +117,7 @@
 
         try
         {
-            propertyInfo.setter.accept(base, value);
+            propertyDescriptor.getSetter().accept(base, value);
         }
         catch (Exception e)
         {
@@ -160,17 +126,9 @@
     }
 
     @Override
-    public Object invoke(ELContext context, Object base, Object method, Class<?>[] paramTypes, Object[] params)
-    {
-        // just use the original BeanELResolver method
-        // it's higher effort to implement this
-        return super.invoke(context, base, method, paramTypes, params);
-    }
-
-    @Override
     public boolean isReadOnly(ELContext context, Object base, Object property)
     {
-        if (privateLookupIn == null)
+        if (!MethodHandleUtils.isSupported())
         {
             return super.isReadOnly(context, base, property);
         }
@@ -183,13 +141,13 @@
 
         context.setPropertyResolved(base, property);
 
-        return getPropertyInfo(base, property).setter == null;
+        return getPropertyDescriptor(base, property).getSetter() == null;
     }
 
     @Override
     public Class<?> getCommonPropertyType(ELContext context, Object base)
     {
-        if (privateLookupIn == null)
+        if (!MethodHandleUtils.isSupported())
         {
             return super.getCommonPropertyType(context, base);
         }
@@ -202,182 +160,11 @@
         return null;
     }
 
-    protected class PropertyInfo
+    protected MethodHandleUtils.LambdaPropertyDescriptor getPropertyDescriptor(Object base, Object property)
     {
-        Class<?> type;
-        Function getter;
-        BiConsumer setter;
+        Map<String, MethodHandleUtils.LambdaPropertyDescriptor> beanCache = cache.computeIfAbsent(
+                base.getClass().getName(), k -> MethodHandleUtils.getLambdaPropertyDescriptors(base.getClass()));
+        return beanCache.get((String) property);
     }
 
-    protected PropertyInfo getPropertyInfo(Object base, Object property)
-    {
-        Map<String, PropertyInfo> beanCache = cache.computeIfAbsent(base.getClass().getName(),
-                k -> new ConcurrentHashMap<>());
-        return beanCache.computeIfAbsent((String) property, k -> initPropertyInfo(base.getClass(), k));
-    }
-
-    protected PropertyInfo initPropertyInfo(Class<?> target, String fieldName)
-    {
-
-        PropertyInfo info = new PropertyInfo();
-
-        try
-        {
-            PropertyDescriptor pd = null;
-            for (PropertyDescriptor cpd : Introspector.getBeanInfo(target, Object.class).getPropertyDescriptors())
-            {
-                if (fieldName.equals(cpd.getName()))
-                {
-                    pd = cpd;
-                }
-            }
-
-            if (pd == null)
-            {
-                throw new PropertyNotFoundException("Property \"" + fieldName + "\" not found on \""
-                        + target.getName() + "\"");
-            }
-
-            info.type = pd.getPropertyType();
-
-            MethodHandles.Lookup lookup = (MethodHandles.Lookup) privateLookupIn.invoke(null, target,
-                    MethodHandles.lookup());
-
-            Method getter = pd.getReadMethod();
-            if (getter != null)
-            {
-                MethodHandle getterHandle = lookup.unreflect(getter);
-                CallSite getterCallSite = LambdaMetafactory.metafactory(lookup,
-                        "apply",
-                        MethodType.methodType(Function.class),
-                        MethodType.methodType(Object.class, Object.class),
-                        getterHandle,
-                        getterHandle.type());
-                info.getter = (Function) getterCallSite.getTarget().invokeExact();
-            }
-
-            Method setter = pd.getWriteMethod();
-            if (setter != null)
-            {
-                MethodHandle setterHandle = lookup.unreflect(setter);
-                info.setter = createSetter(lookup, info, setterHandle);
-            }
-        }
-        catch (Throwable e)
-        {
-            throw new ELException(e);
-        }
-
-        return info;
-    }
-
-    @SuppressWarnings("unchecked")
-    protected BiConsumer createSetter(MethodHandles.Lookup lookup, PropertyInfo propertyInfo,
-            MethodHandle setterHandle)
-            throws LambdaConversionException, Throwable
-    {
-        // special handling for primitives required, see https://dzone.com/articles/setters-method-handles-and-java-11
-        if (propertyInfo.type.isPrimitive())
-        {
-            if (propertyInfo.type == double.class)
-            {
-                ObjDoubleConsumer consumer = (ObjDoubleConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjDoubleConsumer.class, double.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (double) b);
-            }
-            else if (propertyInfo.type == int.class)
-            {
-                ObjIntConsumer consumer = (ObjIntConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjIntConsumer.class, int.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (int) b);
-            }
-            else if (propertyInfo.type == long.class)
-            {
-                ObjLongConsumer consumer = (ObjLongConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjLongConsumer.class, long.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (long) b);
-            }
-            else if (propertyInfo.type == float.class)
-            {
-                ObjFloatConsumer consumer = (ObjFloatConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjFloatConsumer.class, float.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (float) b);
-            }
-            else if (propertyInfo.type == byte.class)
-            {
-                ObjByteConsumer consumer = (ObjByteConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjByteConsumer.class, byte.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (byte) b);
-            }
-            else if (propertyInfo.type == char.class)
-            {
-                ObjCharConsumer consumer = (ObjCharConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjCharConsumer.class, char.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (char) b);
-            }
-            else if (propertyInfo.type == short.class)
-            {
-                ObjShortConsumer consumer = (ObjShortConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjShortConsumer.class, short.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (short) b);
-            }
-            else if (propertyInfo.type == boolean.class)
-            {
-                ObjBooleanConsumer consumer = (ObjBooleanConsumer) createSetterCallSite(
-                        lookup, setterHandle, ObjBooleanConsumer.class, boolean.class).getTarget().invokeExact();
-                return (a, b) -> consumer.accept(a, (boolean) b);
-            }
-            else
-            {
-                throw new RuntimeException("Type is not supported yet: " + propertyInfo.type.getName());
-            }
-        }
-        else
-        {
-            return (BiConsumer) createSetterCallSite(lookup, setterHandle, BiConsumer.class, Object.class).getTarget()
-                    .invokeExact();
-        }
-    }
-
-    protected CallSite createSetterCallSite(MethodHandles.Lookup lookup, MethodHandle setter, Class<?> interfaceType,
-            Class<?> valueType)
-            throws LambdaConversionException
-    {
-        return LambdaMetafactory.metafactory(lookup,
-                "accept",
-                MethodType.methodType(interfaceType),
-                MethodType.methodType(void.class, Object.class, valueType),
-                setter,
-                setter.type());
-    }
-
-    @FunctionalInterface
-    public interface ObjFloatConsumer<T extends Object>
-    {
-        public void accept(T t, float i);
-    }
-
-    @FunctionalInterface
-    public interface ObjByteConsumer<T extends Object>
-    {
-        public void accept(T t, byte i);
-    }
-
-    @FunctionalInterface
-    public interface ObjCharConsumer<T extends Object>
-    {
-        public void accept(T t, char i);
-    }
-
-    @FunctionalInterface
-    public interface ObjShortConsumer<T extends Object>
-    {
-        public void accept(T t, short i);
-    }
-
-    @FunctionalInterface
-    public interface ObjBooleanConsumer<T extends Object>
-    {
-        public void accept(T t, boolean i);
-    }
 }
diff --git a/impl/src/main/java/org/apache/myfaces/util/lang/MethodHandleUtils.java b/impl/src/main/java/org/apache/myfaces/util/lang/MethodHandleUtils.java
new file mode 100644
index 0000000..df62baa
--- /dev/null
+++ b/impl/src/main/java/org/apache/myfaces/util/lang/MethodHandleUtils.java
@@ -0,0 +1,236 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.myfaces.util.lang;
+
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.lang.invoke.CallSite;
+import java.lang.invoke.LambdaConversionException;
+import java.lang.invoke.LambdaMetafactory;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.ObjIntConsumer;
+import java.util.function.ObjLongConsumer;
+import javax.el.ELException;
+
+public class MethodHandleUtils
+{
+    private static Method privateLookupIn;
+
+    static
+    {
+        try
+        {
+            privateLookupIn = MethodHandles.class.getMethod("privateLookupIn", Class.class,
+                    MethodHandles.Lookup.class);
+        }
+        catch (Exception e)
+        {
+        }
+    }
+
+    public static boolean isSupported()
+    {
+        return privateLookupIn != null;
+    }
+    
+    public static class LambdaPropertyDescriptor
+    {
+        private Class<?> type;
+        private Function getter;
+        private BiConsumer setter;
+
+        public Class<?> getType()
+        {
+            return type;
+        }
+
+        public Function getGetter()
+        {
+            return getter;
+        }
+
+        public BiConsumer getSetter()
+        {
+            return setter;
+        }
+    }
+
+    public static HashMap<String, LambdaPropertyDescriptor> getLambdaPropertyDescriptors(Class<?> target)
+    {
+        try
+        {            
+            PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(target).getPropertyDescriptors();
+            HashMap<String, LambdaPropertyDescriptor> properties = new HashMap<>(propertyDescriptors.length);
+
+            for (PropertyDescriptor pd : Introspector.getBeanInfo(target).getPropertyDescriptors())
+            {
+                LambdaPropertyDescriptor lpd = new LambdaPropertyDescriptor();
+                lpd.type = pd.getPropertyType();
+                
+                MethodHandles.Lookup lookup = (MethodHandles.Lookup) privateLookupIn.invoke(null, target,
+                        MethodHandles.lookup());
+
+                Method getter = pd.getReadMethod();
+                if (getter != null)
+                {
+                    MethodHandle getterHandle = lookup.unreflect(getter);
+                    CallSite getterCallSite = LambdaMetafactory.metafactory(lookup,
+                            "apply",
+                            MethodType.methodType(Function.class),
+                            MethodType.methodType(Object.class, Object.class),
+                            getterHandle,
+                            getterHandle.type());
+                    lpd.getter = (Function) getterCallSite.getTarget().invokeExact();
+                }
+
+                Method setter = pd.getWriteMethod();
+                if (setter != null)
+                {
+                    MethodHandle setterHandle = lookup.unreflect(setter);
+                    lpd.setter = createSetter(lookup, lpd, setterHandle);
+                }
+                
+                properties.put(pd.getName(), lpd);
+            }
+            
+            return properties;
+        }
+        catch (Throwable e)
+        {
+            throw new ELException(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    protected static BiConsumer createSetter(MethodHandles.Lookup lookup, LambdaPropertyDescriptor propertyInfo,
+            MethodHandle setterHandle)
+            throws LambdaConversionException, Throwable
+    {
+        // special handling for primitives required, see https://dzone.com/articles/setters-method-handles-and-java-11
+        if (propertyInfo.type.isPrimitive())
+        {
+            if (propertyInfo.type == double.class)
+            {
+                ObjDoubleConsumer consumer = (ObjDoubleConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjDoubleConsumer.class, double.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (double) b);
+            }
+            else if (propertyInfo.type == int.class)
+            {
+                ObjIntConsumer consumer = (ObjIntConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjIntConsumer.class, int.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (int) b);
+            }
+            else if (propertyInfo.type == long.class)
+            {
+                ObjLongConsumer consumer = (ObjLongConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjLongConsumer.class, long.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (long) b);
+            }
+            else if (propertyInfo.type == float.class)
+            {
+                ObjFloatConsumer consumer = (ObjFloatConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjFloatConsumer.class, float.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (float) b);
+            }
+            else if (propertyInfo.type == byte.class)
+            {
+                ObjByteConsumer consumer = (ObjByteConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjByteConsumer.class, byte.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (byte) b);
+            }
+            else if (propertyInfo.type == char.class)
+            {
+                ObjCharConsumer consumer = (ObjCharConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjCharConsumer.class, char.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (char) b);
+            }
+            else if (propertyInfo.type == short.class)
+            {
+                ObjShortConsumer consumer = (ObjShortConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjShortConsumer.class, short.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (short) b);
+            }
+            else if (propertyInfo.type == boolean.class)
+            {
+                ObjBooleanConsumer consumer = (ObjBooleanConsumer) createSetterCallSite(
+                        lookup, setterHandle, ObjBooleanConsumer.class, boolean.class).getTarget().invokeExact();
+                return (a, b) -> consumer.accept(a, (boolean) b);
+            }
+            else
+            {
+                throw new RuntimeException("Type is not supported yet: " + propertyInfo.type.getName());
+            }
+        }
+        else
+        {
+            return (BiConsumer) createSetterCallSite(lookup, setterHandle, BiConsumer.class, Object.class).getTarget()
+                    .invokeExact();
+        }
+    }
+
+    protected static CallSite createSetterCallSite(MethodHandles.Lookup lookup, MethodHandle setter,
+            Class<?> interfaceType, Class<?> valueType)
+            throws LambdaConversionException
+    {
+        return LambdaMetafactory.metafactory(lookup,
+                "accept",
+                MethodType.methodType(interfaceType),
+                MethodType.methodType(void.class, Object.class, valueType),
+                setter,
+                setter.type());
+    }
+
+    @FunctionalInterface
+    public interface ObjFloatConsumer<T extends Object>
+    {
+        public void accept(T t, float i);
+    }
+
+    @FunctionalInterface
+    public interface ObjByteConsumer<T extends Object>
+    {
+        public void accept(T t, byte i);
+    }
+
+    @FunctionalInterface
+    public interface ObjCharConsumer<T extends Object>
+    {
+        public void accept(T t, char i);
+    }
+
+    @FunctionalInterface
+    public interface ObjShortConsumer<T extends Object>
+    {
+        public void accept(T t, short i);
+    }
+
+    @FunctionalInterface
+    public interface ObjBooleanConsumer<T extends Object>
+    {
+        public void accept(T t, boolean i);
+    }
+}