public <T> MessageBodyWriter<T> getMessageBodyWriter( Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return ProviderFactory.getInstance(m).createMessageBodyWriter( type, genericType, annotations, mediaType, m); }
@Override public void clearProviders() { super.clearProviders(); responseExceptionMappers.clear(); asyncInvocationInterceptorFactories.clear(); }
public void clearThreadLocalProxies() { clearProxies(injectedProviders); if (application != null) { application.clearThreadLocalProxies(); } if (this != SHARED_FACTORY) { SHARED_FACTORY.clearThreadLocalProxies(); } }
public <T> MessageBodyReader<T> getMessageBodyReader( Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return ProviderFactory.getInstance(m).createMessageBodyReader( type, genericType, annotations, mediaType, m); }
private static ResponseExceptionMapper<?> findExceptionMapper(Message message, Class<?> exType) { ProviderFactory pf = ProviderFactory.getInstance(message); return pf.createResponseExceptionMapper(message, exType); }
method.getDeclaredAnnotations()); } finally { ProviderFactory.getInstance(outMessage).clearThreadLocalProxies();
public <T> ContextResolver<T> getContextResolver(Class<T> contextType, MediaType mediaType) { return ProviderFactory.getInstance(m).createContextResolver(contextType, m, mediaType); }
final ProviderFactory pf = ProviderFactory.getInstance(m); for (MediaType type : types) { List<ReaderInterceptor> readers = pf.createMessageBodyReaderInterceptor( targetTypeClass, parameterType,
if (o == null) { ContextProvider<?> provider = ProviderFactory.getInstance(m).createContextProvider(clazz, contextMessage); if (provider != null) { o = provider.createContext(contextMessage);
List<ReaderInterceptor> readers = outMessage == null ? null : ProviderFactory.getInstance(outMessage) .createMessageBodyReaderInterceptor(cls, t, anns, mediaType, outMessage, entityStreamAvailable, null); reportMessageHandlerProblem("MSG_READER_PROBLEM", cls, mediaType, ex); } finally { ProviderFactory pf = ProviderFactory.getInstance(outMessage); if (pf != null) { pf.clearThreadLocalProxies();
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; }
o = createContextResolver(genericType, contextMessage); } else if (Configuration.class.isAssignableFrom(clazz)) { o = ProviderFactory.getInstance(contextMessage).getConfiguration(contextMessage); } else if (Application.class.isAssignableFrom(clazz)) { ProviderInfo<?> providerInfo = } else if (contextMessage != null) { ContextProvider<?> provider = ProviderFactory.getInstance(contextMessage).createContextProvider(clazz, contextMessage); if (provider != null) { o = provider.createContext(contextMessage);
public <T extends Throwable> ExceptionMapper<T> getExceptionMapper(Class<T> type) { return ProviderFactory.getInstance(m).createExceptionMapper(type, m); }
if (pf != null) { Message m = null; if (pf.isParamConverterContextsAvailable()) { m = new MessageImpl(); m.put(Message.REQUESTOR_ROLE, Boolean.TRUE); (ParamConverter<Object>)pf.createParameterHandler(pClass, pClass, anns, m); if (prov != null) { try { } finally { if (m != null) { pf.clearThreadLocalProxies();
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; } }
private void processRequest(Message message) { ProviderFactory providerFactory = ProviderFactory.getInstance(message); RequestPreprocessor rp = providerFactory.getRequestPreprocessor(); if (rp != null) { rp.preprocess(message, new UriInfoImpl(message, null)); List<ProviderInfo<RequestHandler>> shs = providerFactory.getRequestHandlers(); for (ProviderInfo<RequestHandler> sh : shs) { if (ori == null && !operChecked) {
Message m, Set<String> names) { MessageBodyWriter<T> mw = createMessageBodyWriter(bodyType, parameterType, parameterAnnotations, interceptors = new ArrayList<>(size + 1); List<ProviderInfo<WriterInterceptor>> writers = getBoundFilters(writerInterceptors, names); for (ProviderInfo<WriterInterceptor> p : writers) { injectContextValues(p, m); interceptors.add(p.getProvider());
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; }
public static MicroProfileClientProviderFactory createInstance(Bus bus, Comparator<ProviderInfo<?>> comparator) { if (bus == null) { bus = BusFactory.getThreadDefaultBus(); } MicroProfileClientProviderFactory factory = new MicroProfileClientProviderFactory(bus, comparator); ProviderFactory.initFactory(factory); factory.setBusProviders(); return factory; }