public static ContextResolver<?> createContextResolver(Type genericType, Message m) { if (genericType instanceof ParameterizedType) { return ProviderFactory.getInstance(m).createContextResolver( ((ParameterizedType)genericType).getActualTypeArguments()[0], m); } else if (m != null) { return ProviderFactory.getInstance(m).createContextResolver(genericType, m); } else { return null; } }
public <T> MessageBodyReader<T> getMessageBodyReader( Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return ProviderFactory.getInstance(m).createMessageBodyReader( type, genericType, annotations, mediaType, m); }
public <T> MessageBodyWriter<T> getMessageBodyWriter( Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return ProviderFactory.getInstance(m).createMessageBodyWriter( type, genericType, annotations, mediaType, m); }
public static ContextResolver<?> createContextResolver(Type genericType, Message m) { if (genericType instanceof ParameterizedType) { return ProviderFactory.getInstance(m).createContextResolver( ((ParameterizedType)genericType).getActualTypeArguments()[0], m); } else if (m != null) { return ProviderFactory.getInstance(m).createContextResolver(genericType, m); } else { return null; } }
public <T> ContextResolver<T> getContextResolver(Class<T> contextType, MediaType mediaType) { return ProviderFactory.getInstance(m).createContextResolver(contextType, m, mediaType); }
public <T extends Throwable> ExceptionMapper<T> getExceptionMapper(Class<T> type) { return ProviderFactory.getInstance(m).createExceptionMapper(type, m); }
private static ResponseExceptionMapper<?> findExceptionMapper(Message message, Class<?> exType) { ProviderFactory pf = ProviderFactory.getInstance(message); return pf.createResponseExceptionMapper(message, exType); }
public <T> ContextResolver<T> getContextResolver(Class<T> contextType, MediaType mediaType) { return ProviderFactory.getInstance(m).createContextResolver(contextType, m, mediaType); }
public <T> MessageBodyReader<T> getMessageBodyReader( Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return ProviderFactory.getInstance(m).createMessageBodyReader( type, getGenericType(type, genericType), annotations, mediaType, m); }
public <T> MessageBodyWriter<T> getMessageBodyWriter( Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return ProviderFactory.getInstance(m).createMessageBodyWriter( type, getGenericType(type, genericType), annotations, mediaType, m); }
private Response handleMetadataRequest(Message m) { List<ProviderInfo<RequestHandler>> shs = ProviderFactory.getInstance(m).getRequestHandlers(); // this is actually being tested by ProviderFactory unit tests but just in case // WadlGenerator, the custom or default one, must be the first one if (shs.size() > 0 && shs.get(0).getProvider() instanceof WadlGenerator) { return shs.get(0).getProvider().handleRequest(m, null); } else { return null; } }
public static ProviderFactory getInstance(Message m) { Endpoint e = m.getExchange().get(Endpoint.class); return getInstance(e); }
public static <T> T createFromParameterHandler(String value, Class<T> pClass, Annotation[] anns, Message message) { T result = null; if (message != null) { ParamConverter<T> pm = ProviderFactory.getInstance(message) .createParameterHandler(pClass, anns); if (pm != null) { result = pm.fromString(value); } } return result; }
protected String convertParamValue(Object pValue, Annotation[] anns) { if (pValue == null) { return null; } ProviderFactory pf = ProviderFactory.getInstance(cfg.getEndpoint()); if (pf != null) { Class<?> pClass = pValue.getClass(); @SuppressWarnings("unchecked") ParamConverter<Object> prov = (ParamConverter<Object>)pf.createParameterHandler(pClass, anns); if (prov != null) { return prov.toString(pValue); } } return pValue.toString(); }
private <T> T doInitResource(Class<?> cls, T resource) { ClassResourceInfo sub = cri.getSubResource(subClass, cls, resource, true); Message m = PhaseInterceptorChain.getCurrentMessage(); if (m != null) { sub.initBeanParamInfo(ProviderFactory.getInstance(m)); } return resource; }
public static Object createBeanParamValue(Message m, Class<?> clazz, OperationResourceInfo ori) { BeanParamInfo bmi = ProviderFactory.getInstance(m).getBeanParamInfo(clazz); if (bmi == null) { // we could've started introspecting now but the fact no bean info // is available indicates that the one created at start up has been // lost and hence it is 500 LOG.warning("Bean parameter info is not available"); throw ExceptionUtils.toInternalServerErrorException(null, null); } Object instance; try { instance = ClassLoaderUtils.loadClass(clazz.getName(), JAXRSUtils.class).newInstance(); } catch (Throwable t) { throw ExceptionUtils.toInternalServerErrorException(t, null); } JAXRSUtils.injectParameters(ori, bmi, instance, m); InjectionUtils.injectContexts(instance, bmi, m); return instance; }
: new ClientException(ex); } finally { ProviderFactory.getInstance(outMessage).clearThreadLocalProxies();
private void convertExceptionToResponseIfPossible(Throwable ex, Message message) { Response excResponse = JAXRSUtils.convertFaultToResponse(ex, message); if (excResponse == null) { ProviderFactory.getInstance(message).clearThreadLocalProxies(); message.getExchange().put(Message.PROPOGATE_EXCEPTION, ExceptionUtils.propogateException(message)); throw ex instanceof RuntimeException ? (RuntimeException)ex : ExceptionUtils.toInternalServerErrorException(ex, null); } message.getExchange().put(Response.class, excResponse); }
public void handleMessage(Message inMessage) throws Fault { ProviderFactory pf = ProviderFactory.getInstance(inMessage); if (pf == null) { return; } List<ProviderInfo<ClientResponseFilter>> filters = pf.getClientResponseFilters(); if (!filters.isEmpty()) { ClientRequestContext reqContext = new ClientRequestContextImpl(inMessage.getExchange().getOutMessage(), true); ClientResponseContext respContext = new ClientResponseContextImpl(getResponse(inMessage), inMessage); for (ProviderInfo<ClientResponseFilter> filter : filters) { InjectionUtils.injectContexts(filter.getProvider(), filter, inMessage); try { filter.getProvider().filter(reqContext, respContext); } catch (IOException ex) { throw new ClientException(ex); } } } }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public Object aroundReadFrom(ReaderInterceptorContext c) throws IOException, WebApplicationException { Class entityCls = (Class)c.getType(); Type entityType = c.getGenericType(); MediaType entityMt = c.getMediaType(); Annotation[] entityAnns = c.getAnnotations(); if (m.get(ProviderFactory.PROVIDER_SELECTION_PROPERTY_CHANGED) == Boolean.TRUE && !reader.isReadable(entityCls, entityType, entityAnns, entityMt)) { reader = ProviderFactory.getInstance(m) .createMessageBodyReader(entityCls, entityType, entityAnns, entityMt, m); if (reader == null) { throw new RuntimeException("No reader available"); } } return reader.readFrom(entityCls, entityType, entityAnns, entityMt, new HttpHeadersImpl(m).getRequestHeaders(), c.getInputStream()); }