Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.cxf.jaxrs.utils.ResourceUtils Maven / Gradle / Ivy
/**
* 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.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ws.rs.ApplicationPath;
import javax.ws.rs.BeanParam;
import javax.ws.rs.CookieParam;
import javax.ws.rs.Encoded;
import javax.ws.rs.FormParam;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.MatrixParam;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;
import javax.xml.namespace.QName;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.apache.cxf.Bus;
import org.apache.cxf.BusFactory;
import org.apache.cxf.common.classloader.ClassLoaderUtils;
import org.apache.cxf.common.i18n.BundleUtils;
import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.common.util.StringUtils;
import org.apache.cxf.feature.Feature;
import org.apache.cxf.helpers.CastUtils;
import org.apache.cxf.helpers.DOMUtils;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
import org.apache.cxf.jaxrs.ext.DefaultMethod;
import org.apache.cxf.jaxrs.ext.xml.ElementClass;
import org.apache.cxf.jaxrs.ext.xml.XMLName;
import org.apache.cxf.jaxrs.lifecycle.PerRequestResourceProvider;
import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
import org.apache.cxf.jaxrs.model.ClassResourceInfo;
import org.apache.cxf.jaxrs.model.MethodDispatcher;
import org.apache.cxf.jaxrs.model.OperationResourceInfo;
import org.apache.cxf.jaxrs.model.Parameter;
import org.apache.cxf.jaxrs.model.ParameterType;
import org.apache.cxf.jaxrs.model.ResourceTypes;
import org.apache.cxf.jaxrs.model.URITemplate;
import org.apache.cxf.jaxrs.model.UserOperation;
import org.apache.cxf.jaxrs.model.UserResource;
import org.apache.cxf.jaxrs.provider.JAXBElementProvider;
import org.apache.cxf.message.Message;
import org.apache.cxf.message.MessageImpl;
import org.apache.cxf.resource.ResourceManager;
import org.apache.cxf.staxutils.StaxUtils;
public final class ResourceUtils {
private static final Logger LOG = LogUtils.getL7dLogger(ResourceUtils.class);
private static final ResourceBundle BUNDLE = BundleUtils.getBundle(ResourceUtils.class);
private static final String CLASSPATH_PREFIX = "classpath:";
private static final String NOT_RESOURCE_METHOD_MESSAGE_ID = "NOT_RESOURCE_METHOD";
private static final String NOT_SUSPENDED_ASYNC_MESSAGE_ID = "NOT_SUSPENDED_ASYNC_METHOD";
private static final String NO_VOID_RETURN_ASYNC_MESSAGE_ID = "NO_VOID_RETURN_ASYNC_METHOD";
private static final Set SERVER_PROVIDER_CLASS_NAMES;
static {
SERVER_PROVIDER_CLASS_NAMES = new HashSet<>();
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.MessageBodyWriter");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.MessageBodyReader");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ExceptionMapper");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ContextResolver");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ReaderInterceptor");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.WriterInterceptor");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ParamConverterProvider");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.container.ContainerRequestFilter");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.container.ContainerResponseFilter");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.container.DynamicFeature");
SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.core.Feature");
SERVER_PROVIDER_CLASS_NAMES.add("org.apache.cxf.jaxrs.ext.ContextProvider");
}
private ResourceUtils() {
}
private static Method[] getDeclaredMethods(final Class c) {
return AccessController.doPrivileged(new PrivilegedAction() {
@Override
public Method[] run() {
return c.getDeclaredMethods();
}
});
}
public static Method findPostConstructMethod(Class c) {
return findPostConstructMethod(c, null);
}
public static Method findPostConstructMethod(Class c, String name) {
if (Object.class == c || null == c) {
return null;
}
for (Method m : getDeclaredMethods(c)) {
if (name != null) {
if (m.getName().equals(name)) {
return m;
}
} else if (m.getAnnotation(PostConstruct.class) != null) {
return m;
}
}
Method m = findPostConstructMethod(c.getSuperclass(), name);
if (m != null) {
return m;
}
for (Class i : c.getInterfaces()) {
m = findPostConstructMethod(i, name);
if (m != null) {
return m;
}
}
return null;
}
public static Method findPreDestroyMethod(Class c) {
return findPreDestroyMethod(c, null);
}
public static Method findPreDestroyMethod(Class c, String name) {
if (Object.class == c || null == c) {
return null;
}
for (Method m : getDeclaredMethods(c)) {
if (name != null) {
if (m.getName().equals(name)) {
return m;
}
} else if (m.getAnnotation(PreDestroy.class) != null) {
return m;
}
}
Method m = findPreDestroyMethod(c.getSuperclass(), name);
if (m != null) {
return m;
}
for (Class i : c.getInterfaces()) {
m = findPreDestroyMethod(i, name);
if (m != null) {
return m;
}
}
return null;
}
public static ClassResourceInfo createClassResourceInfo(
Map resources, UserResource model,
Class defaultClass,
boolean isRoot, boolean enableStatic,
Bus bus) {
final boolean isDefaultClass = defaultClass != null;
Class sClass = !isDefaultClass ? loadClass(model.getName()) : defaultClass;
return createServiceClassResourceInfo(resources, model, sClass, isRoot, enableStatic, bus);
}
public static ClassResourceInfo createServiceClassResourceInfo(
Map resources, UserResource model,
Class sClass, boolean isRoot, boolean enableStatic, Bus bus) {
if (model == null) {
throw new RuntimeException("Resource class " + sClass.getName() + " has no model info");
}
ClassResourceInfo cri =
new ClassResourceInfo(sClass, sClass, isRoot, enableStatic, true,
model.getConsumes(), model.getProduces(), bus);
URITemplate t = URITemplate.createTemplate(model.getPath());
cri.setURITemplate(t);
MethodDispatcher md = new MethodDispatcher();
Map ops = model.getOperationsAsMap();
Method defaultMethod = null;
Map methodNames = new HashMap<>();
for (Method m : cri.getServiceClass().getMethods()) {
if (m.getAnnotation(DefaultMethod.class) != null) {
// if needed we can also support multiple default methods
defaultMethod = m;
}
methodNames.put(m.getName(), m);
}
for (Map.Entry entry : ops.entrySet()) {
UserOperation op = entry.getValue();
Method actualMethod = methodNames.get(op.getName());
if (actualMethod == null) {
actualMethod = defaultMethod;
}
if (actualMethod == null) {
continue;
}
OperationResourceInfo ori =
new OperationResourceInfo(actualMethod, cri, URITemplate.createTemplate(op.getPath()),
op.getVerb(), op.getConsumes(), op.getProduces(),
op.getParameters(),
op.isOneway());
String rClassName = actualMethod.getReturnType().getName();
if (op.getVerb() == null) {
if (resources.containsKey(rClassName)) {
ClassResourceInfo subCri = rClassName.equals(model.getName()) ? cri
: createServiceClassResourceInfo(resources, resources.get(rClassName),
actualMethod.getReturnType(), false, enableStatic, bus);
if (subCri != null) {
cri.addSubClassResourceInfo(subCri);
md.bind(ori, actualMethod);
}
}
} else {
md.bind(ori, actualMethod);
}
}
cri.setMethodDispatcher(md);
return checkMethodDispatcher(cri) ? cri : null;
}
public static ClassResourceInfo createClassResourceInfo(final Class rClass,
final Class sClass,
boolean root,
boolean enableStatic) {
return createClassResourceInfo(rClass, sClass, root, enableStatic, BusFactory.getThreadDefaultBus());
}
public static ClassResourceInfo createClassResourceInfo(final Class rClass,
final Class sClass,
boolean root,
boolean enableStatic,
Bus bus) {
return createClassResourceInfo(rClass, sClass, null, root, enableStatic, bus);
}
public static ClassResourceInfo createClassResourceInfo(final Class rClass,
final Class sClass,
ClassResourceInfo parent,
boolean root,
boolean enableStatic,
Bus bus) {
return createClassResourceInfo(rClass, sClass, parent, root, enableStatic, bus, null, null);
}
//CHECKSTYLE:OFF
public static ClassResourceInfo createClassResourceInfo(final Class rClass,
final Class sClass,
ClassResourceInfo parent,
boolean root,
boolean enableStatic,
Bus bus,
List defaultConsumes,
List defaultProduces) {
//CHECKSTYLE:ON
ClassResourceInfo cri = new ClassResourceInfo(rClass, sClass, root, enableStatic, bus,
defaultConsumes, defaultProduces);
cri.setParent(parent);
if (root) {
URITemplate t = URITemplate.createTemplate(cri.getPath());
cri.setURITemplate(t);
}
evaluateResourceClass(cri, enableStatic);
return checkMethodDispatcher(cri) ? cri : null;
}
private static void evaluateResourceClass(ClassResourceInfo cri, boolean enableStatic) {
MethodDispatcher md = new MethodDispatcher();
Class serviceClass = cri.getServiceClass();
final Map annotatedMethods = new HashMap<>();
for (Method m : serviceClass.getMethods()) {
if (!m.isBridge() && !m.isSynthetic()) {
//do real methods first
Method annotatedMethod = AnnotationUtils.getAnnotatedMethod(serviceClass, m);
if (!annotatedMethods.containsKey(annotatedMethod)) {
evaluateResourceMethod(cri, enableStatic, md, m, annotatedMethod);
annotatedMethods.put(annotatedMethod, m);
}
}
}
for (Method m : serviceClass.getMethods()) {
if (m.isBridge() || m.isSynthetic()) {
//if a bridge/synthetic method isn't already mapped to something, go ahead and do it
Method annotatedMethod = AnnotationUtils.getAnnotatedMethod(serviceClass, m);
if (!annotatedMethods.containsKey(annotatedMethod)) {
evaluateResourceMethod(cri, enableStatic, md, m, annotatedMethod);
annotatedMethods.put(annotatedMethod, m);
} else {
// Certain synthetic / bridge methods could be quite useful to handle
// methods with co-variant return types, especially when used with client proxies,
// see please: https://blogs.oracle.com/sundararajan/covariant-return-types-in-java
bindResourceMethod(md, m, annotatedMethods.get(annotatedMethod));
}
}
}
cri.setMethodDispatcher(md);
}
private static void bindResourceMethod(MethodDispatcher md, Method m, Method bound) {
final OperationResourceInfo ori = md.getOperationResourceInfo(bound);
if (ori != null && !ori.getMethodToInvoke().equals(m)) {
md.bind(ori, bound, m);
}
}
private static void evaluateResourceMethod(ClassResourceInfo cri, boolean enableStatic, MethodDispatcher md,
Method m, Method annotatedMethod) {
String httpMethod = AnnotationUtils.getHttpMethodValue(annotatedMethod);
Path path = AnnotationUtils.getMethodAnnotation(annotatedMethod, Path.class);
if (httpMethod != null || path != null) {
if (!checkAsyncResponse(annotatedMethod)) {
return;
}
md.bind(createOperationInfo(m, annotatedMethod, cri, path, httpMethod), m);
if (httpMethod == null) {
// subresource locator
Class subClass = m.getReturnType();
if (subClass == Class.class) {
subClass = InjectionUtils.getActualType(m.getGenericReturnType());
}
if (enableStatic) {
ClassResourceInfo subCri = cri.findResource(subClass, subClass);
if (subCri == null) {
ClassResourceInfo ancestor = getAncestorWithSameServiceClass(cri, subClass);
subCri = ancestor != null ? ancestor
: createClassResourceInfo(subClass, subClass, cri, false, enableStatic,
cri.getBus());
}
if (subCri != null) {
cri.addSubClassResourceInfo(subCri);
}
}
}
} else {
reportInvalidResourceMethod(m, NOT_RESOURCE_METHOD_MESSAGE_ID, Level.FINE);
}
}
private static void reportInvalidResourceMethod(Method m, String messageId, Level logLevel) {
if (LOG.isLoggable(logLevel)) {
LOG.log(logLevel, new org.apache.cxf.common.i18n.Message(messageId,
BUNDLE,
m.getDeclaringClass().getName(),
m.getName()).toString());
}
}
private static boolean checkAsyncResponse(Method m) {
Class[] types = m.getParameterTypes();
for (int i = 0; i < types.length; i++) {
if (types[i] == AsyncResponse.class) {
if (AnnotationUtils.getAnnotation(m.getParameterAnnotations()[i], Suspended.class) == null) {
reportInvalidResourceMethod(m, NOT_SUSPENDED_ASYNC_MESSAGE_ID, Level.FINE);
return false;
}
if (m.getReturnType() == Void.TYPE || m.getReturnType() == Void.class) {
return true;
}
reportInvalidResourceMethod(m, NO_VOID_RETURN_ASYNC_MESSAGE_ID, Level.WARNING);
return false;
}
}
return true;
}
private static ClassResourceInfo getAncestorWithSameServiceClass(ClassResourceInfo parent, Class subClass) {
if (parent == null) {
return null;
}
if (parent.getServiceClass() == subClass) {
return parent;
}
return getAncestorWithSameServiceClass(parent.getParent(), subClass);
}
public static Constructor findResourceConstructor(Class resourceClass, boolean perRequest) {
List> cs = new LinkedList<>();
for (Constructor c : resourceClass.getConstructors()) {
Class[] params = c.getParameterTypes();
Annotation[][] anns = c.getParameterAnnotations();
boolean match = true;
for (int i = 0; i < params.length; i++) {
if (!perRequest) {
if (AnnotationUtils.getAnnotation(anns[i], Context.class) == null) {
match = false;
break;
}
} else if (!AnnotationUtils.isValidParamAnnotations(anns[i])) {
match = false;
break;
}
}
if (match) {
cs.add(c);
}
}
Collections.sort(cs, new Comparator>() {
public int compare(Constructor c1, Constructor c2) {
int p1 = c1.getParameterTypes().length;
int p2 = c2.getParameterTypes().length;
return p1 > p2 ? -1 : p1 < p2 ? 1 : 0;
}
});
return cs.isEmpty() ? null : cs.get(0);
}
public static List getParameters(Method resourceMethod) {
Annotation[][] paramAnns = resourceMethod.getParameterAnnotations();
if (paramAnns.length == 0) {
return CastUtils.cast(Collections.emptyList(), Parameter.class);
}
Class[] types = resourceMethod.getParameterTypes();
List params = new ArrayList<>(paramAnns.length);
for (int i = 0; i < paramAnns.length; i++) {
Parameter p = getParameter(i, paramAnns[i], types[i]);
params.add(p);
}
return params;
}
//CHECKSTYLE:OFF
public static Parameter getParameter(int index, Annotation[] anns, Class type) {
Context ctx = AnnotationUtils.getAnnotation(anns, Context.class);
if (ctx != null) {
return new Parameter(ParameterType.CONTEXT, index, null);
}
boolean isEncoded = AnnotationUtils.getAnnotation(anns, Encoded.class) != null;
BeanParam bp = AnnotationUtils.getAnnotation(anns, BeanParam.class);
if (bp != null) {
return new Parameter(ParameterType.BEAN, index, null, isEncoded, null);
}
String dValue = AnnotationUtils.getDefaultParameterValue(anns);
PathParam a = AnnotationUtils.getAnnotation(anns, PathParam.class);
if (a != null) {
return new Parameter(ParameterType.PATH, index, a.value(), isEncoded, dValue);
}
QueryParam q = AnnotationUtils.getAnnotation(anns, QueryParam.class);
if (q != null) {
return new Parameter(ParameterType.QUERY, index, q.value(), isEncoded, dValue);
}
MatrixParam m = AnnotationUtils.getAnnotation(anns, MatrixParam.class);
if (m != null) {
return new Parameter(ParameterType.MATRIX, index, m.value(), isEncoded, dValue);
}
FormParam f = AnnotationUtils.getAnnotation(anns, FormParam.class);
if (f != null) {
return new Parameter(ParameterType.FORM, index, f.value(), isEncoded, dValue);
}
HeaderParam h = AnnotationUtils.getAnnotation(anns, HeaderParam.class);
if (h != null) {
return new Parameter(ParameterType.HEADER, index, h.value(), isEncoded, dValue);
}
CookieParam c = AnnotationUtils.getAnnotation(anns, CookieParam.class);
if (c != null) {
return new Parameter(ParameterType.COOKIE, index, c.value(), isEncoded, dValue);
}
return new Parameter(ParameterType.REQUEST_BODY, index, null);
}
//CHECKSTYLE:ON
private static OperationResourceInfo createOperationInfo(Method m, Method annotatedMethod,
ClassResourceInfo cri, Path path, String httpMethod) {
OperationResourceInfo ori = new OperationResourceInfo(m, annotatedMethod, cri);
URITemplate t = URITemplate.createTemplate(path);
ori.setURITemplate(t);
ori.setHttpMethod(httpMethod);
return ori;
}
private static boolean checkMethodDispatcher(ClassResourceInfo cr) {
if (cr.getMethodDispatcher().getOperationResourceInfos().isEmpty()) {
LOG.warning(new org.apache.cxf.common.i18n.Message("NO_RESOURCE_OP_EXC",
BUNDLE,
cr.getServiceClass().getName()).toString());
return false;
}
return true;
}
private static Class loadClass(String cName) {
try {
return ClassLoaderUtils.loadClass(cName.trim(), ResourceUtils.class);
} catch (ClassNotFoundException ex) {
throw new RuntimeException("No class " + cName.trim() + " can be found", ex);
}
}
public static List getUserResources(String loc, Bus bus) {
try (InputStream is = ResourceUtils.getResourceStream(loc, bus)) {
if (is == null) {
return null;
}
return getUserResources(is);
} catch (Exception ex) {
LOG.warning("Problem with processing a user model at " + loc);
}
return null;
}
public static InputStream getResourceStream(String loc, Bus bus) throws IOException {
URL url = getResourceURL(loc, bus);
return url == null ? null : url.openStream();
}
public static URL getResourceURL(String loc, Bus bus) throws IOException {
URL url = null;
if (loc.startsWith(CLASSPATH_PREFIX)) {
String path = loc.substring(CLASSPATH_PREFIX.length());
url = ResourceUtils.getClasspathResourceURL(path, ResourceUtils.class, bus);
} else {
try {
url = new URL(loc);
} catch (Exception ex) {
// it can be either a classpath or file resource without a scheme
url = ResourceUtils.getClasspathResourceURL(loc, ResourceUtils.class, bus);
if (url == null) {
File file = new File(loc);
if (file.exists()) {
url = file.toURI().toURL();
}
}
}
}
if (url == null) {
LOG.warning("No resource " + loc + " is available");
}
return url;
}
public static InputStream getClasspathResourceStream(String path, Class callingClass, Bus bus) {
InputStream is = ClassLoaderUtils.getResourceAsStream(path, callingClass);
return is == null ? getResource(path, InputStream.class, bus) : is;
}
public static URL getClasspathResourceURL(String path, Class callingClass, Bus bus) {
URL url = ClassLoaderUtils.getResource(path, callingClass);
return url == null ? getResource(path, URL.class, bus) : url;
}
public static T getResource(String path, Class resourceClass, Bus bus) {
if (bus != null) {
ResourceManager rm = bus.getExtension(ResourceManager.class);
if (rm != null) {
return rm.resolveResource(path, resourceClass);
}
}
return null;
}
public static Properties loadProperties(String propertiesLocation, Bus bus) throws IOException {
Properties props = new Properties();
try (InputStream is = getResourceStream(propertiesLocation, bus)) {
props.load(is);
}
return props;
}
public static List getUserResources(String loc) {
return getUserResources(loc, BusFactory.getThreadDefaultBus());
}
public static List getUserResources(InputStream is) throws Exception {
Document doc = StaxUtils.read(new InputStreamReader(is, StandardCharsets.UTF_8));
return getResourcesFromElement(doc.getDocumentElement());
}
public static List getResourcesFromElement(Element modelEl) {
List resources = new ArrayList<>();
List resourceEls =
DOMUtils.findAllElementsByTagNameNS(modelEl,
"http://cxf.apache.org/jaxrs", "resource");
for (Element e : resourceEls) {
resources.add(getResourceFromElement(e));
}
return resources;
}
public static ResourceTypes getAllRequestResponseTypes(List cris,
boolean jaxbOnly) {
return getAllRequestResponseTypes(cris, jaxbOnly, null);
}
public static ResourceTypes getAllRequestResponseTypes(List cris,
boolean jaxbOnly,
MessageBodyWriter jaxbWriter) {
ResourceTypes types = new ResourceTypes();
for (ClassResourceInfo resource : cris) {
getAllTypesForResource(resource, types, jaxbOnly, jaxbWriter);
}
return types;
}
public static Class getActualJaxbType(Class type, Method resourceMethod, boolean inbound) {
ElementClass element = resourceMethod.getAnnotation(ElementClass.class);
if (element != null) {
Class cls = inbound ? element.request() : element.response();
if (cls != Object.class) {
return cls;
}
}
return type;
}
private static void getAllTypesForResource(ClassResourceInfo resource,
ResourceTypes types,
boolean jaxbOnly,
MessageBodyWriter jaxbWriter) {
Class jaxbElement = null;
try {
jaxbElement = ClassLoaderUtils.loadClass("javax.xml.bind.JAXBElement", ResourceUtils.class);
} catch (final ClassNotFoundException e) {
// no-op
}
for (OperationResourceInfo ori : resource.getMethodDispatcher().getOperationResourceInfos()) {
Method method = ori.getAnnotatedMethod() == null ? ori.getMethodToInvoke() : ori.getAnnotatedMethod();
Class realReturnType = method.getReturnType();
Class cls = realReturnType;
if (cls == Response.class || ori.isAsync()) {
cls = getActualJaxbType(cls, method, false);
}
Type type = method.getGenericReturnType();
if (jaxbOnly) {
checkJaxbType(resource.getServiceClass(), cls, realReturnType == Response.class || ori.isAsync()
? cls : type, types, method.getAnnotations(), jaxbWriter, jaxbElement);
} else {
types.getAllTypes().put(cls, type);
}
for (Parameter pm : ori.getParameters()) {
if (pm.getType() == ParameterType.REQUEST_BODY) {
Class inType = method.getParameterTypes()[pm.getIndex()];
if (inType != AsyncResponse.class) {
Type paramType = method.getGenericParameterTypes()[pm.getIndex()];
if (jaxbOnly) {
checkJaxbType(resource.getServiceClass(), inType, paramType, types,
method.getParameterAnnotations()[pm.getIndex()], jaxbWriter, jaxbElement);
} else {
types.getAllTypes().put(inType, paramType);
}
}
}
}
}
for (ClassResourceInfo sub : resource.getSubResources()) {
if (!isRecursiveSubResource(resource, sub)) {
getAllTypesForResource(sub, types, jaxbOnly, jaxbWriter);
}
}
}
private static boolean isRecursiveSubResource(ClassResourceInfo parent, ClassResourceInfo sub) {
if (parent == null) {
return false;
}
if (parent == sub) {
return true;
}
return isRecursiveSubResource(parent.getParent(), sub);
}
private static void checkJaxbType(Class serviceClass,
Class type,
Type genericType,
ResourceTypes types,
Annotation[] anns,
MessageBodyWriter jaxbWriter,
Class jaxbElement) {
boolean isCollection = false;
if (InjectionUtils.isSupportedCollectionOrArray(type)) {
type = InjectionUtils.getActualType(genericType);
isCollection = true;
}
if (type == Object.class && !(genericType instanceof Class)
|| genericType instanceof TypeVariable) {
Type theType = InjectionUtils.processGenericTypeIfNeeded(serviceClass,
Object.class,
genericType);
type = InjectionUtils.getActualType(theType);
}
if (type == null
|| InjectionUtils.isPrimitive(type)
|| (jaxbElement != null && jaxbElement.isAssignableFrom(type))
|| Response.class.isAssignableFrom(type)
|| type.isInterface()) {
return;
}
MessageBodyWriter writer = jaxbWriter;
if (writer == null) {
JAXBElementProvider defaultWriter = new JAXBElementProvider<>();
defaultWriter.setMarshallAsJaxbElement(true);
defaultWriter.setXmlTypeAsJaxbElementOnly(true);
writer = defaultWriter;
}
if (writer.isWriteable(type, type, anns, MediaType.APPLICATION_XML_TYPE)) {
types.getAllTypes().put(type, type);
Class genCls = InjectionUtils.getActualType(genericType);
if (genCls != type && genCls != null && genCls != Object.class
&& !InjectionUtils.isSupportedCollectionOrArray(genCls)) {
types.getAllTypes().put(genCls, genCls);
}
XMLName name = AnnotationUtils.getAnnotation(anns, XMLName.class);
QName qname = name != null ? JAXRSUtils.convertStringToQName(name.value()) : null;
if (isCollection) {
types.getCollectionMap().put(type, qname);
} else {
types.getXmlNameMap().put(type, qname);
}
}
}
private static UserResource getResourceFromElement(Element e) {
UserResource resource = new UserResource();
resource.setName(e.getAttribute("name"));
resource.setPath(e.getAttribute("path"));
resource.setConsumes(e.getAttribute("consumes"));
resource.setProduces(e.getAttribute("produces"));
List operEls =
DOMUtils.findAllElementsByTagNameNS(e,
"http://cxf.apache.org/jaxrs", "operation");
List opers = new ArrayList<>(operEls.size());
for (Element operEl : operEls) {
opers.add(getOperationFromElement(operEl));
}
resource.setOperations(opers);
return resource;
}
private static UserOperation getOperationFromElement(Element e) {
UserOperation op = new UserOperation();
op.setName(e.getAttribute("name"));
op.setVerb(e.getAttribute("verb"));
op.setPath(e.getAttribute("path"));
op.setOneway(Boolean.parseBoolean(e.getAttribute("oneway")));
op.setConsumes(e.getAttribute("consumes"));
op.setProduces(e.getAttribute("produces"));
List paramEls =
DOMUtils.findAllElementsByTagNameNS(e,
"http://cxf.apache.org/jaxrs", "param");
List params = new ArrayList<>(paramEls.size());
for (int i = 0; i < paramEls.size(); i++) {
Element paramEl = paramEls.get(i);
Parameter p = new Parameter(paramEl.getAttribute("type"), i, paramEl.getAttribute("name"));
p.setEncoded(Boolean.valueOf(paramEl.getAttribute("encoded")));
p.setDefaultValue(paramEl.getAttribute("defaultValue"));
String pClass = paramEl.getAttribute("class");
if (!StringUtils.isEmpty(pClass)) {
try {
p.setJavaType(ClassLoaderUtils.loadClass(pClass, ResourceUtils.class));
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
params.add(p);
}
op.setParameters(params);
return op;
}
public static Object[] createConstructorArguments(Constructor c,
Message m,
boolean perRequest) {
return createConstructorArguments(c, m, perRequest, null);
}
public static Object[] createConstructorArguments(Constructor c,
Message m,
boolean perRequest,
Map, Object> contextValues) {
Class[] params = c.getParameterTypes();
Annotation[][] anns = c.getParameterAnnotations();
Type[] genericTypes = c.getGenericParameterTypes();
return createConstructorArguments(c, m, perRequest, contextValues, params, anns, genericTypes);
}
public static Object[] createConstructorArguments(Constructor c,
Message m,
boolean perRequest,
Map,
Object> contextValues,
Class[] params,
Annotation[][] anns,
Type[] genericTypes) {
if (m == null) {
m = new MessageImpl();
}
@SuppressWarnings("unchecked")
MultivaluedMap templateValues =
(MultivaluedMap)m.get(URITemplate.TEMPLATE_PARAMETERS);
Object[] values = new Object[params.length];
for (int i = 0; i < params.length; i++) {
if (AnnotationUtils.getAnnotation(anns[i], Context.class) != null) {
Object contextValue = contextValues != null ? contextValues.get(params[i]) : null;
if (contextValue == null) {
if (perRequest || InjectionUtils.VALUE_CONTEXTS.contains(params[i].getName())) {
values[i] = JAXRSUtils.createContextValue(m, genericTypes[i], params[i]);
} else {
values[i] = InjectionUtils.createThreadLocalProxy(params[i]);
}
} else {
values[i] = contextValue;
}
} else {
// this branch won't execute for singletons given that the found constructor
// is guaranteed to have only Context parameters, if any, for singletons
Parameter p = ResourceUtils.getParameter(i, anns[i], params[i]);
values[i] = JAXRSUtils.createHttpParameterValue(
p, params[i], genericTypes[i], anns[i], m, templateValues, null);
}
}
return values;
}
@SuppressWarnings("unchecked")
public static JAXRSServerFactoryBean createApplication(Application app,
boolean ignoreAppPath,
boolean staticSubresourceResolution,
boolean useSingletonResourceProvider,
Bus bus) {
Set singletons = app.getSingletons();
verifySingletons(singletons);
List> resourceClasses = new ArrayList<>();
List providers = new ArrayList<>();
List features = new ArrayList<>();
Map, ResourceProvider> map = new HashMap<>();
// Note, app.getClasses() returns a list of per-request classes
// or singleton provider classes
for (Class cls : app.getClasses()) {
if (isValidApplicationClass(cls, singletons)) {
if (isValidProvider(cls)) {
providers.add(createProviderInstance(cls));
} else if (Feature.class.isAssignableFrom(cls)) {
features.add(createFeatureInstance((Class) cls));
} else {
resourceClasses.add(cls);
if (useSingletonResourceProvider) {
map.put(cls, new SingletonResourceProvider(createProviderInstance(cls)));
} else {
map.put(cls, new PerRequestResourceProvider(cls));
}
}
}
}
// we can get either a provider or resource class here
for (Object o : singletons) {
if (isValidProvider(o.getClass())) {
providers.add(o);
} else if (o instanceof Feature) {
features.add((Feature) o);
} else {
resourceClasses.add(o.getClass());
map.put(o.getClass(), new SingletonResourceProvider(o));
}
}
JAXRSServerFactoryBean bean = new JAXRSServerFactoryBean();
if (bus != null) {
bean.setBus(bus);
}
String address = "/";
if (!ignoreAppPath) {
ApplicationPath appPath = locateApplicationPath(app.getClass());
if (appPath != null) {
address = appPath.value();
}
}
if (!address.startsWith("/")) {
address = "/" + address;
}
bean.setAddress(address);
bean.setStaticSubresourceResolution(staticSubresourceResolution);
bean.setResourceClasses(resourceClasses);
bean.setProviders(providers);
bean.getFeatures().addAll(features);
for (Map.Entry, ResourceProvider> entry : map.entrySet()) {
bean.setResourceProvider(entry.getKey(), entry.getValue());
}
Map appProps = app.getProperties();
if (appProps != null) {
bean.getProperties(true).putAll(appProps);
}
bean.setApplication(app);
return bean;
}
public static Object createProviderInstance(Class cls) {
try {
Constructor c = ResourceUtils.findResourceConstructor(cls, false);
if (c != null && c.getParameterTypes().length == 0) {
return c.newInstance();
}
return c;
} catch (Throwable ex) {
throw new RuntimeException("Provider " + cls.getName() + " can not be created", ex);
}
}
public static Feature createFeatureInstance(Class cls) {
try {
Constructor c = ResourceUtils.findResourceConstructor(cls, false);
if (c == null) {
throw new RuntimeException("No valid constructor found for " + cls.getName());
}
return (Feature) c.newInstance();
} catch (Throwable ex) {
throw new RuntimeException("Feature " + cls.getName() + " can not be created", ex);
}
}
private static boolean isValidProvider(Class c) {
if (c == null || c == Object.class) {
return false;
}
if (c.getAnnotation(Provider.class) != null) {
return true;
}
for (Class itf : c.getInterfaces()) {
if (SERVER_PROVIDER_CLASS_NAMES.contains(itf.getName())) {
return true;
}
}
return isValidProvider(c.getSuperclass());
}
private static void verifySingletons(Set singletons) {
if (singletons.isEmpty()) {
return;
}
Set map = new HashSet<>();
for (Object s : singletons) {
if (map.contains(s.getClass().getName())) {
throw new RuntimeException("More than one instance of the same singleton class "
+ s.getClass().getName() + " is available");
}
map.add(s.getClass().getName());
}
}
public static boolean isValidResourceClass(Class c) {
if (c.isInterface() || Modifier.isAbstract(c.getModifiers())) {
LOG.info("Ignoring invalid resource class " + c.getName());
return false;
}
return true;
}
public static ApplicationPath locateApplicationPath(Class appClass) {
ApplicationPath appPath = appClass.getAnnotation(ApplicationPath.class);
if (appPath == null && appClass.getSuperclass() != Application.class) {
return locateApplicationPath(appClass.getSuperclass());
}
return appPath;
}
private static boolean isValidApplicationClass(Class c, Set singletons) {
if (!isValidResourceClass(c)) {
return false;
}
for (Object s : singletons) {
if (c == s.getClass()) {
LOG.info("Ignoring per-request resource class " + c.getName()
+ " as it is also registered as singleton");
return false;
}
}
return true;
}
}
