All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.apache.cxf.jaxrs.provider.ProviderFactory Maven / Gradle / Ivy

    There is a newer version: 2.7.18
    Show newest version
    /**
 * 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.provider;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Logger;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.MessageBodyWriter;

import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.endpoint.Endpoint;
import org.apache.cxf.jaxrs.client.ResponseExceptionMapper;
import org.apache.cxf.jaxrs.ext.ParameterHandler;
import org.apache.cxf.jaxrs.ext.RequestHandler;
import org.apache.cxf.jaxrs.ext.ResponseHandler;
import org.apache.cxf.jaxrs.ext.SystemQueryHandler;
import org.apache.cxf.jaxrs.impl.RequestPreprocessor;
import org.apache.cxf.jaxrs.impl.WebApplicationExceptionMapper;
import org.apache.cxf.jaxrs.model.ProviderInfo;
import org.apache.cxf.jaxrs.utils.InjectionUtils;
import org.apache.cxf.jaxrs.utils.JAXRSUtils;
import org.apache.cxf.message.Message;

public final class ProviderFactory {
    private static final Logger LOG = LogUtils.getL7dLogger(ProviderFactory.class);
    private static final ProviderFactory SHARED_FACTORY = new ProviderFactory();
    
    static {
        // TODO : do dynamic instantiation of JSON and few other default providers
        JSONProvider jsonProvider = null;
        try {
            jsonProvider = new JSONProvider();
        } catch (Throwable ex) {
            String message = "Problem with instantiating the default JSON provider, ";
            if (ex.getMessage() != null) {
                message += ex.getMessage();
            } else {
                message += "exception class : " + ex.getClass().getName();  
            }
            LOG.info(message);
        }
        
        SHARED_FACTORY.setProviders(new JAXBElementProvider(),
                                    jsonProvider,
                                    new BinaryDataProvider(),
                                    new SourceProvider(),
                                    new FormEncodingProvider(),
                                    new PrimitiveTextProvider(),
                                    new MultipartProvider(),
                                    new WebApplicationExceptionMapper(),
                                    new SystemQueryHandler());
    }
    
    private List> messageReaders = 
        new ArrayList>();
    private List> messageWriters = 
        new ArrayList>();
    private List> contextResolvers = 
        new ArrayList>(1);
    private List> exceptionMappers = 
        new ArrayList>(1);
    private List> requestHandlers = 
        new ArrayList>(1);
    private List> responseHandlers = 
        new ArrayList>(1);
    private List> paramHandlers = 
        new ArrayList>(1);
    private List> responseExceptionMappers = 
        new ArrayList>(1);
    private RequestPreprocessor requestPreprocessor;
    
    private ProviderFactory() {
    }
    
    public static ProviderFactory getInstance() {
        return new ProviderFactory();
    }
    
    public static ProviderFactory getInstance(Message m) {
        Endpoint e = m.getExchange().get(Endpoint.class);
        return (ProviderFactory)e.get(ProviderFactory.class.getName());
    }
    
    public static ProviderFactory getSharedInstance() {
        return SHARED_FACTORY;
    }
    
    public  ContextResolver createContextResolver(Type contextType, 
                                                        Message m) {
        Object mt = m.get(Message.CONTENT_TYPE);
        return createContextResolver(contextType, m,
               mt == null ? MediaType.valueOf("*/*") : MediaType.valueOf(mt.toString()));
        
    }
    
    @SuppressWarnings("unchecked")
    public  ContextResolver createContextResolver(Type contextType, Message m,
                                                        MediaType mt) {
        for (ProviderInfo cr : contextResolvers) {
            Type[] types = cr.getProvider().getClass().getGenericInterfaces();
            for (Type t : types) {
                if (t instanceof ParameterizedType) {
                    ParameterizedType pt = (ParameterizedType)t;
                    Type[] args = pt.getActualTypeArguments();
                    for (int i = 0; i < args.length; i++) {
                        if (contextType == args[i]) {
                            
                            InjectionUtils.injectContextFields(cr.getProvider(), cr, m);
                            InjectionUtils.injectContextMethods(cr.getProvider(), cr, m);
                            return cr.getProvider();
                        }
                    }
                }
            }
        }
        return null;
    }
    
    public  ExceptionMapper createExceptionMapper(Class exceptionType, 
                                                                          Message m) {
        
        ExceptionMapper mapper = doCreateExceptionMapper(exceptionType, m);
        if (mapper != null || this == SHARED_FACTORY) {
            return mapper;
        }
        
        return SHARED_FACTORY.createExceptionMapper(exceptionType, m);
    }
    
    @SuppressWarnings("unchecked")
    private  ExceptionMapper doCreateExceptionMapper(
        Class exceptionType, Message m) {
        
        List> candidates = new LinkedList>();
        
        for (ProviderInfo em : exceptionMappers) {
            handleMapper((List)candidates, em, exceptionType, m);
        }
        if (candidates.size() == 0) {
            return null;
        }
        Collections.sort((List)candidates, new ExceptionMapperComparator());
        return candidates.get(0);
    }
    
    @SuppressWarnings("unchecked")
    public  ParameterHandler createParameterHandler(Class paramType) {
        
        List> candidates = new LinkedList>();
        
        for (ProviderInfo em : paramHandlers) {
            handleMapper((List)candidates, em, paramType, null);
        }
        if (candidates.size() == 0) {
            return null;
        }
        Collections.sort(candidates, new ParameterHandlerComparator());
        return candidates.get(0);
    }
    
    @SuppressWarnings("unchecked")
    public  ResponseExceptionMapper createResponseExceptionMapper(
                                 Class paramType) {
        
        List> candidates = new LinkedList>();
        
        for (ProviderInfo em : responseExceptionMappers) {
            handleMapper((List)candidates, em, paramType, null);
        }
        if (candidates.size() == 0) {
            return null;
        }
        Collections.sort(candidates, new ResponseExceptionMapperComparator());
        return candidates.get(0);
    }
    
    private static void handleMapper(List candidates, ProviderInfo em, 
                                     Class expectedType, Message m) {
        
        Type[] types = em.getProvider().getClass().getGenericInterfaces();
        for (Type t : types) {
            if (t instanceof ParameterizedType) {
                ParameterizedType pt = (ParameterizedType)t;
                Type[] args = pt.getActualTypeArguments();
                for (int i = 0; i < args.length; i++) {
                    if (((Class)args[i]).isAssignableFrom(expectedType)) {
                        if (m != null) {
                            InjectionUtils.injectContextFields(em.getProvider(), em, m);
                            InjectionUtils.injectContextMethods(em.getProvider(), em, m);
                        }
                        candidates.add(em.getProvider());
                        break;
                    }
                }
            }
        }
    }
    
    
    
    public  MessageBodyReader createMessageBodyReader(Class bodyType,
                                                            Type parameterType,
                                                            Annotation[] parameterAnnotations,
                                                            MediaType mediaType,
                                                            Message m) {
        // Try user provided providers
        MessageBodyReader mr = chooseMessageReader(bodyType,
                                                      parameterType,
                                                      parameterAnnotations,
                                                      mediaType,
                                                      m);
        
        //If none found try the default ones
        if (mr != null ||  this == SHARED_FACTORY) {
            return mr;
        }
        return SHARED_FACTORY.createMessageBodyReader(bodyType, parameterType, 
                                                        parameterAnnotations, mediaType, m);
    }
    
    
    
    public List> getRequestHandlers() {
        if (requestHandlers.size() == 0) {
            return Collections.unmodifiableList(SHARED_FACTORY.requestHandlers);
        } else {
            List> handlers = 
                new ArrayList>(SHARED_FACTORY.requestHandlers);
            handlers.addAll(requestHandlers);
            return handlers;
        }
    }
    
    public List> getResponseHandlers() {
        
        return Collections.unmodifiableList(responseHandlers);
    }

    public  MessageBodyWriter createMessageBodyWriter(Class bodyType,
                                                            Type parameterType,
                                                            Annotation[] parameterAnnotations,
                                                            MediaType mediaType,
                                                            Message m) {
        // Try user provided providers
        MessageBodyWriter mw = chooseMessageWriter(bodyType,
                                                      parameterType,
                                                      parameterAnnotations,
                                                      mediaType,
                                                      m);
        
        //If none found try the default ones
        if (mw != null || this == SHARED_FACTORY) {
            return mw;
        }
        return SHARED_FACTORY.createMessageBodyWriter(bodyType, parameterType, 
                                                        parameterAnnotations, mediaType, m);
    }
    
//CHECKSTYLE:OFF       
    private void setProviders(Object... providers) {
        
        for (Object o : providers) {
            if (o == null) {
                continue;
            }
            if (MessageBodyReader.class.isAssignableFrom(o.getClass())) {
                messageReaders.add(new ProviderInfo((MessageBodyReader)o)); 
            }
            
            if (MessageBodyWriter.class.isAssignableFrom(o.getClass())) {
                messageWriters.add(new ProviderInfo((MessageBodyWriter)o)); 
            }
            
            if (ContextResolver.class.isAssignableFrom(o.getClass())) {
                contextResolvers.add(new ProviderInfo((ContextResolver)o)); 
            }
            
            if (RequestHandler.class.isAssignableFrom(o.getClass())) {
                requestHandlers.add(new ProviderInfo((RequestHandler)o)); 
            }
            
            if (ResponseHandler.class.isAssignableFrom(o.getClass())) {
                responseHandlers.add(new ProviderInfo((ResponseHandler)o)); 
            }
            
            if (ExceptionMapper.class.isAssignableFrom(o.getClass())) {
                exceptionMappers.add(new ProviderInfo((ExceptionMapper)o)); 
            }
            
            if (ResponseExceptionMapper.class.isAssignableFrom(o.getClass())) {
                responseExceptionMappers.add(new ProviderInfo((ResponseExceptionMapper)o)); 
            }
            
            if (ParameterHandler.class.isAssignableFrom(o.getClass())) {
                paramHandlers.add(new ProviderInfo((ParameterHandler)o)); 
            }
        }
        
        sortReaders();
        sortWriters();
        
        injectContexts(messageReaders, messageWriters, contextResolvers, requestHandlers, responseHandlers,
                       exceptionMappers);
    }
//CHECKSTYLE:ON
    
    void injectContexts(List ... providerLists) {
        for (List list : providerLists) {
            for (Object p : list) {
                ProviderInfo pi = (ProviderInfo)p;
                InjectionUtils.injectContextProxies(pi, pi.getProvider());
            }
        }
    }
    
    /*
     * sorts the available providers according to the media types they declare
     * support for. Sorting of media types follows the general rule: x/y < * x < *,
     * i.e. a provider that explicitly lists a media types is sorted before a
     * provider that lists *. Quality parameter values are also used such that
     * x/y;q=1.0 < x/y;q=0.7.
     */    
    private void sortReaders() {
        Collections.sort(messageReaders, new MessageBodyReaderComparator());
    }
    
    private void sortWriters() {
        Collections.sort(messageWriters, new MessageBodyWriterComparator());
    }
    
        
    
    /**
     * Choose the first body reader provider that matches the requestedMimeType 
     * for a sorted list of Entity providers
     * Returns null if none is found.
     * @param 
     * @param messageBodyReaders
     * @param type
     * @param requestedMimeType
     * @return
     */
    @SuppressWarnings("unchecked")
    private  MessageBodyReader chooseMessageReader(Class type,
                                                         Type genericType,
                                                         Annotation[] annotations,
                                                         MediaType mediaType,
                                                         Message m) {
        for (ProviderInfo ep : messageReaders) {
            InjectionUtils.injectContextFields(ep.getProvider(), ep, m);
            InjectionUtils.injectContextMethods(ep.getProvider(), ep, m);             
            if (matchesReaderCriterias(ep.getProvider(), type, genericType, annotations, mediaType)) {
                return ep.getProvider();
            }
        }     
        
        return null;
        
    }
    
    private  boolean matchesReaderCriterias(MessageBodyReader ep,
                                               Class type,
                                               Type genericType,
                                               Annotation[] annotations,
                                               MediaType mediaType) {
        if (!ep.isReadable(type, genericType, annotations)) {
            return false;
        }
        
        List supportedMediaTypes = JAXRSUtils.getProviderConsumeTypes(ep);
        
        List availableMimeTypes = 
            JAXRSUtils.intersectMimeTypes(Collections.singletonList(mediaType), supportedMediaTypes);

        return availableMimeTypes.size() != 0 ? true : false;
        
    }
        
    /**
     * Choose the first body writer provider that matches the requestedMimeType 
     * for a sorted list of Entity providers
     * Returns null if none is found.
     * @param 
     * @param messageBodyWriters
     * @param type
     * @param requestedMimeType
     * @return
     */
    @SuppressWarnings("unchecked")
    private  MessageBodyWriter chooseMessageWriter(Class type,
                                                         Type genericType,
                                                         Annotation[] annotations,
                                                         MediaType mediaType,
                                                         Message m) {
        for (ProviderInfo ep : messageWriters) {
            InjectionUtils.injectContextFields(ep.getProvider(), ep, m);
            InjectionUtils.injectContextMethods(ep.getProvider(), ep, m); 
            if (matchesWriterCriterias(ep.getProvider(), type, genericType, annotations, mediaType)) {
                return ep.getProvider();
            }
        }     
        
        return null;
        
    }
    
    private  boolean matchesWriterCriterias(MessageBodyWriter ep,
                                               Class type,
                                               Type genericType,
                                               Annotation[] annotations,
                                               MediaType mediaType) {
        if (!ep.isWriteable(type, genericType, annotations)) {
            return false;
        }
        
        List supportedMediaTypes = JAXRSUtils.getProviderProduceTypes(ep);
        
        List availableMimeTypes = 
            JAXRSUtils.intersectMimeTypes(Collections.singletonList(mediaType),
                                          supportedMediaTypes);

        return availableMimeTypes.size() != 0 ? true : false;
        
    }
    
    List> getMessageReaders() {
        return Collections.unmodifiableList(messageReaders);
    }

    List> getMessageWriters() {
        return Collections.unmodifiableList(messageWriters);
    }
    
    List> getContextResolvers() {
        return Collections.unmodifiableList(contextResolvers);
    }
    
     
    public void registerUserProvider(Object provider) {
        setUserProviders(Collections.singletonList(provider));    
    }
    /**
     * Use for injection of entityProviders
     * @param entityProviders the entityProviders to set
     */
    public void setUserProviders(List userProviders) {
        setProviders(userProviders.toArray());
    }

    private static class MessageBodyReaderComparator 
        implements Comparator> {
        
        public int compare(ProviderInfo p1, 
                           ProviderInfo p2) {
            MessageBodyReader e1 = p1.getProvider();
            MessageBodyReader e2 = p2.getProvider();
            List types1 = JAXRSUtils.getProviderConsumeTypes(e1);
            types1 = JAXRSUtils.sortMediaTypes(types1);
            List types2 = JAXRSUtils.getProviderConsumeTypes(e2);
            types2 = JAXRSUtils.sortMediaTypes(types2);
    
            return JAXRSUtils.compareSortedMediaTypes(types1, types2);
            
        }
    }
    
    private static class MessageBodyWriterComparator 
        implements Comparator> {
        
        public int compare(ProviderInfo p1, 
                           ProviderInfo p2) {
            MessageBodyWriter e1 = p1.getProvider();
            MessageBodyWriter e2 = p2.getProvider();
            
            List types1 =
                JAXRSUtils.sortMediaTypes(JAXRSUtils.getProviderProduceTypes(e1));
            List types2 =
                JAXRSUtils.sortMediaTypes(JAXRSUtils.getProviderProduceTypes(e2));
    
            return JAXRSUtils.compareSortedMediaTypes(types1, types2);
            
        }
    }
    
    public void setRequestPreprocessor(RequestPreprocessor rp) {
        this.requestPreprocessor = rp;
    }
    
    public RequestPreprocessor getRequestPreprocessor() {
        return requestPreprocessor;
    }
    
    public void clearThreadLocalProxies() {
        clearProxies(messageReaders,
                     messageWriters,
                     contextResolvers,
                     requestHandlers,
                     responseHandlers,
                     exceptionMappers);
    }
    
    void clearProxies(List ...lists) {
        for (List list : lists) {
            for (Object p : list) {
                ProviderInfo pi = (ProviderInfo)p;
                pi.clearThreadLocalProxies();
            }
        }
    }
    
    void clearProviders() {
        messageReaders.clear();
        messageWriters.clear();
        contextResolvers.clear();
        exceptionMappers.clear();
        requestHandlers.clear();
        responseHandlers.clear();
        paramHandlers.clear();
        responseExceptionMappers.clear();
    }
    
    public void setSchemaLocations(List schemas) {
        for (ProviderInfo r : messageReaders) {
            try {
                Method m = r.getProvider().getClass().getMethod("setSchemas", 
                                                     new Class[]{List.class});
                m.invoke(r.getProvider(), new Object[]{schemas});
            } catch (Exception ex) {
                // ignore
            }
        }
    }
    
    private static class ExceptionMapperComparator implements 
        Comparator> {

        public int compare(ExceptionMapper em1, 
                           ExceptionMapper em2) {
            return compareClasses(em1.getClass(), em2.getClass());
        }
        
    }
    
    private static class ResponseExceptionMapperComparator implements 
        Comparator> {
    
        public int compare(ResponseExceptionMapper em1, 
                           ResponseExceptionMapper em2) {
            return compareClasses(em1.getClass(), em2.getClass());
        }
        
    }
    
    private static class ParameterHandlerComparator implements 
        Comparator> {

        public int compare(ParameterHandler em1, 
                           ParameterHandler em2) {
            return compareClasses(em1.getClass(), em2.getClass());
        }
    
    }
    
    private static int compareClasses(Class cl1, Class cl2) {
        Type[] types1 = cl1.getGenericInterfaces();
        Type[] types2 = cl2.getGenericInterfaces();
        
        Class realClass1 = InjectionUtils.getActualType(types1[0]);
        Class realClass2 = InjectionUtils.getActualType(types2[0]);
        if (realClass1 == realClass2) {
            return 0;
        }
        if (realClass1.isAssignableFrom(realClass2)) {
            // subclass should go first
            return 1;
        }
        return -1;
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy