Updated with fixes from CXF 3.5.0
diff --git a/tomee/apache-tomee/src/patch/java/org/apache/cxf/jaxrs/utils/AnnotationUtils.java b/tomee/apache-tomee/src/patch/java/org/apache/cxf/jaxrs/utils/AnnotationUtils.java
new file mode 100644
index 0000000..8d49e2d
--- /dev/null
+++ b/tomee/apache-tomee/src/patch/java/org/apache/cxf/jaxrs/utils/AnnotationUtils.java
@@ -0,0 +1,308 @@
+/**
+ * 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.cxf.jaxrs.utils;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.CookieParam;
+import javax.ws.rs.DefaultValue;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.NameBinding;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Priorities;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ClassHelper;
+
+public final class AnnotationUtils {
+    private static final Logger LOG = LogUtils.getL7dLogger(AnnotationUtils.class);
+    private static final Class<? extends Annotation> PRIORITY_API =
+            (Class<? extends Annotation>) loadClassOrNull("javax.annotation.Priority");
+    private static final Method PRIORITY_VALUE = getMethodOrNull(PRIORITY_API, "value");
+
+    private static final Set<Class<?>> PARAM_ANNOTATION_CLASSES;
+    private static final Set<Class<?>> METHOD_ANNOTATION_CLASSES;
+    static {
+        PARAM_ANNOTATION_CLASSES = initParamAnnotationClasses();
+        METHOD_ANNOTATION_CLASSES = initMethodAnnotationClasses();
+    }
+
+    private AnnotationUtils() {
+
+    }
+
+    private static Method getMethodOrNull(final Class<?> type, final String name) {
+        if (type == null) {
+            return null;
+        }
+        try {
+            return type.getMethod(name);
+        } catch (final NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    private static Class<? extends Annotation> loadClassOrNull(final String name) {
+        try {
+            return org.apache.cxf.common.classloader.ClassLoaderUtils.loadClass(
+                    name, AnnotationUtils.class, Annotation.class);
+        } catch (final ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    private static Set<Class<?>> initParamAnnotationClasses() {
+        Set<Class<?>> classes = new HashSet<>();
+        classes.add(PathParam.class);
+        classes.add(QueryParam.class);
+        classes.add(MatrixParam.class);
+        classes.add(HeaderParam.class);
+        classes.add(CookieParam.class);
+        classes.add(FormParam.class);
+        classes.add(BeanParam.class);
+        return classes;
+    }
+
+    private static Set<Class<?>> initMethodAnnotationClasses() {
+        Set<Class<?>> classes = new HashSet<>();
+        classes.add(HttpMethod.class);
+        classes.add(Path.class);
+        classes.add(Produces.class);
+        classes.add(Consumes.class);
+        return classes;
+    }
+
+    public static int getBindingPriority(Class<?> providerCls) {
+        if (PRIORITY_API == null) {
+            return Priorities.USER;
+        }
+        Annotation b = getClassAnnotation(providerCls, PRIORITY_API);
+        try {
+            return b == null ? Priorities.USER : Integer.class.cast(PRIORITY_VALUE.invoke(b));
+        } catch (final IllegalAccessException | InvocationTargetException e) {
+            return Priorities.USER;
+        }
+    }
+    
+    public static Set<String> getInstanceNameBindings(Bus bus, Object obj) {
+        final Class<?> realClazz = ClassHelper.getRealClass(bus, obj);
+        return getNameBindings(realClazz.getAnnotations());
+    }
+    
+    public static Set<String> getNameBindings(Bus bus, Class<?> clazz) {
+        final Class<?> realClazz = ClassHelper.getRealClassFromClass(bus, clazz);
+        return getNameBindings(realClazz.getAnnotations());
+    }
+    
+    public static Set<String> getNameBindings(Annotation[] targetAnns) {
+        if (targetAnns.length == 0) {
+            return Collections.emptySet();
+        }
+        Set<String> names = new LinkedHashSet<>();
+        for (Annotation a : targetAnns) {
+            NameBinding nb = a.annotationType().getAnnotation(NameBinding.class);
+            if (nb != null) {
+                names.add(a.annotationType().getName());
+            }
+        }
+        return names;
+    }
+
+    public static boolean isParamAnnotationClass(Class<?> annotationClass) {
+        return PARAM_ANNOTATION_CLASSES.contains(annotationClass);
+    }
+
+    public static boolean isValidParamAnnotationClass(Class<?> annotationClass) {
+        return PARAM_ANNOTATION_CLASSES.contains(annotationClass) || Context.class == annotationClass;
+    }
+
+    public static boolean isValidParamAnnotations(Annotation[] paramAnnotations) {
+        for (Annotation a : paramAnnotations) {
+            if (AnnotationUtils.isValidParamAnnotationClass(a.annotationType())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isMethodAnnotation(Annotation a) {
+        return METHOD_ANNOTATION_CLASSES.contains(a.annotationType())
+               || a.annotationType().getAnnotation(HttpMethod.class) != null;
+    }
+
+    public static String getAnnotationValue(Annotation a) {
+        String value = null;
+        if (a.annotationType() == PathParam.class) {
+            value = ((PathParam)a).value();
+        } else if (a.annotationType() == QueryParam.class) {
+            value = ((QueryParam)a).value();
+        } else if (a.annotationType() == MatrixParam.class) {
+            value = ((MatrixParam)a).value();
+        } else if (a.annotationType() == HeaderParam.class) {
+            value = ((HeaderParam)a).value();
+        } else if (a.annotationType() == CookieParam.class) {
+            value = ((CookieParam)a).value();
+        } else if (a.annotationType() == FormParam.class) {
+            value = ((FormParam)a).value();
+        }
+        return value;
+    }
+
+    public static <T> T getAnnotation(Annotation[] anns, Class<T> type) {
+        if (anns == null) {
+            return null;
+        }
+        for (Annotation a : anns) {
+            if (a.annotationType() == type) {
+                return type.cast(a);
+            }
+        }
+        return null;
+    }
+
+    public static Method getAnnotatedMethod(Class<?> serviceClass, Method m) {
+        Method annotatedMethod = doGetAnnotatedMethod(serviceClass, m);
+        return annotatedMethod == null ? m : annotatedMethod;
+    }
+
+    private static Method doGetAnnotatedMethod(Class<?> serviceClass, Method m) {
+
+        if (m != null) {
+            if (!m.isBridge() && !m.isSynthetic()) {
+                //the bridge/synthetic methods may not have the parameter annotations
+                //thus we will need to search the super classes/interfaces to make 
+                //sure we get the proper method that would also have the parameters annotated
+                //properly
+                for (Annotation a : m.getAnnotations()) {
+                    if (AnnotationUtils.isMethodAnnotation(a)) {
+                        return m;
+                    }
+                }
+                for (Annotation[] paramAnnotations : m.getParameterAnnotations()) {
+                    if (isValidParamAnnotations(paramAnnotations)) {
+                        LOG.warning("Method " + m.getName() + " in " + m.getDeclaringClass().getName()
+                                     + " has no JAX-RS Path or HTTP Method annotations");
+                        return m;
+                    }
+                }
+            }
+            Class<?> declaringClass = m.getDeclaringClass();
+            Class<?> superC = declaringClass.getSuperclass();
+            if (superC != null && Object.class != superC) {
+                try {
+                    Method method = doGetAnnotatedMethod(serviceClass,
+                                                         superC.getMethod(m.getName(), m.getParameterTypes()));
+                    if (method != null) {
+                        return method;
+                    }
+                } catch (NoSuchMethodException ex) {
+                    // ignore
+                }
+            }
+            for (Class<?> i : declaringClass.getInterfaces()) {
+                try {
+                    Method method = doGetAnnotatedMethod(serviceClass,
+                                                         i.getMethod(m.getName(), m.getParameterTypes()));
+                    if (method != null) {
+                        return method;
+                    }
+                } catch (NoSuchMethodException ex) {
+                    // ignore
+                }
+            }
+            if (declaringClass != serviceClass && !declaringClass.isInterface()) {
+                for (Class<?> i : serviceClass.getInterfaces()) {
+                    try {
+                        Method method = doGetAnnotatedMethod(serviceClass,
+                                                             i.getMethod(m.getName(), m.getParameterTypes()));
+                        if (method != null) {
+                            return method;
+                        }
+                    } catch (NoSuchMethodException ex) {
+                        // ignore
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public static String getHttpMethodValue(Method m) {
+        for (Annotation a : m.getAnnotations()) {
+            HttpMethod httpM = a.annotationType().getAnnotation(HttpMethod.class);
+            if (httpM != null) {
+                return httpM.value();
+            }
+        }
+        return null;
+    }
+
+    public static <A extends Annotation> A getMethodAnnotation(Method m, Class<A> aClass) {
+        return m == null ? null : m.getAnnotation(aClass);
+    }
+
+    public static <A extends Annotation> A getClassAnnotation(Class<?> c, Class<A> aClass) {
+        if (c == null) {
+            return null;
+        }
+        A p = c.getAnnotation(aClass);
+        if (p != null) {
+            return p;
+        }
+
+        p = getClassAnnotation(c.getSuperclass(), aClass);
+        if (p != null) {
+            return p;
+        }
+
+        // finally try the first one on the interface
+        for (Class<?> i : c.getInterfaces()) {
+            p = getClassAnnotation(i, aClass);
+            if (p != null) {
+                return p;
+            }
+        }
+        return null;
+    }
+
+    public static String getDefaultParameterValue(Annotation[] anns) {
+
+        DefaultValue dv = AnnotationUtils.getAnnotation(anns, DefaultValue.class);
+        return dv != null ? dv.value() : null;
+    }
+
+}