package org.apache.cxf.jaxrs.interceptor; import java.io.IOException; import java.util.List; import java.util.ResourceBundle; import java.util.logging.Level; import java.util.logging.Logger; import javax.ws.rs.WebApplicationException; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.core.Response; import org.apache.cxf.common.i18n.BundleUtils; import org.apache.cxf.common.logging.LogUtils; import org.apache.cxf.jaxrs.JAXRSServiceImpl; import org.apache.cxf.jaxrs.ext.RequestHandler; import org.apache.cxf.jaxrs.impl.MetadataMap; import org.apache.cxf.jaxrs.impl.RequestPreprocessor; import org.apache.cxf.jaxrs.impl.UriInfoImpl; import org.apache.cxf.jaxrs.lifecycle.ResourceProvider; import org.apache.cxf.jaxrs.model.ClassResourceInfo; import org.apache.cxf.jaxrs.model.OperationResourceInfo; import org.apache.cxf.jaxrs.model.ProviderInfo; import org.apache.cxf.jaxrs.model.URITemplate; import org.apache.cxf.jaxrs.provider.ProviderFactory; import org.apache.cxf.jaxrs.utils.HttpUtils; import org.apache.cxf.jaxrs.utils.InjectionUtils; import org.apache.cxf.jaxrs.utils.JAXRSUtils; import org.apache.cxf.message.Message; import org.apache.cxf.message.MessageUtils; import org.apache.cxf.phase.AbstractPhaseInterceptor; import org.apache.cxf.phase.Phase; import org.apache.cxf.service.Service; public class JAXRSInInterceptor extends AbstractPhaseInterceptor<Message> { private static final Logger LOG = LogUtils.getL7dLogger(JAXRSInInterceptor.class); private static final ResourceBundle BUNDLE = BundleUtils.getBundle(JAXRSInInterceptor.class); public JAXRSInInterceptor() { super(Phase.UNMARSHAL); } @Override public void handleFault(Message message) { super.handleFault(message); LOG.fine("Cleanup thread local variables"); Object rootInstance = message.getExchange().remove(JAXRSUtils.ROOT_INSTANCE); Object rootProvider = message.getExchange().remove(JAXRSUtils.ROOT_PROVIDER); if (rootInstance != null && rootProvider != null) { try { ((ResourceProvider)rootProvider).releaseInstance(message, rootInstance); } catch (Throwable tex) { LOG.warning("Exception occurred during releasing the service instance, " + tex.getMessage()); } } ProviderFactory.getInstance(message).clearThreadLocalProxies(); ClassResourceInfo cri = (ClassResourceInfo)message.getExchange().get(JAXRSUtils.ROOT_RESOURCE_CLASS); if (cri != null) { cri.clearThreadLocalProxies(); } } public void handleMessage(Message message) { try { processRequest(message); } catch (RuntimeException ex) { Response excResponse = JAXRSUtils.convertFaultToResponse(ex, message); if (excResponse == null) { ProviderFactory.getInstance(message).clearThreadLocalProxies(); message.getExchange().put(Message.PROPOGATE_EXCEPTION, JAXRSUtils.propogateException(message)); throw ex; } message.getExchange().put(Response.class, excResponse); } } private void processRequest(Message message) { if (message.getExchange().get(OperationResourceInfo.class) != null) { // it's a suspended invocation; return; } RequestPreprocessor rp = ProviderFactory.getInstance(message).getRequestPreprocessor(); if (rp != null) { rp.preprocess(message, new UriInfoImpl(message, null)); if (message.getExchange().get(Response.class) != null) { return; } } String requestContentType = (String)message.get(Message.CONTENT_TYPE); if (requestContentType == null) { requestContentType = "*/*"; } String rawPath = HttpUtils.getPathToMatch(message, true); //1. Matching target resource class Service service = message.getExchange().get(Service.class); List<ClassResourceInfo> resources = ((JAXRSServiceImpl)service).getClassResourceInfos(); String acceptTypes = HttpUtils.getProtocolHeader(message, Message.ACCEPT_CONTENT_TYPE, null); if (acceptTypes == null) { acceptTypes = "*/*"; message.put(Message.ACCEPT_CONTENT_TYPE, acceptTypes); } List<MediaType> acceptContentTypes = null; try { acceptContentTypes = JAXRSUtils.sortMediaTypes(acceptTypes); } catch (IllegalArgumentException ex) { throw new WebApplicationException(406); } message.getExchange().put(Message.ACCEPT_CONTENT_TYPE, acceptContentTypes); MultivaluedMap<String, String> values = new MetadataMap<String, String>(); ClassResourceInfo resource = JAXRSUtils.selectResourceClass(resources, rawPath, values, message); if (resource == null) { org.apache.cxf.common.i18n.Message errorMsg = new org.apache.cxf.common.i18n.Message("NO_ROOT_EXC", BUNDLE, message.get(Message.REQUEST_URI), rawPath); LOG.warning(errorMsg.toString()); Response resp = JAXRSUtils.createResponse(resource, message, errorMsg.toString(), Response.Status.NOT_FOUND.getStatusCode(), false); throw new WebApplicationException(resp); } message.getExchange().put(JAXRSUtils.ROOT_RESOURCE_CLASS, resource); String httpMethod = HttpUtils.getProtocolHeader(message, Message.HTTP_REQUEST_METHOD, "POST"); OperationResourceInfo ori = null; boolean operChecked = false; List<ProviderInfo<RequestHandler>> shs = ProviderFactory.getInstance(message).getRequestHandlers(); for (ProviderInfo<RequestHandler> sh : shs) { String newAcceptTypes = HttpUtils.getProtocolHeader(message, Message.ACCEPT_CONTENT_TYPE, "*/*"); if (!acceptTypes.equals(newAcceptTypes) || (ori == null && !operChecked)) { acceptTypes = newAcceptTypes; acceptContentTypes = JAXRSUtils.sortMediaTypes(newAcceptTypes); message.getExchange().put(Message.ACCEPT_CONTENT_TYPE, acceptContentTypes); if (ori != null) { values = new MetadataMap<String, String>(); resource = JAXRSUtils.selectResourceClass(resources, rawPath, values, message); } try { ori = JAXRSUtils.findTargetMethod(resource, message, httpMethod, values, requestContentType, acceptContentTypes, false); setExchangeProperties(message, ori, values, resources.size()); } catch (WebApplicationException ex) { operChecked = true; } } InjectionUtils.injectContextFields(sh.getProvider(), sh, message); InjectionUtils.injectContextMethods(sh.getProvider(), sh, message); Response response = sh.getProvider().handleRequest(message, resource); if (response != null) { message.getExchange().put(Response.class, response); return; } } String newAcceptTypes = (String)message.get(Message.ACCEPT_CONTENT_TYPE); if (!acceptTypes.equals(newAcceptTypes) || ori == null) { acceptTypes = newAcceptTypes; acceptContentTypes = JAXRSUtils.sortMediaTypes(acceptTypes); message.getExchange().put(Message.ACCEPT_CONTENT_TYPE, acceptContentTypes); if (ori != null) { values = new MetadataMap<String, String>(); resource = JAXRSUtils.selectResourceClass(resources, rawPath, values, message); } try { ori = JAXRSUtils.findTargetMethod(resource, message, httpMethod, values, requestContentType, acceptContentTypes, true); setExchangeProperties(message, ori, values, resources.size()); } catch (WebApplicationException ex) { if (JAXRSUtils.noResourceMethodForOptions(ex.getResponse(), httpMethod)) { Response response = JAXRSUtils.createResponse(resource, null, null, 200, true); message.getExchange().put(Response.class, response); return; } else { throw ex; } } } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Request path is: " + rawPath); LOG.fine("Request HTTP method is: " + httpMethod); LOG.fine("Request contentType is: " + requestContentType); LOG.fine("Accept contentType is: " + acceptTypes); LOG.fine("Found operation: " + ori.getMethodToInvoke().getName()); } setExchangeProperties(message, ori, values, resources.size()); //Process parameters 处理请求参数,一般解析参数从这里开始 try { List<Object> params = JAXRSUtils.processParameters(ori, values, message); message.setContent(List.class, params); } catch (IOException ex) { Response excResponse = JAXRSUtils.convertFaultToResponse(ex, message); if (excResponse == null) { throw new WebApplicationException(ex); } else { message.getExchange().put(Response.class, excResponse); } } } private void setExchangeProperties(Message message, OperationResourceInfo ori, MultivaluedMap<String, String> values, int numberOfResources) { message.getExchange().put(OperationResourceInfo.class, ori); message.put("org.apache.cxf.resource.method", ori.getMethodToInvoke()); message.put(URITemplate.TEMPLATE_PARAMETERS, values); String plainOperationName = ori.getMethodToInvoke().getName(); if (numberOfResources > 1) { plainOperationName = ori.getClassResourceInfo().getServiceClass().getSimpleName() + "#" + plainOperationName; } message.getExchange().put("org.apache.cxf.resource.operation.name", plainOperationName); boolean oneway = ori.isOneway() || MessageUtils.isTrue(HttpUtils.getProtocolHeader(message, Message.ONE_WAY_REQUEST, null)); message.getExchange().setOneWay(oneway); } }
public class JAXRSUtils{ //Message contains following information: PATH, HTTP_REQUEST_METHOD, CONTENT_TYPE, InputStream. public static List<Object> processParameters(OperationResourceInfo ori, MultivaluedMap<String, String> values, Message message) throws IOException, WebApplicationException { Method method = ori.getMethodToInvoke(); Class<?>[] parameterTypes = method.getParameterTypes(); Parameter[] paramsInfo = ori.getParameters().toArray(new Parameter[]{}); Method annotatedMethod = ori.getAnnotatedMethod(); Type[] genericParameterTypes = annotatedMethod == null ? method.getGenericParameterTypes() : annotatedMethod.getGenericParameterTypes(); Annotation[][] anns = annotatedMethod == null ? null : annotatedMethod.getParameterAnnotations(); List<Object> params = new ArrayList<Object>(parameterTypes.length); for (int i = 0; i < parameterTypes.length; i++) { Class<?> param = parameterTypes[i]; Type genericParam = genericParameterTypes[i]; if (genericParam instanceof TypeVariable) { genericParam = InjectionUtils.getSuperType(ori.getClassResourceInfo().getServiceClass(), (TypeVariable<?>)genericParam); } if (param == Object.class) { param = (Class<?>)genericParam; } else if (genericParam == Object.class) { genericParam = param; } Object paramValue = processParameter(param, genericParam, anns == null ? new Annotation[0] : anns[i], paramsInfo[i], values, message, ori); params.add(paramValue); } return params; } private static Object processParameter(Class<?> parameterClass, Type parameterType, Annotation[] parameterAnns, Parameter parameter, MultivaluedMap<String, String> values, Message message, OperationResourceInfo ori) throws IOException, WebApplicationException { InputStream is = message.getContent(InputStream.class); if (parameter.getType() == ParameterType.REQUEST_BODY) { String contentType = (String)message.get(Message.CONTENT_TYPE); if (contentType == null) { org.apache.cxf.common.i18n.Message errorMsg = new org.apache.cxf.common.i18n.Message("NO_CONTENT_TYPE_SPECIFIED", BUNDLE, ori.getHttpMethod()); LOG.fine(errorMsg.toString()); contentType = MediaType.WILDCARD; } return readFromMessageBody(parameterClass, parameterType, parameterAnns, is, MediaType.valueOf(contentType), ori.getConsumeTypes(), message); } else if (parameter.getType() == ParameterType.CONTEXT) { return createContextValue(message, parameterType, parameterClass); } else { return createHttpParameterValue(parameter, parameterClass, parameterType, parameterAnns, message, values, ori); } } private static <T> T readFromMessageBody(Class<T> targetTypeClass, Type parameterType, Annotation[] parameterAnnotations, InputStream is, MediaType contentType, List<MediaType> consumeTypes, Message m) throws IOException, WebApplicationException { List<MediaType> types = JAXRSUtils.intersectMimeTypes(consumeTypes, contentType); MessageBodyReader<T> provider = null; for (MediaType type : types) { //获取用户提供的provider进行参数解析 provider = ProviderFactory.getInstance(m) .createMessageBodyReader(targetTypeClass, parameterType, parameterAnnotations, type, m); if (provider != null) { try { HttpHeaders headers = new HttpHeadersImpl(m); return provider.readFrom(targetTypeClass, parameterType, parameterAnnotations, contentType, headers.getRequestHeaders(), is); } catch (IOException e) { throw e; } catch (WebApplicationException ex) { throw ex; } catch (Exception ex) { throw new WebApplicationException(ex); } } else { String errorMessage = new org.apache.cxf.common.i18n.Message("NO_MSG_READER", BUNDLE, targetTypeClass.getSimpleName(), contentType).toString(); LOG.warning(errorMessage); throw new WebApplicationException(Response.Status.UNSUPPORTED_MEDIA_TYPE); } } return null; } }