Class ProviderBase<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>,MAPPER extends com.fasterxml.jackson.databind.ObjectMapper,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>,MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER>>

java.lang.Object
org.glassfish.jersey.jackson.internal.jackson.jaxrs.base.ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>
All Implemented Interfaces:
com.fasterxml.jackson.core.Versioned, MessageBodyReader<Object>, MessageBodyWriter<Object>
Direct Known Subclasses:
JacksonJsonProvider

public abstract class ProviderBase<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>,MAPPER extends com.fasterxml.jackson.databind.ObjectMapper,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>,MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER>> extends Object implements MessageBodyReader<Object>, MessageBodyWriter<Object>, com.fasterxml.jackson.core.Versioned
  • Field Details

    • HEADER_CONTENT_TYPE_OPTIONS

      public static final String HEADER_CONTENT_TYPE_OPTIONS
      This header is useful on Windows, trying to deal with potential XSS attacks.
      See Also:
    • CLASS_NAME_NO_CONTENT_EXCEPTION

      protected static final String CLASS_NAME_NO_CONTENT_EXCEPTION
      See Also:
    • DEFAULT_UNTOUCHABLES

      protected static final HashSet<ClassKey> DEFAULT_UNTOUCHABLES
      Looks like we need to worry about accidental data binding for types we shouldn't be handling. This is probably not a very good way to do it, but let's start by blacklisting things we are not to handle.

      (why ClassKey? since plain old Class has no hashCode() defined, lookups are painfully slow)

    • DEFAULT_UNREADABLES

      public static final Class<?>[] DEFAULT_UNREADABLES
      These are classes that we never use for reading (never try to deserialize instances of these types).
    • DEFAULT_UNWRITABLES

      public static final Class<?>[] DEFAULT_UNWRITABLES
      These are classes that we never use for writing (never try to serialize instances of these types).
    • JAXRS_FEATURE_DEFAULTS

      protected static final int JAXRS_FEATURE_DEFAULTS
    • _mapperConfig

      protected final MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER> _mapperConfig
      Helper object used for encapsulating configuration aspects of ObjectMapper
    • _cfgCustomUntouchables

      protected HashMap<ClassKey,Boolean> _cfgCustomUntouchables
      Map that contains overrides to default list of untouchable types: true meaning that entry is untouchable, false that is is not.
    • _cfgCheckCanSerialize

      protected boolean _cfgCheckCanSerialize
      Whether we want to actually check that Jackson has a serializer for given type. Since this should generally be the case (due to auto-discovery) and since the call to check availability can be bit expensive, defaults to false.
    • _cfgCheckCanDeserialize

      protected boolean _cfgCheckCanDeserialize
      Whether we want to actually check that Jackson has a deserializer for given type. Since this should generally be the case (due to auto-discovery) and since the call to check availability can be bit expensive, defaults to false.
    • _jaxRSFeatures

      protected int _jaxRSFeatures
      Feature flags set.
      Since:
      2.3
    • _defaultReadView

      protected Class<?> _defaultReadView
      View to use for reading if none defined for the end point.
    • _defaultWriteView

      protected Class<?> _defaultWriteView
      View to use for writing if none defined for the end point.
    • _untouchables

      public static final HashSet<ClassKey> _untouchables
    • _unreadableClasses

      public static final Class<?>[] _unreadableClasses
    • _unwritableClasses

      public static final Class<?>[] _unwritableClasses
    • _readers

      protected final com.fasterxml.jackson.databind.util.LRUMap<AnnotationBundleKey,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>> _readers
      Cache for resolved endpoint configurations when reading JSON data
    • _writers

      protected final com.fasterxml.jackson.databind.util.LRUMap<AnnotationBundleKey,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>> _writers
      Cache for resolved endpoint configurations when writing JSON data
  • Constructor Details

    • ProviderBase

      protected ProviderBase(MAPPER_CONFIG mconfig)
    • ProviderBase

      @Deprecated protected ProviderBase()
      Deprecated.
      Constructor that is only added to resolve [jaxrs-providers#10]; problems with combination of RESTeasy and CDI. Should NOT be used by any code explicitly; only exists for proxy support.
  • Method Details

    • checkCanDeserialize

      public void checkCanDeserialize(boolean state)
      Method for defining whether actual detection for existence of a deserializer for type should be done when isReadable(java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], jakarta.ws.rs.core.MediaType) is called.
    • checkCanSerialize

      public void checkCanSerialize(boolean state)
      Method for defining whether actual detection for existence of a serializer for type should be done when isWriteable(java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], jakarta.ws.rs.core.MediaType) is called.
    • addUntouchable

      public void addUntouchable(Class<?> type)
      Method for marking specified type as "untouchable", meaning that provider will not try to read or write values of this type (or its subtypes).
      Parameters:
      type - Type to consider untouchable; can be any kind of class, including abstract class or interface. No instance of this type (including subtypes, i.e. types assignable to this type) will be read or written by provider
    • removeUntouchable

      public void removeUntouchable(Class<?> type)
      Method for removing definition of specified type as untouchable: usually only
      Since:
      2.2
    • setAnnotationsToUse

      public void setAnnotationsToUse(Annotations[] annotationsToUse)
      Method for configuring which annotation sets to use (including none). Annotation sets are defined in order decreasing precedence; that is, first one has the priority over following ones.
      Parameters:
      annotationsToUse - Ordered list of annotation sets to use; if null, default
    • setMapper

      public void setMapper(MAPPER m)
      Method that can be used to directly define ObjectMapper to use for serialization and deserialization; if null, will use the standard provider discovery from context instead. Default setting is null.
    • setDefaultReadView

      public THIS setDefaultReadView(Class<?> view)
      Method for specifying JSON View to use for reading content when end point does not have explicit View annotations.
      Since:
      2.3
    • setDefaultWriteView

      public THIS setDefaultWriteView(Class<?> view)
      Method for specifying JSON View to use for reading content when end point does not have explicit View annotations.
      Since:
      2.3
    • setDefaultView

      public THIS setDefaultView(Class<?> view)
      Method for specifying JSON View to use for reading and writing content when end point does not have explicit View annotations. Functionally equivalent to: setDefaultReadView(view); setDefaultWriteView(view);
      Since:
      2.3
    • configure

      public THIS configure(JaxRSFeature feature, boolean state)
    • enable

      public THIS enable(JaxRSFeature feature)
    • enable

      public THIS enable(JaxRSFeature first, JaxRSFeature... f2)
    • disable

      public THIS disable(JaxRSFeature feature)
    • disable

      public THIS disable(JaxRSFeature first, JaxRSFeature... f2)
    • isEnabled

      public boolean isEnabled(JaxRSFeature f)
    • configure

      public THIS configure(com.fasterxml.jackson.databind.DeserializationFeature f, boolean state)
    • enable

      public THIS enable(com.fasterxml.jackson.databind.DeserializationFeature f)
    • disable

      public THIS disable(com.fasterxml.jackson.databind.DeserializationFeature f)
    • configure

      public THIS configure(com.fasterxml.jackson.databind.SerializationFeature f, boolean state)
    • enable

      public THIS enable(com.fasterxml.jackson.databind.SerializationFeature f)
    • disable

      public THIS disable(com.fasterxml.jackson.databind.SerializationFeature f)
    • enable

      public THIS enable(com.fasterxml.jackson.core.JsonParser.Feature f)
    • enable

      public THIS enable(com.fasterxml.jackson.core.JsonGenerator.Feature f)
    • disable

      public THIS disable(com.fasterxml.jackson.core.JsonParser.Feature f)
    • disable

      public THIS disable(com.fasterxml.jackson.core.JsonGenerator.Feature f)
    • configure

      public THIS configure(com.fasterxml.jackson.core.JsonParser.Feature f, boolean state)
    • configure

      public THIS configure(com.fasterxml.jackson.core.JsonGenerator.Feature f, boolean state)
    • hasMatchingMediaTypeForReading

      protected boolean hasMatchingMediaTypeForReading(MediaType mediaType)
      Helper method used to check whether given media type is supported by this provider for read operations (when binding input data such as POST body).

      Default implementation simply calls hasMatchingMediaType(jakarta.ws.rs.core.MediaType).

      Since:
      2.3
    • hasMatchingMediaTypeForWriting

      protected boolean hasMatchingMediaTypeForWriting(MediaType mediaType)
      Helper method used to check whether given media type is supported by this provider for writing operations, such as when converting response object to response body of request (like GET or POST).

      Default implementation simply calls hasMatchingMediaType(jakarta.ws.rs.core.MediaType).

      Since:
      2.3
    • hasMatchingMediaType

      protected abstract boolean hasMatchingMediaType(MediaType mediaType)
      Helper method used to check whether given media type is supported by this provider.
      Since:
      2.2
    • _locateMapperViaProvider

      protected abstract MAPPER _locateMapperViaProvider(Class<?> type, MediaType mediaType)
      Helper method that is called if no mapper has been explicitly configured.
    • _configForReading

      protected EP_CONFIG _configForReading(MAPPER mapper, Annotation[] annotations, Class<?> defaultView)
    • _configForWriting

      protected EP_CONFIG _configForWriting(MAPPER mapper, Annotation[] annotations, Class<?> defaultView)
    • _configForReading

      protected abstract EP_CONFIG _configForReading(com.fasterxml.jackson.databind.ObjectReader reader, Annotation[] annotations)
    • _configForWriting

      protected abstract EP_CONFIG _configForWriting(com.fasterxml.jackson.databind.ObjectWriter writer, Annotation[] annotations)
    • getSize

      public long getSize(Object value, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType)
      Method that JAX-RS container calls to try to figure out serialized length of given value. Since computation of this length is about as expensive as serialization itself, implementation will return -1 to denote "not known", so that container will determine length from actual serialized output (if needed).
      Specified by:
      getSize in interface MessageBodyWriter<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>>
    • isWriteable

      public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType)
      Method that JAX-RS container calls to try to check whether given value (of specified type) can be serialized by this provider. Implementation will first check that expected media type is expected one (by call to hasMatchingMediaType(jakarta.ws.rs.core.MediaType)); then verify that type is not one of "untouchable" types (types we will never automatically handle), and finally that there is a serializer for type (iff checkCanSerialize(boolean) has been called with true argument -- otherwise assumption is there will be a handler)
      Specified by:
      isWriteable in interface MessageBodyWriter<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>>
    • writeTo

      public void writeTo(Object value, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String,Object> httpHeaders, OutputStream entityStream) throws IOException
      Method that JAX-RS container calls to serialize given value.
      Specified by:
      writeTo in interface MessageBodyWriter<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>>
      Throws:
      IOException
    • findEncoding

      protected com.fasterxml.jackson.core.JsonEncoding findEncoding(MediaType mediaType, MultivaluedMap<String,Object> httpHeaders)
      Helper method to use for determining desired output encoding. For now, will always just use UTF-8...
    • _modifyHeaders

      protected void _modifyHeaders(Object value, Class<?> type, Type genericType, Annotation[] annotations, MultivaluedMap<String,Object> httpHeaders, EP_CONFIG endpoint) throws IOException
      Overridable method used for adding optional response headers before serializing response object.
      Throws:
      IOException
    • _createGenerator

      protected com.fasterxml.jackson.core.JsonGenerator _createGenerator(com.fasterxml.jackson.databind.ObjectWriter writer, OutputStream rawStream, com.fasterxml.jackson.core.JsonEncoding enc) throws IOException
      Overridable helper method called to create a JsonGenerator for writing contents into given raw OutputStream.
      Throws:
      IOException
      Since:
      2.3
    • _endpointForWriting

      protected EP_CONFIG _endpointForWriting(Object value, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String,Object> httpHeaders)
    • isReadable

      public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType)
      Method that JAX-RS container calls to try to check whether values of given type (and media type) can be deserialized by this provider. Implementation will first check that expected media type is a JSON type (via call to hasMatchingMediaType(jakarta.ws.rs.core.MediaType)); then verify that type is not one of "untouchable" types (types we will never automatically handle), and finally that there is a deserializer for type (iff checkCanDeserialize(boolean) has been called with true argument -- otherwise assumption is there will be a handler)
      Specified by:
      isReadable in interface MessageBodyReader<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>>
    • readFrom

      public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String,String> httpHeaders, InputStream entityStream) throws IOException
      Method that JAX-RS container calls to deserialize given value.
      Specified by:
      readFrom in interface MessageBodyReader<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>>
      Throws:
      IOException
    • _createParser

      protected com.fasterxml.jackson.core.JsonParser _createParser(com.fasterxml.jackson.databind.ObjectReader reader, InputStream rawStream) throws IOException
      Overridable helper method called to create a JsonParser for reading contents of given raw InputStream. May return null to indicate that Stream is empty; that is, contains no content.
      Throws:
      IOException
      Since:
      2.2
    • _endpointForReading

      protected EP_CONFIG _endpointForReading(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String,String> httpHeaders)
      Overridable helper method that will basically fetch representation of the endpoint that can be used to get ObjectReader to use for deserializing content
      Since:
      2.8
    • locateMapper

      public MAPPER locateMapper(Class<?> type, MediaType mediaType)
      Method called to locate ObjectMapper to use for serialization and deserialization. Exact logic depends on setting of JaxRSFeature.DYNAMIC_OBJECT_MAPPER_LOOKUP.

      If JaxRSFeature.DYNAMIC_OBJECT_MAPPER_LOOKUP is disabled (default setting unless changed), behavior is as follows:

      1. If an instance has been explicitly defined by setMapper(MAPPER) (or non-null instance passed in constructor), that will be used.
      2. If not, will try to locate it using standard JAX-RS ContextResolver mechanism, if it has been properly configured to access it (by JAX-RS runtime).
      3. Finally, if no mapper is found, will return a default unconfigured ObjectMapper instance (one constructed with default constructor and not modified in any way)

      If JaxRSFeature.DYNAMIC_OBJECT_MAPPER_LOOKUP is enabled, steps 1 and 2 are reversed, such that JAX-RS ContextResolver is first used, and only if none is defined will configured mapper be used.

      Parameters:
      type - Class of object being serialized or deserialized; not checked at this point, since it is assumed that unprocessable classes have been already weeded out, but will be passed to ContextResolver as is.
      mediaType - Declared media type for the instance to process: not used by this method, but will be passed to ContextResolver as is.
    • _isSpecialReadable

      protected boolean _isSpecialReadable(Class<?> type)
      Overridable helper method used to allow handling of somewhat special types for reading
      Since:
      2.2
    • _isIgnorableForReading

      protected boolean _isIgnorableForReading(ClassKey typeKey)
      Overridable helper method called to check whether given type is a known "ignorable type" (in context of reading), values of which are not bound from content.
      Since:
      2.6
    • _isIgnorableForWriting

      protected boolean _isIgnorableForWriting(ClassKey typeKey)
      Overridable helper method called to check whether given type is a known "ignorable type" (in context of reading), values of which can not be written out.
      Since:
      2.6
    • _createNoContentException

      protected IOException _createNoContentException()
    • _containedIn

      protected static boolean _containedIn(Class<?> mainType, HashSet<ClassKey> set)
    • _findCustomUntouchable

      protected Boolean _findCustomUntouchable(Class<?> mainType)
    • findSuperTypes

      protected static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore)
    • findSuperTypes

      protected static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore, List<Class<?>> result)
    • _addSuperTypes

      protected static void _addSuperTypes(Class<?> cls, Class<?> endBefore, Collection<Class<?>> result, boolean addClassItself)