RestContext (Apache Juneau 7.1.1)

java.lang.Object
- org.apache.juneau.Context
- - org.apache.juneau.BeanContext
  - - org.apache.juneau.rest.RestContext

```
public final class RestContext
extends BeanContext
```
Contains all the configuration on a REST resource and the entry points for handling REST calls.
See Also:
- Overview > juneau-rest-server > RestContext

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`REST_allowBodyParam` Configuration property: Allow body URL parameter.
`static String`	`REST_allowedMethodParams` Configuration property: Allowed method parameters.
`static String`	`REST_allowHeaderParams` Configuration property: Allow header URL parameters.
`static String`	`REST_callHandler` Configuration property: REST call handler.
`static String`	`REST_children` Configuration property: Children.
`static String`	`REST_classpathResourceFinder` Configuration property: Classpath resource finder.
`static String`	`REST_clientVersionHeader` Configuration property: Client version header.
`static String`	`REST_consumes` Configuration property: Supported content media types.
`static String`	`REST_contextPath` Configuration property: Resource context path.
`static String`	`REST_converters` Configuration property: Class-level response converters.
`static String`	`REST_defaultCharset` Configuration property: Default character encoding.
`static String`	`REST_defaultRequestHeaders` Configuration property: Default request headers.
`static String`	`REST_defaultResponseHeaders` Configuration property: Default response headers.
`static String`	`REST_encoders` Configuration property: Compression encoders.
`static String`	`REST_guards` Configuration property: Class-level guards.
`static String`	`REST_infoProvider` Configuration property: REST info provider.
`static String`	`REST_logger` Configuration property: REST logger.
`static String`	`REST_maxInput` Configuration property: The maximum allowed input size (in bytes) on HTTP requests.
`static String`	`REST_messages` Configuration property: Messages.
`static String`	`REST_mimeTypes` Configuration property: MIME types.
`static String`	`REST_paramResolvers` Configuration property: Java method parameter resolvers.
`static String`	`REST_parsers` Configuration property: Parsers.
`static String`	`REST_partParser` Configuration property: HTTP part parser.
`static String`	`REST_partSerializer` Configuration property: HTTP part serializer.
`static String`	`REST_path` Configuration property: Resource path.
`static String`	`REST_produces` Configuration property: Supported accept media types.
`static String`	`REST_renderResponseStackTraces` Configuration property: Render response stack traces in responses.
`static String`	`REST_resourceResolver` Configuration property: REST resource resolver.
`static String`	`REST_responseHandlers` Configuration property: Response handlers.
`static String`	`REST_serializers` Configuration property: Serializers.
`static String`	`REST_staticFileResponseHeaders` Configuration property: Static file response headers.
`static String`	`REST_staticFiles` Configuration property: Static file mappings.
`static String`	`REST_useClasspathResourceCaching` Configuration property: Use classpath resource caching.
`static String`	`REST_useStackTraceHashes` Configuration property: Use stack trace hashes.
`static String`	`REST_widgets` Configuration property: HTML Widgets.

Fields inherited from class org.apache.juneau.BeanContext
BEAN_beanClassVisibility, BEAN_beanConstructorVisibility, BEAN_beanDictionary, BEAN_beanDictionary_add, BEAN_beanDictionary_remove, BEAN_beanFieldVisibility, BEAN_beanFilters, BEAN_beanFilters_add, BEAN_beanFilters_remove, BEAN_beanMapPutReturnsOldValue, BEAN_beanMethodVisibility, BEAN_beansRequireDefaultConstructor, BEAN_beansRequireSerializable, BEAN_beansRequireSettersForGetters, BEAN_beansRequireSomeProperties, BEAN_beanTypePropertyName, BEAN_debug, BEAN_excludeProperties, BEAN_ignoreInvocationExceptionsOnGetters, BEAN_ignoreInvocationExceptionsOnSetters, BEAN_ignorePropertiesWithoutSetters, BEAN_ignoreUnknownBeanProperties, BEAN_ignoreUnknownNullBeanProperties, BEAN_implClasses, BEAN_includeProperties, BEAN_locale, BEAN_mediaType, BEAN_notBeanClasses, BEAN_notBeanClasses_add, BEAN_notBeanClasses_remove, BEAN_notBeanPackages, BEAN_notBeanPackages_add, BEAN_notBeanPackages_remove, BEAN_pojoSwaps, BEAN_pojoSwaps_add, BEAN_pojoSwaps_remove, BEAN_propertyNamer, BEAN_sortProperties, BEAN_timeZone, BEAN_useInterfaceProxies, BEAN_useJavaBeanIntrospector, DEFAULT, DEFAULT_SORTED

Constructor Summary

Constructors
Constructor and Description

RestContext(RestContextBuilder builder)
Constructor.

Constructors
Constructor and Description
`RestContext(RestContextBuilder builder)` Constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allowMethodParam(String m)` Returns true if the specified `Method` GET parameter value can be used to override the method name in the HTTP header.
`protected void`	`checkForInitException()` Throws a `RestException` if an exception occurred in the constructor of this object.
`BeanSessionArgs`	`createDefaultSessionArgs()` Unused.
`BeanSession`	`createSession(BeanSessionArgs args)` Unused.
`protected void`	`destroy()` Calls `Servlet.destroy()` on any child resources defined on this resource.
`protected RestParam[]`	`findParams(Method method, UrlPathPattern pathPattern, boolean isPreOrPost)` Finds the `RestParam` instances to handle resolving objects on the calls to the specified Java method.
`BeanContext`	`getBeanContext()` Returns the `BeanContext` object used for parsing path variables and header values.
`protected RestCallHandler`	`getCallHandler()` Returns the REST call handler used by this resource.
`Map<String,RestJavaMethod>`	`getCallMethods()` Returns the REST Java methods defined in this resource.
`protected Map<String,RestCallRouter>`	`getCallRouters()` Returns a map of HTTP method names to call routers.
`RestContext`	`getChildResource(String path)` Returns the context of the child resource associated with the specified path.
`Map<String,RestContext>`	`getChildResources()` Returns the child resources associated with this servlet.
`<T> T`	`getClasspathResource(Class<?> baseClass, Class<T> c, MediaType mediaType, String name, Locale locale)` Same as `getClasspathResource(Class, MediaType, String, Locale)`, except overrides the class used for retrieving the classpath resource.
`InputStream`	`getClasspathResource(Class<?> baseClass, String name, Locale locale)` Same as `getClasspathResource(String, Locale)`, but allows you to override the class used for looking up the classpath resource.
`<T> T`	`getClasspathResource(Class<T> c, MediaType mediaType, String name, Locale locale)` Reads the input stream from `getClasspathResource(String, Locale)` and parses it into a POJO using the parser matched by the specified media type.
`InputStream`	`getClasspathResource(String name, Locale locale)` Same as `Class.getResourceAsStream(String)` except if it doesn't find the resource on this class, searches up the parent hierarchy chain.
`String`	`getClasspathResourceAsString(Class<?> baseClass, String name, Locale locale)` Same as `getClasspathResourceAsString(String, Locale)`, but allows you to override the class used for looking up the classpath resource.
`String`	`getClasspathResourceAsString(String name, Locale locale)` Reads the input stream from `getClasspathResource(String, Locale)` into a String.
`String`	`getClientVersionHeader()` Returns the name of the client version header name used by this resource.
`Config`	`getConfig()` Returns the config file associated with this servlet.
`List<MediaType>`	`getConsumes()` Returns the explicit list of supported content types for this resource.
`String`	`getContextPath()` Returns the context path of the resource.
`RestConverter[]`	`getConverters()` Returns the converters associated with this resource at the class level.
`String`	`getDefaultCharset()` Returns the default charset to use on requests and responses when not specified on the request.
`Map<String,Object>`	`getDefaultRequestHeaders()` Returns the default request headers for this resource.
`Map<String,Object>`	`getDefaultResponseHeaders()` Returns the default response headers for this resource.
`EncoderGroup`	`getEncoders()` Returns the encoders associated with this resource.
`RestGuard[]`	`getGuards()` Returns the guards associated with this resource at the class level.
`RestInfoProvider`	`getInfoProvider()` Returns the REST information provider used by this resource.
`RestLogger`	`getLogger()` Returns the logger to use for this resource.
`long`	`getMaxInput()` Returns the maximum request input size in bytes.
`String`	`getMediaTypeForName(String name)` Returns the media type for the specified file name.
`MessageBundle`	`getMessages()` Returns the resource bundle used by this resource.
`RestContext`	`getParentContext()` Returns the parent resource context (if this resource was initialized from a parent).
`ParserGroup`	`getParsers()` Returns the parsers registered with this resource.
`HttpPartParser`	`getPartParser()` Returns the HTTP-part parser associated with this resource.
`HttpPartSerializer`	`getPartSerializer()` Returns the HTTP-part serializer associated with this resource.
`String`	`getPath()` Returns the path for this resource as defined by the `@RestResource.path()` annotation or `RestContextBuilder.path(String)` method concatenated with those on all parent classes.
`List<MediaType>`	`getProduces()` Returns the explicit list of supported accept types for this resource.
`RestContextProperties`	`getProperties()` Returns the class-level properties associated with this servlet.
`Object`	`getResource()` Returns the resource object.
`protected RestResourceResolver`	`getResourceResolver()` Returns the resource resolver associated with this context.
`protected ResponseHandler[]`	`getResponseHandlers()` Returns the response handlers associated with this resource.
`RestParam[]`	`getRestParams(Method method)` Returns the parameters defined on the specified Java method.
`RestServlet`	`getRestServlet()` Returns the resource object as a `RestServlet`.
`SerializerGroup`	`getSerializers()` Returns the serializers registered with this resource.
`String`	`getServletInitParameter(String name)` Returns the servlet init parameter returned by `ServletConfig.getInitParameter(String)`.
`int`	`getStackTraceOccurrence(Throwable e)` Returns the number of times this exception was thrown based on a hash of its stacktrace.
`VarResolver`	`getVarResolver()` Returns the variable resolver for this servlet.
`Map<String,Widget>`	`getWidgets()` The widgets used for resolving "$W{...}" variables.
`boolean`	`hasChildResources()` Returns true if this resource has any child resources associated with it.
`boolean`	`isAllowBodyParam()` Returns whether it's safe to pass the HTTP body as a "body" GET parameter.
`boolean`	`isAllowHeaderParams()` Returns whether it's safe to pass header values in as GET parameters.
`boolean`	`isRenderResponseStackTraces()` Returns whether it's safe to render stack traces in HTTP responses.
`boolean`	`isStaticFile(String p)` Returns true if the specified path refers to a static file.
`StreamResource`	`resolveStaticFile(String pathInfo)` Resolve a static resource file.

Methods inherited from class org.apache.juneau.BeanContext
_class, asMap, builder, create, createBeanSession, createBeanSession, createDefaultBeanSessionArgs, createSession, createSession, dumpCacheStats, getBeanMeta, getBeanRegistry, getBeanTypePropertyName, getClassMeta, getClassMeta, getClassMetaForObject, getExcludeProperties, getImplClassConstructor, getIncludeProperties, hasSameCache, isBean, isNotABean, newInstance, newInstance, newInstanceFromOuter, object, resolveClassMeta, string

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - REST_allowBodyParam
```
public static final String REST_allowBodyParam
```
    Configuration property: Allow body URL parameter.
    Property:
    - Name: "RestContext.allowBodyParam.b"
    - Data type: Boolean
    - Default: true
    - Session-overridable: false
    - Annotations:
      
      RestResource.allowBodyParam()
    - Methods:
      
      RestContextBuilder.allowBodyParam(boolean)
    Description:
    
    When enabled, the HTTP body content on PUT and POST requests can be passed in as text using the "body" URL parameter.
    For example:
    ?body=(name='John%20Smith',age=45)
    
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(allowBodyParam="$C{REST/allowBodyParam,false}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.allowBodyParam(false); // Same, but using property. builder.set(REST_allowBodyParam, false); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.allowBodyParam(false); } }
    
    Notes:
    - 'body' parameter name is case-insensitive.
    - Useful for debugging PUT and POST methods using only a browser.
    See Also:
    
    Constant Field Values
  - REST_allowedMethodParams
```
public static final String REST_allowedMethodParams
```
    Configuration property: Allowed method parameters.
    Property:
    - Name: "RestContext.allowedMethodParams.s"
    - Data type: String
    - Default: "HEAD,OPTIONS"
    - Session-overridable: false
    - Annotations:
      
      RestResource.allowedMethodParams()
    - Methods:
      
      RestContextBuilder.allowedMethodParams(String...)
    Description:
    
    When specified, the HTTP method can be overridden by passing in a "method" URL parameter on a regular GET request.
    For example:
    ?method=OPTIONS
    
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(allowMethodParams="$C{REST/allowMethodParams,HEAD\,OPTIONS\,PUT}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.allowMethodParams("HEAD,OPTIONS,PUT"); // Same, but using property. builder.set(REST_allowMethodParams, "HEAD,OPTIONS,PUT"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.allowMethodParams("HEAD", "OPTIONS", "PUT"); } }
    
    Notes:
    - Format is a comma-delimited list of HTTP method names that can be passed in as a method parameter.
    - 'method' parameter name is case-insensitive.
    - Use "*" to represent all methods.
    Note that per the HTTP specification, special care should be taken when allowing non-safe (POST, PUT, DELETE) methods to be invoked through GET requests.
    See Also:
    
    Constant Field Values
  - REST_allowHeaderParams
```
public static final String REST_allowHeaderParams
```
    Configuration property: Allow header URL parameters.
    Property:
    - Name: "RestContext.allowHeaderParams.b"
    - Data type: Boolean
    - Default: true
    - Session-overridable: false
    - Annotations:
      
      RestResource.allowHeaderParams()
    - Methods:
      
      RestContextBuilder.allowHeaderParams(boolean)
    Description:
    
    When enabled, headers such as "Accept" and "Content-Type" to be passed in as URL query parameters.
    For example:
    ?Accept=text/json&Content-Type=text/json
    
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(allowMethodParams="$C{REST/allowHeaderParams,false}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.allowHeaderParams(false); // Same, but using property. builder.set(REST_allowHeaderParams, false); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.allowHeaderParams(false); } }
    
    Notes:
    - Header names are case-insensitive.
    - Useful for debugging REST interface using only a browser.
    See Also:
    
    Constant Field Values
  - REST_callHandler
```
public static final String REST_callHandler
```
    Configuration property: REST call handler.
    Property:
    - Name: "RestContext.callHandler.o"
    - Data type: RestCallHandler | Class<? extends RestCallHandler>
    - Default: BasicRestCallHandler
    - Session-overridable: false
    - Annotations:
      
      RestResource.callHandler()
    - Methods:
      
      RestContextBuilder.callHandler(Class)
      RestContextBuilder.callHandler(RestCallHandler)
    Description:
    
    This class handles the basic lifecycle of an HTTP REST call.
    Subclasses can be used to customize how these HTTP calls are handled.
    Example:
    
    // Our customized call handler. public class MyRestCallHandler extends BasicRestCallHandler { // Must provide this constructor! public MyRestCallHandler(RestContext context) { super(context); } @Override public RestRequest createRequest(HttpServletRequest req) throws ServletException { // Low-level handling of requests. ... } @Override public void handleResponse(RestRequest req, RestResponse res, Object output) throws IOException, RestException { // Low-level handling of responses. ... } @Override public void handleNotFound(int rc, RestRequest req, RestResponse res) throws Exception { // Low-level handling of various error conditions. ... } } // Option #1 - Registered via annotation resolving to a config file setting with default value. @RestResource(callHandler=MyRestCallHandler.class) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.callHandler(MyRestCallHandler.class); // Same, but using property. builder.set(REST_callHandler, MyRestCallHandler.class); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.callHandler(MyRestCallHandler.class); } }
    
    Notes:
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(RestContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    
    Constant Field Values
  - REST_children
```
public static final String REST_children
```
    Configuration property: Children.
    Property:
    - Name: "RestContext.children.lo"
    - Data type: List<Class | Object | RestChild>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.children()
    - Methods:
      
      RestContextBuilder.child(String,Object)
      RestContextBuilder.children(Class...)
      RestContextBuilder.children(Object...)
    Description:
    
    Defines children of this resource.
    A REST child resource is simply another servlet or object that is initialized as part of the ascendant resource and has a servlet path directly under the ascendant resource object path.
    The main advantage to defining servlets as REST children is that you do not need to define them in the web.xml file of the web application.
    This can cut down on the number of entries that show up in the web.xml file if you are defining large numbers of servlets.
    Child resources must specify a value for @RestResource.path() that identifies the subpath of the child resource relative to the ascendant path UNLESS you use the RestContextBuilder.child(String, Object) method to register it.
    Child resources can be nested arbitrarily deep using this technique (i.e. children can also have children).
    
    Servlet initialization:
    
    A child resource will be initialized immediately after the ascendant servlet/resource is initialized.
    The child resource receives the same servlet config as the ascendant servlet/resource.
    This allows configuration information such as servlet initialization parameters to filter to child resources.
    
    Runtime behavior:
    
    As a rule, methods defined on the HttpServletRequest object will behave as if the child servlet were deployed as a top-level resource under the child's servlet path.
    For example, the getServletPath() and getPathInfo() methods on the HttpServletRequest object will behave as if the child resource were deployed using the child's servlet path.
    Therefore, the runtime behavior should be equivalent to deploying the child servlet in the web.xml file of the web application.
    
    Example:
    
    // Our child resource. @RestResource(path="/child") public class MyChildResource {...} // Option #1 - Registered via annotation. @RestResource(children={MyChildResource.class}) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.children(MyChildResource.class); // Same, but using property. builder.addTo(REST_children, MyChildResource.class)); // Use a pre-instantiated object instead. builder.child("/child", new MyChildResource()); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.children(MyChildResource.class); } }
    Notes:
    - When defined as classes, instances are resolved using the registered REST_resourceResolver which by default is BasicRestResourceResolver which requires the class have one of the following constructors:
      
      public T(RestContextBuilder)
      public T()
    See Also:
    - Overview > juneau-rest-server > Children
    See Also:
    
    Constant Field Values
  - REST_classpathResourceFinder
```
public static final String REST_classpathResourceFinder
```
    Configuration property: Classpath resource finder.
    Property:
    - Name: "RestContext.classpathResourceFinder.o"
    - Data type: ClasspathResourceFinder
    - Default: ClasspathResourceFinderBasic
    - Session-overridable: false
    - Annotations:
      
      RestResource.classpathResourceFinder()
    - Methods:
      
      RestContextBuilder.classpathResourceFinder(Class)
      RestContextBuilder.classpathResourceFinder(ClasspathResourceFinder)
    Description:
    
    Used to retrieve localized files from the classpath.
    Used by the following methods:
    - RestContext
      
      getClasspathResource(String,Locale)
      getClasspathResource(Class,String,Locale)
      getClasspathResource(Class,MediaType,String,Locale)
      getClasspathResource(Class,Class,MediaType,String,Locale)
      getClasspathResourceAsString(String,Locale)
      getClasspathResourceAsString(Class,String,Locale)
      resolveStaticFile(String)
    - RestRequest
      
      getClasspathReaderResource(String)
      getClasspathReaderResource(String,boolean)
      getClasspathReaderResource(String,boolean,MediaType)
    It also affects the behavior of the REST_staticFiles property.
    Example:
    
    // Our customized classpath resource finder. public class MyClasspathResourceFinder extends ClasspathResourceFinderBasic { @Override public InputStream findResource(Class<?> baseClass, String name, Locale locale) throws IOException { // Do your own resolution. } } // Option #1 - Registered via annotation. @RestResource(classpathResourceFinder=MyClasspathResourceFinder.class) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.classpathResourceFinder(MyClasspathResourceFinder.class); // Same, but using property. builder.set(REST_classpathResourceFinder, MyClasspathResourceFinder.class)); // Use a pre-instantiated object instead. builder.classpathResourceFinder(new MyClasspathResourceFinder()); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.classpathResourceFinder(MyClasspathResourceFinder.class); } }
    Notes:
    - The default value is ClasspathResourceFinderBasic which provides basic support for finding localized resources on the classpath and JVM working directory.
      The ClasspathResourceFinderRecursive is another option that also recursively searches for resources up the class-hierarchy.
      Each of these classes can be extended to provide customized handling of resource retrieval.
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(RestContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    
    Constant Field Values
  - REST_clientVersionHeader
```
public static final String REST_clientVersionHeader
```
    Configuration property: Client version header.
    Property:
    - Name: "RestContext.clientVersionHeader.s"
    - Data type: String
    - Default: "X-Client-Version"
    - Session-overridable: false
    - Annotations:
      
      RestResource.clientVersionHeader()
    - Methods:
      
      RestContextBuilder.clientVersionHeader(String)
    Description:
    
    Specifies the name of the header used to denote the client version on HTTP requests.
    The client version is used to support backwards compatibility for breaking REST interface changes.
    Used in conjunction with @RestMethod.clientVersion() annotation.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(clientVersionHeader="$C{REST/clientVersionHeader,Client-Version}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.clientVersionHeader("Client-Version"); // Same, but using property. builder.set(REST_clientVersionHeader, "Client-Version"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.clientVersionHeader("Client-Version"); } }
    
    // Call this method if Client-Version is at least 2.0. // Note that this also matches 2.0.1. @RestMethod(name=GET, path="/foobar", clientVersion="2.0") public Object method1() { ... } // Call this method if Client-Version is at least 1.1, but less than 2.0. @RestMethod(name=GET, path="/foobar", clientVersion="[1.1,2.0)") public Object method2() { ... } // Call this method if Client-Version is less than 1.1. @RestMethod(name=GET, path="/foobar", clientVersion="[0,1.1)") public Object method3() { ... }
    See Also:
    
    Constant Field Values
  - REST_contextPath
```
public static final String REST_contextPath
```
    Configuration property: Resource context path.
    Property:
    - Name: "RestContext.contextPath.s"
    - Data type: String
    - Default: null
    - Session-overridable: false
    - Annotations:
      
      RestResource.contextPath()
    - Methods:
      
      RestContextBuilder.contextPath(String)
    Description:
    
    Overrides the context path value for this resource and any child resources.
    This setting is useful if you want to use "context:/child/path" URLs in child resource POJOs but the context path is not actually specified on the servlet container.
    Affects the following methods:
    - RestRequest.getContextPath() - Returns the overridden context path for the resource.
    - RestRequest.getServletPath() - Includes the overridden context path for the resource.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(path="/servlet", contextPath="$C{REST/contextPathOverride,/foo}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.contextPath("/foo"); // Same, but using property. builder.set(REST_contextPath, "/foo"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.contextPath("/foo"); } }
    See Also:
    
    Constant Field Values
  - REST_converters
```
public static final String REST_converters
```
    Configuration property: Class-level response converters.
    Property:
    - Name: "RestContext.converters.lo"
    - Data type: List<RestConverter | Class<? extends RestConverter>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.converters()
      RestMethod.converters()
    - Methods:
      
      RestContextBuilder.converters(Class...)
      RestContextBuilder.converters(RestConverter...)
    Description:
    
    Associates one or more converters with a resource class.
    These converters get called immediately after execution of the REST method in the same order specified in the annotation.
    The object passed into this converter is the object returned from the Java method or passed into the RestResponse.setOutput(Object) method.
    Can be used for performing post-processing on the response object before serialization.
    When multiple converters are specified, they're executed in the order they're specified in the annotation (e.g. first the results will be traversed, then the resulting node will be searched/sorted).
    Example:
    
    // Our converter. public class MyConverter implements RestConverter { @Override public Object convert(RestRequest req, Object o) { // Do something with object and return another object. // Or just return the same object for a no-op. } } // Option #1 - Registered via annotation resolving to a config file setting with default value. @RestResource(converters={MyConverter.class}) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.converters(MyConverter.class); // Same, but using property. builder.set(REST_converters, MyConverter.class); // Pass in an instance instead. builder.converters(new MyConverter()); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.converters(MyConverter.class); } }
    
    See Also:
    - Traversable - Allows URL additional path info to address individual elements in a POJO tree.
    - Queryable - Allows query/view/sort functions to be performed on POJOs.
    - Introspectable - Allows Java public methods to be invoked on the returned POJOs.
    See Also:
    - Overview > juneau-rest-server > Converters
    Notes:
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(BeanContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    
    Constant Field Values
  - REST_defaultCharset
```
public static final String REST_defaultCharset
```
    Configuration property: Default character encoding.
    Property:
    - Name: "RestContext.defaultCharset.s"
    - Data type: String
    - Default: "utf-8"
    - Session-overridable: false
    - Annotations:
      
      RestResource.defaultCharset()
      RestMethod.defaultCharset()
    - Methods:
      
      RestContextBuilder.defaultCharset(String)
      RestContextBuilder.defaultCharset(Charset)
    Description:
    
    The default character encoding for the request and response if not specified on the request.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(defaultCharset="$C{REST/defaultCharset,US-ASCII}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.defaultCharset("US-ASCII"); // Same, but using property. builder.set(REST_defaultCharset, "US-ASCII"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.defaultCharset("US-ASCII"); } // Override at the method level. @RestMethod(defaultCharset="UTF-16") public Object myMethod() {...} }
    See Also:
    
    Constant Field Values
  - REST_defaultRequestHeaders
```
public static final String REST_defaultRequestHeaders
```
    Configuration property: Default request headers.
    Property:
    - Name: "RestContext.defaultRequestHeaders.smo"
    - Data type: Map<String,String>
    - Default: empty map
    - Session-overridable: false
    - Annotations:
      
      RestResource.defaultRequestHeaders()
      RestMethod.defaultRequestHeaders()
    - Methods:
      
      RestContextBuilder.defaultRequestHeader(String,Object)
      RestContextBuilder.defaultRequestHeaders(String...)
    Description:
    
    Specifies default values for request headers if they're not passed in through the request.
    Notes:
    - Strings are in the format "Header-Name: header-value".
    - Affects values returned by RestRequest.getHeader(String) when the header is not present on the request.
    - The most useful reason for this annotation is to provide a default Accept header when one is not specified so that a particular default Serializer is picked.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(defaultRequestHeaders={"Accept: application/json", "My-Header: $C{REST/myHeaderValue}"}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder .defaultRequestHeader("Accept", "application/json"); .defaultRequestHeaders("My-Header: foo"); // Same, but using property. builder.addTo(REST_defaultRequestHeaders, "Accept", "application/json"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.defaultRequestHeader("Accept", "application/json"); } // Override at the method level. @RestMethod(defaultRequestHeaders={"Accept: text/xml"}) public Object myMethod() {...} }
    See Also:
    
    Constant Field Values
  - REST_defaultResponseHeaders
```
public static final String REST_defaultResponseHeaders
```
    Configuration property: Default response headers.
    Property:
    - Name: "RestContext.defaultResponseHeaders.omo"
    - Data type: Map<String,String>
    - Default: empty map
    - Session-overridable: false
    - Annotations:
      
      RestResource.defaultResponseHeaders()
    - Methods:
      
      RestContextBuilder.defaultResponseHeader(String,Object)
      RestContextBuilder.defaultResponseHeaders(String...)
    Description:
    
    Specifies default values for response headers if they're not set after the Java REST method is called.
    Notes:
    - Strings are in the format "Header-Name: header-value".
    - This is equivalent to calling RestResponse.setHeader(String, String) programmatically in each of the Java methods.
    - The header value will not be set if the header value has already been specified (hence the 'default' in the name).
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(defaultResponseHeaders={"Content-Type: $C{REST/defaultContentType,text/plain}","My-Header: $C{REST/myHeaderValue}"}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder .defaultResponseHeader("Content-Type", "text/plain"); .defaultResponseHeaders("My-Header: foo"); // Same, but using property. builder .addTo(REST_defaultRequestHeaders, "Accept", "application/json"); .addTo(REST_defaultRequestHeaders, "My-Header", "foo"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.defaultResponseHeader("Content-Type", "text/plain"); } }
    See Also:
    
    Constant Field Values
  - REST_encoders
```
public static final String REST_encoders
```
    Configuration property: Compression encoders.
    Property:
    - Name: "RestContext.encoders.o"
    - Data type: List<Encoder | Class<? extends Encoder>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.encoders()
      RestMethod.encoders()
    - Methods:
      
      RestContextBuilder.encoders(Class...)
      RestContextBuilder.encoders(Encoder...)
    Description:
    
    These can be used to enable various kinds of compression (e.g. "gzip") on requests and responses.
    Example:
    
    // Option #1 - Registered via annotation. @RestResource(encoders={GzipEncoder.class}) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.encoders(GzipEncoder.class); // Same, but using property. builder.addTo(REST_encoders, GzipEncoder.class); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.encoders(GzipEncoder.class); } // Override at the method level. @RestMethod(encoders={MySpecialEncoder.class}, inherit={"ENCODERS"}) public Object myMethod() {...} }
    
    Notes:
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(BeanContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    - Overview > juneau-rest-server > Encoders
    See Also:
    
    Constant Field Values
  - REST_guards
```
public static final String REST_guards
```
    Configuration property: Class-level guards.
    Property:
    - Name: "RestContext.guards.lo"
    - Data type: List<RestGuard | Class<? extends RestGuard>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.guards()
      RestMethod.guards()
    - Methods:
      
      RestContextBuilder.guards(Class...)
      RestContextBuilder.guards(RestGuard...)
    Description:
    
    Associates one or more RestGuards with all REST methods defined in this class.
    These guards get called immediately before execution of any REST method in this class.
    If multiple guards are specified, ALL guards must pass.
    Note that this is different than matchers were only ONE matcher needs to pass.
    Example:
    
    // Define a guard that only lets Billy make a request. public BillyGuard extends RestGuard { @Override public boolean isRequestAllowed(RestRequest req) { return req.getUserPrincipal().getName().equals("Billy"); } } // Option #1 - Registered via annotation. @RestResource(guards={BillyGuard.class}) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.guards(BillyGuard.class); // Same, but using property. builder.addTo(REST_guards, BillyGuard.class); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.guards(BillyGuard.class); } // Override at the method level. @RestMethod(guards={SomeOtherGuard.class}) public Object myMethod() {...} }
    
    Notes:
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(RestContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    - Overview > juneau-rest-server > Guards
    See Also:
    
    Constant Field Values
  - REST_infoProvider
```
public static final String REST_infoProvider
```
    Configuration property: REST info provider.
    Property:
    - Name: "RestContext.infoProvider.o"
    - Data type: RestInfoProvider | Class<? extends RestInfoProvider>
    - Default: BasicRestInfoProvider
    - Session-overridable: false
    - Annotations:
      
      RestResource.infoProvider()
    - Methods:
      
      RestContextBuilder.infoProvider(Class)
      RestContextBuilder.infoProvider(RestInfoProvider)
    Description:
    
    Class used to retrieve title/description/swagger information about a resource.
    Example:
    
    // Our customized info provider. // Extend from the default implementation and selectively override values. public class MyRestInfoProvider extends BasicRestInfoProvider { // Must provide this constructor! public MyRestInfoProvider(RestContext context) { super(context); } @Override public Swagger getSwaggerFromFile(RestRequest req) throws RestException { // Provide our own method of retrieving swagger from file system. } @Override public Swagger getSwagger(RestRequest req) throws RestException { Swagger s = super.getSwagger(req); // Made inline modifications to generated swagger. return s; } @Override public String getSiteName(RestRequest req) { // Override the site name. } } // Option #1 - Registered via annotation resolving to a config file setting with default value. @RestResource(infoProvider=MyRestInfoProvider.class) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.infoProvider(MyRestInfoProvider.class); // Same, but using property. builder.set(REST_infoProvider, MyRestInfoProvider.class); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.infoProvider(MyRestInfoProvider.class); } }
    
    Notes:
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(RestContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    
    Constant Field Values
  - REST_logger
```
public static final String REST_logger
```
    Configuration property: REST logger.
    Property:
    - Name: "RestContext.logger.o"
    - Data type: RestLogger | Class<? extends RestLogger>
    - Default: BasicRestLogger
    - Session-overridable: false
    - Annotations:
      
      RestResource.logger()
    - Methods:
      
      RestContextBuilder.logger(Class)
      RestContextBuilder.logger(RestLogger)
    Description:
    
    Specifies the logger to use for logging.
    Two implementations are provided by default:
    - BasicRestLogger - Default logging.
    - NoOpRestLogger - Logging disabled.
    Loggers are accessible through the following:
    - RestContext.getLogger()
    - RestRequest.getLogger()
    Example:
    
    // Our customized logger. public class MyRestLogger extends BasicRestLogger { @Override public void log(Level level, Throwable cause, String msg, Object...args) { // Handle logging ourselves. } } // Option #1 - Registered via annotation resolving to a config file setting with default value. @RestResource(logger=MyRestLogger.class) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.logger(MyRestLogger.class); // Same, but using property. builder.set(REST_logger, MyRestLogger.class); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.logger(MyRestLogger.class); } }
    
    See Also:
    - Overview > juneau-rest-server > Logging and Error Handling
    See Also:
    
    Constant Field Values
  - REST_maxInput
```
public static final String REST_maxInput
```
    Configuration property: The maximum allowed input size (in bytes) on HTTP requests.
    Property:
    - Name: "RestContext.maxInput.s"
    - Data type: String
    - Default: "100M"
    - Session-overridable: false
    - Annotations:
      
      RestResource.maxInput()
      RestMethod.maxInput()
    - Methods:
      
      RestContextBuilder.maxInput(String)
    Description:
    
    Useful for alleviating DoS attacks by throwing an exception when too much input is received instead of resulting in out-of-memory errors which could affect system stability.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(maxInput="$C{REST/maxInput,10M}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.maxInput("10M"); // Same, but using property. builder.set(REST_maxInput, "10M"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.maxInput("10M"); } // Override at the method level. @RestMethod(maxInput="10M") public Object myMethod() {...} }
    
    Notes:
    - String value that gets resolved to a long.
    - Can be suffixed with any of the following representing kilobytes, megabytes, and gigabytes: 'K', 'M', 'G'.
    - A value of "-1" can be used to represent no limit.
    See Also:
    
    Constant Field Values
  - REST_messages
```
public static final String REST_messages
```
    Configuration property: Messages.
    Property:
    - Name: "RestContext.messages.lo"
    - Data type: List<MessageBundleLocation>
    - Default: null
    - Session-overridable: false
    - Annotations:
      
      RestResource.messages()
    - Methods:
      
      RestContextBuilder.messages(String),
      RestContextBuilder.messages(Class,String)
      RestContextBuilder.messages(MessageBundleLocation...)
    Description:
    
    Identifies the location of the resource bundle for this class.
    This annotation is used to provide localized messages for the following methods:
    - RestRequest.getMessage(String, Object...)
    - RestContext.getMessages()
    Messages are also available by passing either of the following parameter types into your Java method:
    - ResourceBundle - Basic Java resource bundle.
    - MessageBundle - Extended resource bundle with several convenience methods.
    Messages passed into Java methods already have their locale set to that of the incoming request.
    The value can be a relative path like "nls/Messages", indicating to look for the resource bundle "com.foo.sample.nls.Messages" if the resource class is in "com.foo.sample", or it can be an absolute path like "com.foo.sample.nls.Messages"
    Examples:
    
    package org.apache.foo; // Resolve messages to org/apache/foo/nls/MyMessages.properties @RestResource(messages="nls/MyMessages") public class MyResource {...} @RestMethod(name="GET", path="/hello/{you}") public Object helloYou(RestRequest req, MessageBundle messages, @Path("name") String you)) { String s; // Get it from the RestRequest object. s = req.getMessage("HelloMessage", you); // Or get it from the method parameter. s = messages.getString("HelloMessage", you); // Or get the message in a locale different from the request. s = messages.getString(Locale.UK, "HelloMessage", you); return s; } }
    
    Notes:
    - Mappings are cumulative from super classes.
      Therefore, you can find and retrieve messages up the class-hierarchy chain.
    See Also:
    - Overview > juneau-rest-server > Messages
    See Also:
    
    Constant Field Values
  - REST_mimeTypes
```
public static final String REST_mimeTypes
```
    Configuration property: MIME types.
    Property:
    - Name: "RestContext.mimeTypes.ss"
    - Data type: Set<String>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.mimeTypes()
    - Methods:
      
      RestContextBuilder.mimeTypes(String...)
    Description:
    
    Defines MIME-type file type mappings.
    Used for specifying the content type on file resources retrieved through the following methods:
    This list appends to the existing list provided by ExtendedMimetypesFileTypeMap.
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(mimeTypes={"text/plain txt text TXT"}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.mimeTypes("text/plain txt text TXT"); // Same, but using property. builder.addTo(REST_mimeTypes, "text/plain txt text TXT"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.mimeTypes("text/plain txt text TXT"); } }
    
    Notes:
    - Values are .mime.types formatted entry string.
      Example: "image/svg+xml svg"
    See Also:
    
    Constant Field Values
  - REST_paramResolvers
```
public static final String REST_paramResolvers
```
    Configuration property: Java method parameter resolvers.
    Property:
    - Name: "RestContext.paramResolvers.lo"
    - Data type: List<RestParam | Class<? extends RestParam>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.paramResolvers()
    - Methods:
      
      RestContextBuilder.paramResolvers(Class...)
      RestContextBuilder.paramResolvers(RestParam...)
    Description:
    
    By default, the Juneau framework will automatically Java method parameters of various types (e.g. RestRequest, Accept, Reader). This setting allows you to provide your own resolvers for your own class types that you want resolved.
    For example, if you want to pass in instances of MySpecialObject to your Java method, define the following resolver:
    // Define a parameter resolver for resolving MySpecialObject objects. public class MyRestParam extends RestParam { // Must have no-arg constructor! public MyRestParam() { // First two parameters help with Swagger doc generation. super(QUERY, "myparam", MySpecialObject.class); } // The method that creates our object. // In this case, we're taking in a query parameter and converting it to our object. public Object resolve(RestRequest req, RestResponse res) throws Exception { return new MySpecialObject(req.getQuery().get("myparam")); } } // Option #1 - Registered via annotation. @RestResource(paramResolvers=MyRestParam.class) public class MyResource { // Option #2 - Registered via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.paramResolvers(MyRestParam.class); // Same, but using property. builder.addTo(REST_paramResolver, MyRestParam.class); } // Option #3 - Registered via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.paramResolvers(MyRestParam.class); } // Now pass it into your method. @RestMethod(...) public Object doMyMethod(MySpecialObject mySpeciaObject) { // Do something with it. } }
    
    Notes:
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(BeanContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    - Refer to RestParam for the list of predefined parameter resolvers.
    See Also:
    
    Constant Field Values
  - REST_parsers
```
public static final String REST_parsers
```
    Configuration property: Parsers.
    Property:
    - Name: "RestContext.parsers.lo"
    - Data type: List<Parser | Class<? extends Parser>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.parsers()
      RestMethod.parsers()
    - Methods:
      
      RestContextBuilder.parsers(Object...)
      RestContextBuilder.parsers(Class...)
      RestContextBuilder.parsers(boolean,Object...)
    Description:
    
    Adds class-level parsers to this resource.
    Parsers are used to convert the body of HTTP requests into POJOs.
    Any of the Juneau framework parsers can be used in this setting.
    The parser selected is based on the request Content-Type header matched against the values returned by the following method using a best-match algorithm:
    - Parser.getMediaTypes()
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(parsers={JsonParser.class, XmlParser.class}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.parsers(JsonParser.class, XmlParser.class); // Same, but use pre-instantiated parsers. builder.parsers(JsonParser.DEFAULT, XmlParser.DEFAULT); // Same, but using property. builder.set(REST_parsers, JsonParser.class, XmlParser.class); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.parsers(JsonParser.class, XmlParser.class); } // Override at the method level. @RestMethod(parsers={HtmlParser.class}) public Object myMethod(@Body MyPojo myPojo) { // Do something with your parsed POJO. } }
    
    Notes:
    - When defined as a class, properties/transforms defined on the resource/method are inherited.
    - When defined as an instance, properties/transforms defined on the resource/method are NOT inherited.
    - Typically, you'll want your resource to extend directly from BasicRestServlet which comes preconfigured with the following parsers:
      
      JsonParser
      XmlParser
      HtmlParser
      UonParser
      UrlEncodingParser
      MsgPackParser
      PlainTextParser
    See Also:
    - Overview > juneau-rest-server > Parsers
    See Also:
    
    Constant Field Values
  - REST_partParser
```
public static final String REST_partParser
```
    Configuration property: HTTP part parser.
    Property:
    - Name: "RestContext.partParser.o"
    - Data type: HttpPartParser | Class<? extends HttpPartParser>
    - Default: UonPartParser
    - Session-overridable: false
    - Annotations:
      
      RestResource.partParser()
    - Methods:
      
      RestContextBuilder.partParser(Class)
      RestContextBuilder.partParser(HttpPartParser)
    Description:
    
    Specifies the HttpPartParser to use for parsing headers, query/form parameters, and URI parts.
    The default value is UonPartParser which allows for both plain-text and URL-Encoded-Object-Notation values.
    If your parts contain text that can be confused with UON (e.g. "(foo)"), you can switch to SimplePartParser which treats everything as plain text.
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(partParser=SimplePartParser.class) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.partParser(SimplePartParser.class); // Same, but using property. builder.set(REST_partParser, SimplePartParser.class); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.partParser(SimplePartParser.class); } @RestMethod(...) public Object myMethod(@Header("My-Header") MyParsedHeader h, @Query("myquery") MyParsedQuery q) { // Do something with your parsed parts. } }
    
    Notes:
    - When defined as a class, properties/transforms defined on the resource/method are inherited.
    - When defined as an instance, properties/transforms defined on the resource/method are NOT inherited.
    See Also:
    
    Constant Field Values
  - REST_partSerializer
```
public static final String REST_partSerializer
```
    Configuration property: HTTP part serializer.
    Property:
    - Name: "RestContext.partSerializer.o"
    - Data type: HttpPartSerializer | Class<? extends HttpPartSerializer>
    - Default: SimpleUonPartSerializer
    - Session-overridable: false
    - Annotations:
      
      RestResource.partSerializer()
    - Methods:
      
      RestContextBuilder.partSerializer(Class)
      RestContextBuilder.partSerializer(HttpPartSerializer)
    Description:
    
    Specifies the HttpPartSerializer to use for serializing headers, query/form parameters, and URI parts.
    The default value is SimpleUonPartSerializer which serializes UON notation for beans and maps, and plain text for everything else.
    Other options include:
    - SimplePartSerializer - Always serializes to plain text.
    - UonPartSerializer - Always serializers to UON.
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(partSerializer=SimplePartSerializer.class) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.partSerializer(SimplePartSerializer.class); // Same, but using property. builder.set(REST_partSerializer, SimplePartSerializer.class); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.partSerializer(SimplePartSerializer.class); } @RestMethod(...) public Object myMethod(RestResponse res) { // Set a header to a POJO. res.setHeader("My-Header", new MyPojo()); } }
    
    Notes:
    - When defined as a class, properties/transforms defined on the resource/method are inherited.
    - When defined as an instance, properties/transforms defined on the resource/method are NOT inherited.
    See Also:
    
    Constant Field Values
  - REST_path
```
public static final String REST_path
```
    Configuration property: Resource path.
    Property:
    - Name: "RestContext.path.s"
    - Data type: String
    - Default: null
    - Session-overridable: false
    - Annotations:
      
      RestResource.path()
    - Methods:
      
      RestContextBuilder.path(String)
    Description:
    
    Identifies the URL subpath relative to the ascendant resource.
    This setting is critical for the routing of HTTP requests from ascendant to child resources.
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(path="/myResource") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.path("/myResource"); // Same, but using property. builder.set(REST_path, "/myResource"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.path("/myResource"); } }
    
    Notes:
    - This annotation is ignored on top-level servlets (i.e. servlets defined in web.xml files).
      Therefore, implementers can optionally specify a path value for documentation purposes.
    - Typically, this setting is only applicable to resources defined as children through the @RestResource.children() annotation.
      However, it may be used in other ways (e.g. defining paths for top-level resources in microservices).
    - Slashes are trimmed from the path ends.
      As a convention, you may want to start your path with '/' simple because it make it easier to read.
    - This path is available through the following method:
      
      RestContext.getPath()
    See Also:
    
    Constant Field Values
  - REST_renderResponseStackTraces
```
public static final String REST_renderResponseStackTraces
```
    Configuration property: Render response stack traces in responses.
    Property:
    - Name: "RestContext.renderResponseStackTraces.b"
    - Data type: Boolean
    - Default: false
    - Session-overridable: false
    - Annotations:
      
      RestResource.renderResponseStackTraces()
    - Methods:
      
      RestContextBuilder.renderResponseStackTraces(boolean)
      RestContextBuilder.renderResponseStackTraces()
    Description:
    
    Render stack traces in HTTP response bodies when errors occur.
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(renderResponseStackTraces=true) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.renderResponseStackTraces(); // Same, but using property. builder.set(REST_renderResponseStackTraces, true); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.renderResponseStackTraces(); } }
    
    Notes:
    - Useful for debugging, although allowing stack traces to be rendered may cause security concerns so use caution when enabling.
    - This setting is available through the following method:
      
      RestContext.isRenderResponseStackTraces()
      That method is used by BasicRestCallHandler.renderError(HttpServletRequest, HttpServletResponse, RestException).
    See Also:
    
    Constant Field Values
  - REST_resourceResolver
```
public static final String REST_resourceResolver
```
    Configuration property: REST resource resolver.
    Property:
    - Name: "RestContext.resourceResolver.o"
    - Data type: RestResourceResolver | Class<? extends RestResourceResolver>
    - Default: BasicRestResourceResolver
    - Session-overridable: false
    - Annotations:
      
      RestResource.resourceResolver()
    - Methods:
      
      RestContextBuilder.resourceResolver(Class)
      RestContextBuilder.resourceResolver(RestResourceResolver)
    Description:
    
    The resolver used for resolving instances of child resources.
    Can be used to provide customized resolution of REST resource class instances (e.g. resources retrieve from Spring).
    Example:
    
    // Our custom resource resolver. public class MyResourceResolver extends RestResourceResolverSimple { @Override public Object resolve(Class<?> resourceType, RestContextBuilder builder) throws Exception { Object resource = findOurResourceSomehow(resourceType); // If we can't resolve it, use default resolution. if (resource == null) resource = super.resolve(resourceType, builder); return resource; } } // Option #1 - Defined via annotation. @RestResource(resourceResolver=MyResourceResolver.class) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.resourceResolver(MyResourceResolver.class); // Same, but using property. builder.set(REST_resourceResolver, MyResourceResolver.class); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.resourceResolver(MyResourceResolver.class); } }
    
    Notes:
    - Unless overridden, resource resolvers are inherited from ascendant resources.
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(RestContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    - Overview > juneau-rest-server > Resource Resolvers
    - Overview > juneau-rest-server > Using with Spring and Injection frameworks
    See Also:
    
    Constant Field Values
  - REST_responseHandlers
```
public static final String REST_responseHandlers
```
    Configuration property: Response handlers.
    Property:
    - Name: "RestContext.responseHandlers.lo"
    - Data type: List<ResponseHandler | Class<? extends ResponseHandler>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.responseHandlers()
    - Methods:
      
      RestContextBuilder.responseHandlers(Class...)
      RestContextBuilder.responseHandlers(ResponseHandler...)
    Description:
    
    Specifies a list of ResponseHandler classes that know how to convert POJOs returned by REST methods or set via RestResponse.setOutput(Object) into appropriate HTTP responses.
    By default, the following response handlers are provided out-of-the-box:
    - StreamableHandler - Streamable objects.
    - WritableHandler - Writable objects.
    - ReaderHandler - Reader objects.
    - InputStreamHandler - InputStream objects.
    - RedirectHandler - Redirect objects.
    - ZipFileListResponseHandler - ZipFileList objects.
    - DefaultHandler - All other POJOs.
    Example:
    
    // Our custom response handler for MySpecialObject objects. public class MyResponseHandler implements ResponseHandler { @Override public boolean handle(RestRequest req, RestResponse res, Object output) throws IOException, RestException { if (output instanceof MySpecialObject) { try (Writer w = res.getNegotiatedWriter()) { //Pipe it to the writer ourselves. } return true; // We handled it. } return false; // We didn't handle it. } } // Option #1 - Defined via annotation. @RestResource(responseHandlers=MyResponseHandler.class) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.responseHandlers(MyResponseHandler.class); // Same, but using property. builder.addTo(REST_responseHandlers, MyResponseHandler.class); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.responseHandlers(MyResponseHandler.class); } @RestMethod(...) public Object myMethod() { // Return a special object for our handler. return new MySpecialObject(); } }
    
    Notes:
    - Response handlers resolvers are always inherited from ascendant resources.
    - When defined as a class, the implementation must have one of the following constructors:
      
      public T(RestContext)
      public T()
    - Inner classes of the REST resource class are allowed.
    See Also:
    
    Constant Field Values
  - REST_serializers
```
public static final String REST_serializers
```
    Configuration property: Serializers.
    Property:
    - Name: "RestContext.serializers.lo"
    - Data type: List<Serializer | Class<? extends Serializer>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.serializers()
      RestMethod.serializers()
    - Methods:
      
      RestContextBuilder.serializers(Object...)
      RestContextBuilder.serializers(Class...)
      RestContextBuilder.serializers(boolean,Object...)
    Description:
    
    Adds class-level serializers to this resource.
    Serializer are used to convert POJOs to HTTP response bodies.
    Any of the Juneau framework serializers can be used in this setting.
    The serializer selected is based on the request Accept header matched against the values returned by the following method using a best-match algorithm:
    - Serializer.getMediaTypes()
    Example:
    
    // Option #1 - Defined via annotation. @RestResource(serializers={JsonSerializer.class, XmlSerializer.class}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.serializers(JsonSerializer.class, XmlSerializer.class); // Same, but use pre-instantiated parsers. builder.serializers(JsonSerializer.DEFAULT, XmlSerializer.DEFAULT); // Same, but using property. builder.set(REST_serializers, JsonSerializer.class, XmlSerializer.class); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.serializers(JsonSerializer.class, XmlSerializer.class); } // Override at the method level. @RestMethod(serializers={HtmlSerializer.class}) public MyPojo myMethod() { // Return a POJO to be serialized. return new MyPojo(); } }
    
    Notes:
    - When defined as a class, properties/transforms defined on the resource/method are inherited.
    - When defined as an instance, properties/transforms defined on the resource/method are NOT inherited.
    - Typically, you'll want your resource to extend directly from BasicRestServlet which comes preconfigured with the following serializers:
      
      HtmlDocSerializer
      HtmlStrippedDocSerializer
      HtmlSchemaDocSerializer
      JsonSerializer
      JsonSerializer.Simple
      JsonSchemaSerializer
      XmlDocSerializer
      XmlSchemaDocSerializer
      UonSerializer
      UrlEncodingSerializer
      MsgPackSerializer
      SoapXmlSerializer
      PlainTextSerializer
    See Also:
    - Overview > juneau-rest-server > Serializers
    See Also:
    
    Constant Field Values
  - REST_staticFileResponseHeaders
```
public static final String REST_staticFileResponseHeaders
```
    Configuration property: Static file response headers.
    Property:
    - Name: "RestContext.staticFileResponseHeaders.omo"
    - Data type: Map<String,String>
    - Default: {'Cache-Control': 'max-age=86400, public}
    - Session-overridable: false
    - Annotations:
      
      RestResource.staticFileResponseHeaders()
    - Methods:
      
      RestContextBuilder.staticFileResponseHeaders(boolean,Map)
      RestContextBuilder.staticFileResponseHeaders(String...)
      RestContextBuilder.staticFileResponseHeader(String,String)
    Description:
    
    Used to customize the headers on responses returned for statically-served files.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource( staticFileResponseHeaders={ "Cache-Control: $C{REST/cacheControl,nocache}", "My-Header: $C{REST/myHeaderValue}" } ) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder .staticFileResponseHeader("Cache-Control", "nocache"); .staticFileResponseHeaders("My-Header: foo"); // Same, but using property. builder .addTo(REST_staticFileResponseHeaders, "Cache-Control", "nocache"); .addTo(REST_staticFileResponseHeaders, "My-Header", "foo"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.staticFileResponseHeader("Cache-Control", "nocache"); } }
    
    See Also:
    - REST_staticFiles for information about statically-served files.
    See Also:
    
    Constant Field Values
  - REST_staticFiles
```
public static final String REST_staticFiles
```
    Configuration property: Static file mappings.
    Property:
    - Name: "RestContext.staticFiles.lo"
    - Data type: List<StaticFileMapping>
    - Default: null
    - Session-overridable: false
    - Annotations:
      
      RestResource.staticFiles()
    - Methods:
      
      RestContextBuilder.staticFiles(String),
      RestContextBuilder.staticFiles(Class,String)
      RestContextBuilder.staticFiles(String,String)
      RestContextBuilder.staticFiles(Class,String,String)
      RestContextBuilder.staticFiles(StaticFileMapping...)
    Description:
    
    Used to define paths and locations of statically-served files such as images or HTML documents from the classpath or file system.
    An example where this class is used is in the RestResource.staticFiles() annotation:
    package com.foo.mypackage; @RestResource( path="/myresource", staticFiles={ "htdocs:docs", "styles:styles" } ) public class MyResource extends BasicRestServlet {...}
    
    In the example above, given a GET request to the following URL...
    /myresource/htdocs/foobar.html
    
    ...the servlet will attempt to find the foobar.html file in the following ordered locations:
    1. com.foo.mypackage.docs package.
    2. [working-dir]/docs directory.
    See Also:
    - REST_classpathResourceFinder for configuring how classpath resources are located and retrieved.
    - REST_mimeTypes for configuring the media types based on file extension.
    - REST_staticFileResponseHeaders for configuring response headers on statically served files.
    - REST_useClasspathResourceCaching for configuring static file caching.
    - getClasspathResource(String,Locale) for retrieving static files.
    Notes:
    - Mappings are cumulative from super classes.
    - Child resources can override mappings made on parent class resources.
    See Also:
    
    Constant Field Values
  - REST_produces
```
public static final String REST_produces
```
    Configuration property: Supported accept media types.
    Property:
    - Name: "RestContext.produces.ls"
    - Data type: List<String>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.produces()
      RestMethod.produces()
    - Methods:
      
      RestContextBuilder.produces(boolean,String...)
      RestContextBuilder.produces(boolean,MediaType...)
    Description:
    
    Overrides the media types inferred from the serializers that identify what media types can be produced by the resource.
    An example where this might be useful if you have serializers registered that handle media types that you don't want exposed in the Swagger documentation.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(produces={"$C{REST/supportedProduces,application/json}"}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.produces(false, "application/json") // Same, but using property. builder.set(REST_produces, "application/json"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.produces(false, "application/json"); } }
    
    This affects the returned values from the following:
    - RestContext.getProduces()
    - RestRequest.getProduces()
    - RestInfoProvider.getSwagger(RestRequest) - Affects produces field.
    See Also:
    
    Constant Field Values
  - REST_consumes
```
public static final String REST_consumes
```
    Configuration property: Supported content media types.
    Property:
    - Name: "RestContext.consumes.ls"
    - Data type: List<String>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      RestResource.consumes()
      RestMethod.consumes()
    - Methods:
      
      RestContextBuilder.consumes(boolean,String...)
      RestContextBuilder.consumes(boolean,MediaType...)
    Description:
    
    Overrides the media types inferred from the parsers that identify what media types can be consumed by the resource.
    An example where this might be useful if you have parsers registered that handle media types that you don't want exposed in the Swagger documentation.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(consumes={"$C{REST/supportedConsumes,application/json}"}) public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.consumes(false, "application/json") // Same, but using property. builder.set(REST_consumes, "application/json"); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.consumes(false, "application/json"); } }
    
    This affects the returned values from the following:
    - RestContext.getConsumes()
    - RestRequest.getConsumes()
    - RestInfoProvider.getSwagger(RestRequest) - Affects consumes field.
    See Also:
    
    Constant Field Values
  - REST_useClasspathResourceCaching
```
public static final String REST_useClasspathResourceCaching
```
    Configuration property: Use classpath resource caching.
    Property:
    - Name: "RestContext.useClasspathResourceCaching.b"
    - Data type: Boolean
    - Default: true
    - Session-overridable: false
    - Annotations:
      
      RestResource.useClasspathResourceCaching()
    - Methods:
      
      RestContextBuilder.useClasspathResourceCaching(boolean)
    Description:
    
    When enabled, resources retrieved via getClasspathResource(String, Locale) (and related methods) will be cached in memory to speed subsequent lookups.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(useClasspathResourceCaching="$C{REST/useClasspathResourceCaching,false}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.useClasspathResourceCaching(false) // Same, but using property. builder.set(REST_useClasspathResourceCaching, false); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.useClasspathResourceCaching(false) } }
    
    See Also:
    - REST_staticFiles for information about static files.
    See Also:
    
    Constant Field Values
  - REST_useStackTraceHashes
```
public static final String REST_useStackTraceHashes
```
    Configuration property: Use stack trace hashes.
    Property:
    - Name: "RestContext.useStackTraceHashes.b"
    - Data type: Boolean
    - Default: true
    - Session-overridable: false
    - Annotations:
      
      RestResource.useStackTraceHashes()
    - Methods:
      
      RestContextBuilder.useStackTraceHashes(boolean)
    Description:
    
    When enabled, the number of times an exception has occurred will be tracked based on stack trace hashsums.
    Affects the following methods:
    - RestContext.getStackTraceOccurrance(Throwable)
    - RestCallHandler.handleError(HttpServletRequest, HttpServletResponse, RestException)
    - RestException.getOccurrence() - Returns the number of times this exception occurred.
    Example:
    
    // Option #1 - Defined via annotation resolving to a config file setting with default value. @RestResource(useStackTraceHashes="$C{REST/useStackTraceHashes,false}") public class MyResource { // Option #2 - Defined via builder passed in through resource constructor. public MyResource(RestContextBuilder builder) throws Exception { // Using method on builder. builder.useStackTraceHashes(false) // Same, but using property. builder.set(REST_useStackTraceHashes, false); } // Option #3 - Defined via builder passed in through init method. @RestHook(INIT) public void init(RestContextBuilder builder) throws Exception { builder.useStackTraceHashes(false) } }
    See Also:
    
    Constant Field Values
  - REST_widgets
```
public static final String REST_widgets
```
    Configuration property: HTML Widgets.
    Property:
    - Name: "RestContext.widgets.lo"
    - Data type: List<Widget | Class<? extends Widget>>
    - Default: empty list
    - Session-overridable: false
    - Annotations:
      
      HtmlDoc.widgets()
    - Methods:
      
      RestContextBuilder.widgets(Class...)
      RestContextBuilder.widgets(Widget...)
      RestContextBuilder.widgets(boolean,Widget...)
    Description:
    
    Defines widgets that can be used in conjunction with string variables of the form "$W{name}"to quickly generate arbitrary replacement text. Widgets resolve the following variables:
    - "$W{name}" - Contents returned by Widget.getHtml(RestRequest).
    - "$W{name.script}" - Contents returned by Widget.getScript(RestRequest).
      The script contents are automatically inserted into the <head/script> section in the HTML page.
    - "$W{name.style}" - Contents returned by Widget.getStyle(RestRequest).
      The styles contents are automatically inserted into the <head/style> section in the HTML page.
    The following examples shows how to associate a widget with a REST method and then have it rendered in the links and aside section of the page:
    @RestMethod( widgets={ MyWidget.class } htmldoc=@HtmlDoc( navlinks={ "$W{MyWidget}" }, aside={ "Check out this widget: $W{MyWidget}" } ) )
    
    Notes:
    - Widgets are inherited from super classes, but can be overridden by reusing the widget name.
    See Also:
    - Overview > juneau-rest-server > Widgets
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RestContext
```
public RestContext(RestContextBuilder builder)
            throws Exception
```
    Constructor.
    
    Parameters:
    
    builder - The servlet configuration object.
    
    Throws:
    
    Exception - If any initialization problems were encountered.
- Method Detail
  - getResourceResolver
```
protected RestResourceResolver getResourceResolver()
```
    Returns the resource resolver associated with this context.
    The resource resolver is used for instantiating child resource classes.
    See Also:
    - REST_resourceResolver
    Returns:
    
    The resource resolver associated with this context.
  - getVarResolver
```
public VarResolver getVarResolver()
```
    Returns the variable resolver for this servlet.
    Variable resolvers are used to replace variables in property values. They can be nested arbitrarily deep. They can also return values that themselves contain other variables.
    Example:
    
    @RestResource( messages="nls/Messages", properties={ @Property(name="title",value="$L{title}"), // Localized variable in Messages.properties @Property(name="javaVendor",value="$S{java.vendor,Oracle}"), // System property with default value @Property(name="foo",value="bar"), @Property(name="bar",value="baz"), @Property(name="v1",value="$R{foo}"), // Request variable. value="bar" @Property(name="v1",value="$R{foo,bar}"), // Request variable. value="bar" } ) public class MyRestResource extends BasicRestServlet {
    
    A typical usage pattern involves using variables inside the @HtmlDoc annotation:
    @RestMethod( name=GET, path="/{name}/*", htmldoc=@HtmlDoc( navlinks={ "up: $R{requestParentURI}", "options: servlet:/?method=OPTIONS", "editLevel: servlet:/editLevel?logger=$A{attribute.name, OFF}" } header={ "<h1>$L{MyLocalizedPageTitle}</h1>" }, aside={ "$F{resources/AsideText.html}" } ) ) public LoggerEntry getLogger(RestRequest req, @Path String name) throws Exception {
    
    See Also:
    - RestContextBuilder.vars(Class...) - For adding custom vars.
    - Overview > juneau-rest-server > SVL Variables
    - Overview > juneau-rest-server > Default REST SVL Variables
    Returns:
    
    The var resolver in use by this resource.
  - getConfig
```
public Config getConfig()
```
    Returns the config file associated with this servlet.
    The config file is identified via one of the following:
    - RestResource.config()
    - RestContextBuilder.config(Config)
    Returns:
    
    The resolving config file associated with this servlet.
    Never null.
  - resolveStaticFile
```
public StreamResource resolveStaticFile(String pathInfo)
                                 throws IOException
```
    Resolve a static resource file.
    The location of static resources are defined via:
    - RestContext.REST_staticFiles
    Parameters:
    
    pathInfo - The unencoded path info.
    
    Returns:
    
    The resource, or null if the resource could not be resolved.
    
    Throws:
    
    IOException
  - getClasspathResource
```
public InputStream getClasspathResource(String name,
                                        Locale locale)
                                 throws IOException
```
    Same as Class.getResourceAsStream(String) except if it doesn't find the resource on this class, searches up the parent hierarchy chain.
    If the resource cannot be found in the classpath, then an attempt is made to look in the JVM working directory.
    If the locale is specified, then we look for resources whose name matches that locale.
    For example, if looking for the resource "MyResource.txt" for the Japanese locale, we will look for files in the following order:
    1. "MyResource_ja_JP.txt"
    2. "MyResource_ja.txt"
    3. "MyResource.txt"
    Example:
    
    // A rest method that (unsafely!) returns the contents of a localized file // from the classpath. @RestMethod(path="/foo") public Object myMethod(RestRequest req, @Query("file") String file) { return getContext().getClasspathResource(file, req.getLocale()); }
    
    See Also:
    - REST_classpathResourceFinder
    Parameters:
    
    name - The resource name.
    
    locale - Optional locale.
    If null, won't look for localized file names.
    
    Returns:
    
    An input stream of the resource, or null if the resource could not be found.
    
    Throws:
    
    IOException
  - getClasspathResource
```
public InputStream getClasspathResource(Class<?> baseClass,
                                        String name,
                                        Locale locale)
                                 throws IOException
```
    Same as getClasspathResource(String, Locale), but allows you to override the class used for looking up the classpath resource.
    Example:
    
    // A rest method that (unsafely!) returns the contents of a localized file // from the classpath. @RestMethod(path="/foo") public Object myMethod(RestRequest req, @Query("file") String file) { return getContext().getClasspathResource(SomeOtherClass.class, file, req.getLocale()); }
    
    See Also:
    - REST_classpathResourceFinder
    Parameters:
    
    baseClass - Overrides the default class to use for retrieving the classpath resource.
    If null, uses the REST resource class.
    
    name - The resource name.
    
    locale - Optional locale.
    If null, won't look for localized file names.
    
    Returns:
    
    An input stream of the resource, or null if the resource could not be found.
    
    Throws:
    
    IOException
  - getClasspathResourceAsString
```
public String getClasspathResourceAsString(String name,
                                           Locale locale)
                                    throws IOException
```
    Reads the input stream from getClasspathResource(String, Locale) into a String.
    Example:
    
    // A rest method that (unsafely!) returns the contents of a localized file // from the classpath. @RestMethod(path="/foo") public String myMethod(RestRequest req, @Query("file") String file) { return getContext().getClasspathResourceAsString(file, req.getLocale()); }
    
    See Also:
    - REST_classpathResourceFinder
    Parameters:
    
    name - The resource name.
    
    locale - Optional locale.
    If null, won't look for localized file names.
    
    Returns:
    
    The contents of the stream as a string, or null if the resource could not be found.
    
    Throws:
    
    IOException - If resource could not be found.
  - getClasspathResourceAsString
```
public String getClasspathResourceAsString(Class<?> baseClass,
                                           String name,
                                           Locale locale)
                                    throws IOException
```
    Same as getClasspathResourceAsString(String, Locale), but allows you to override the class used for looking up the classpath resource.
    Example:
    
    // A rest method that (unsafely!) returns the contents of a localized file // from the classpath. @RestMethod(path="/foo") public String myMethod(RestRequest req, @Query("file") String file) { return getContext().getClasspathResourceAsString(SomeOtherClass.class, file, req.getLocale()); }
    
    See Also:
    - REST_classpathResourceFinder
    Parameters:
    
    baseClass - Overrides the default class to use for retrieving the classpath resource.
    If null, uses the REST resource class.
    
    name - The resource name.
    
    locale - Optional locale.
    If null, won't look for localized file names.
    
    Returns:
    
    The contents of the stream as a string, or null if the resource could not be found.
    
    Throws:
    
    IOException - If resource could not be found.
  - getClasspathResource
```
public <T> T getClasspathResource(Class<T> c,
                                  MediaType mediaType,
                                  String name,
                                  Locale locale)
                           throws IOException,
                                  javax.servlet.ServletException
```
    Reads the input stream from getClasspathResource(String, Locale) and parses it into a POJO using the parser matched by the specified media type.
    Useful if you want to load predefined POJOs from JSON files in your classpath.
    Example:
    
    // A rest method that (unsafely!) returns the contents of a localized file // from the classpath parsed as an array of beans. @RestMethod(path="/foo") public MyBean[] myMethod(RestRequest req, @Query("file") String file) { return getContext().getClasspathResource(MyBean[].class, JSON, file, req.getLocale()); }
    
    See Also:
    - REST_classpathResourceFinder
    Parameters:
    
    c - The class type of the POJO to create.
    
    mediaType - The media type of the data in the stream (e.g. "text/json")
    
    name - The resource name (e.g. "htdocs/styles.css").
    
    locale - Optional locale.
    If null, won't look for localized file names.
    
    Returns:
    
    The parsed resource, or null if the resource could not be found.
    
    Throws:
    
    IOException
    
    javax.servlet.ServletException - If the media type was unknown or the input could not be parsed into a POJO.
  - getClasspathResource
```
public <T> T getClasspathResource(Class<?> baseClass,
                                  Class<T> c,
                                  MediaType mediaType,
                                  String name,
                                  Locale locale)
                           throws IOException,
                                  javax.servlet.ServletException
```
    Same as getClasspathResource(Class, MediaType, String, Locale), except overrides the class used for retrieving the classpath resource.
    See Also:
    - REST_classpathResourceFinder
    Example:
    
    // A rest method that (unsafely!) returns the contents of a localized file // from the classpath parsed as an array of beans. @RestMethod(path="/foo") public MyBean[] myMethod(RestRequest req, @Query("file") String file) { return getContext().getClasspathResource(SomeOtherClass.class, MyBean[].class, JSON, file, req.getLocale()); }
    Parameters:
    
    baseClass - Overrides the default class to use for retrieving the classpath resource.
    If null, uses the REST resource class.
    
    c - The class type of the POJO to create.
    
    mediaType - The media type of the data in the stream (e.g. "text/json")
    
    name - The resource name (e.g. "htdocs/styles.css").
    
    locale - Optional locale.
    If null, won't look for localized file names.
    
    Returns:
    
    The parsed resource, or null if the resource could not be found.
    
    Throws:
    
    IOException
    
    javax.servlet.ServletException - If the media type was unknown or the input could not be parsed into a POJO.
  - getPath
```
public String getPath()
```
    Returns the path for this resource as defined by the @RestResource.path() annotation or RestContextBuilder.path(String) method concatenated with those on all parent classes.
    If path is not specified, returns "/".
    Path always starts with "/".
    See Also:
    - REST_path
    Returns:
    
    The servlet path.
  - getWidgets
```
public Map<String,Widget> getWidgets()
```
    The widgets used for resolving
    "$W{...}" variables.
    See Also:
    
    REST_widgets
    Returns:
    
    The var resolver widgets as a map with keys being the name returned by Widget.getName().
  - getLogger
```
public RestLogger getLogger()
```
    Returns the logger to use for this resource.
    See Also:
    - REST_logger
    Returns:
    
    The logger to use for this resource.
    Never null.
  - getMessages
```
public MessageBundle getMessages()
```
    Returns the resource bundle used by this resource.
    See Also:
    - REST_messages
    Returns:
    
    The resource bundle for this resource.
    Never null.
  - getInfoProvider
```
public RestInfoProvider getInfoProvider()
```
    Returns the REST information provider used by this resource.
    See Also:
    - REST_infoProvider
    Returns:
    
    The information provider for this resource.
    Never null.
  - getCallHandler
```
protected RestCallHandler getCallHandler()
```
    Returns the REST call handler used by this resource.
    See Also:
    - REST_callHandler
    Returns:
    
    The call handler for this resource.
    Never null.
  - getCallRouters
```
protected Map<String,RestCallRouter> getCallRouters()
```
    Returns a map of HTTP method names to call routers.
    
    Returns:
    
    A map with HTTP method names upper-cased as the keys, and call routers as the values.
  - getResource
```
public Object getResource()
```
    Returns the resource object.
    This is the instance of the class annotated with the @RestResource annotation, usually an instance of RestServlet.
    
    Returns:
    
    The resource object.
    Never null.
  - getRestServlet
```
public RestServlet getRestServlet()
```
    Returns the resource object as a RestServlet.
    
    Returns:
    
    The resource object cast to RestServlet, or null if the resource doesn't subclass from RestServlet.
  - checkForInitException
```
protected void checkForInitException()
                              throws RestException
```
    Throws a RestException if an exception occurred in the constructor of this object.
    
    Throws:
    
    RestException - The initialization exception wrapped in a RestException.
  - getParentContext
```
public RestContext getParentContext()
```
    Returns the parent resource context (if this resource was initialized from a parent).
    From this object, you can get access to the parent resource class itself using getResource() or getRestServlet()
    
    Returns:
    
    The parent resource context, or null if there is no parent context.
  - getBeanContext
```
public BeanContext getBeanContext()
```
    Returns the BeanContext object used for parsing path variables and header values.
    
    Returns:
    
    The bean context used for parsing path variables and header values.
  - getProperties
```
public RestContextProperties getProperties()
```
    Returns the class-level properties associated with this servlet.
    Properties at the class level are defined via the following:
    Notes:
    - The returned Map is mutable.
      Therefore, subclasses are free to override or set additional initialization parameters in their init() method.
    Returns:
    
    The resource properties as a RestContextProperties.
  - getSerializers
```
public SerializerGroup getSerializers()
```
    Returns the serializers registered with this resource.
    See Also:
    - REST_serializers
    Returns:
    
    The serializers registered with this resource.
  - getParsers
```
public ParserGroup getParsers()
```
    Returns the parsers registered with this resource.
    Parsers at the class level are defined via the following:
    - REST_parsers
    Returns:
    
    The parsers registered with this resource.
  - getServletInitParameter
```
public String getServletInitParameter(String name)
```
    Returns the servlet init parameter returned by ServletConfig.getInitParameter(String).
    
    Parameters:
    
    name - The init parameter name.
    
    Returns:
    
    The servlet init parameter, or null if not found.
  - getChildResources
```
public Map<String,RestContext> getChildResources()
```
    Returns the child resources associated with this servlet.
    
    Returns:
    
    An unmodifiable map of child resources. Keys are the @RestResource.path() annotation defined on the child resource.
  - getStackTraceOccurrence
```
public int getStackTraceOccurrence(Throwable e)
```
    Returns the number of times this exception was thrown based on a hash of its stacktrace.
    See Also:
    - REST_useStackTraceHashes
    Parameters:
    
    e - The exception to check.
    
    Returns:
    
    The number of times this exception was thrown, or 0 if REST_useStackTraceHashes setting is not enabled.
  - isRenderResponseStackTraces
```
public boolean isRenderResponseStackTraces()
```
    Returns whether it's safe to render stack traces in HTTP responses.
    See Also:
    - REST_useStackTraceHashes
    Returns:
    
    true if setting is enabled.
  - isAllowHeaderParams
```
public boolean isAllowHeaderParams()
```
    Returns whether it's safe to pass header values in as GET parameters.
    See Also:
    - REST_allowHeaderParams
    Returns:
    
    true if setting is enabled.
  - isAllowBodyParam
```
public boolean isAllowBodyParam()
```
    Returns whether it's safe to pass the HTTP body as a "body" GET parameter.
    See Also:
    - REST_allowBodyParam
    Returns:
    
    true if setting is enabled.
  - getDefaultCharset
```
public String getDefaultCharset()
```
    Returns the default charset to use on requests and responses when not specified on the request.
    See Also:
    - REST_defaultCharset
    Returns:
    
    The default charset.
    Never null.
  - getMaxInput
```
public long getMaxInput()
```
    Returns the maximum request input size in bytes.
    See Also:
    - REST_maxInput
    Returns:
    
    The maximum request input size in bytes.
  - getClientVersionHeader
```
public String getClientVersionHeader()
```
    Returns the name of the client version header name used by this resource.
    See Also:
    - REST_clientVersionHeader
    Returns:
    
    The name of the client version header used by this resource.
    Never null.
  - allowMethodParam
```
public boolean allowMethodParam(String m)
```
    Returns true if the specified Method GET parameter value can be used to override the method name in the HTTP header.
    See Also:
    - REST_allowedMethodParams
    Parameters:
    
    m - The method name, upper-cased.
    
    Returns:
    
    true if this resource allows the specified method to be overridden.
  - getPartParser
```
public HttpPartParser getPartParser()
```
    Returns the HTTP-part parser associated with this resource.
    See Also:
    - REST_partParser
    Returns:
    
    The HTTP-part parser associated with this resource.
    Never null.
  - getPartSerializer
```
public HttpPartSerializer getPartSerializer()
```
    Returns the HTTP-part serializer associated with this resource.
    See Also:
    - REST_partSerializer
    Returns:
    
    The HTTP-part serializer associated with this resource.
    Never null.
  - getEncoders
```
public EncoderGroup getEncoders()
```
    Returns the encoders associated with this resource.
    See Also:
    - REST_encoders
    Returns:
    
    The encoders associated with this resource.
    Never null.
  - getProduces
```
public List<MediaType> getProduces()
```
    Returns the explicit list of supported accept types for this resource.
    See Also:
    - REST_serializers
    - REST_produces
    Returns:
    
    The supported Accept header values for this resource.
    Never null.
  - getConsumes
```
public List<MediaType> getConsumes()
```
    Returns the explicit list of supported content types for this resource.
    See Also:
    - REST_parsers
    - REST_consumes
    Returns:
    
    The supported Content-Type header values for this resource.
    Never null.
  - getDefaultRequestHeaders
```
public Map<String,Object> getDefaultRequestHeaders()
```
    Returns the default request headers for this resource.
    See Also:
    - REST_defaultRequestHeaders
    Returns:
    
    The default request headers for this resource.
    Never null.
  - getDefaultResponseHeaders
```
public Map<String,Object> getDefaultResponseHeaders()
```
    Returns the default response headers for this resource.
    See Also:
    - REST_defaultResponseHeaders
    Returns:
    
    The default response headers for this resource.
    Never null.
  - getConverters
```
public RestConverter[] getConverters()
```
    Returns the converters associated with this resource at the class level.
    See Also:
    - REST_converters
    Returns:
    
    The converters associated with this resource.
    Never null.
  - getGuards
```
public RestGuard[] getGuards()
```
    Returns the guards associated with this resource at the class level.
    See Also:
    - REST_guards
    Returns:
    
    The guards associated with this resource.
    Never null.
  - getResponseHandlers
```
protected ResponseHandler[] getResponseHandlers()
```
    Returns the response handlers associated with this resource.
    See Also:
    - REST_responseHandlers
    Returns:
    
    The response handlers associated with this resource.
    Never null.
  - hasChildResources
```
public boolean hasChildResources()
```
    Returns true if this resource has any child resources associated with it.
    See Also:
    - REST_children
    Returns:
    
    true if this resource has any child resources associated with it.
  - getChildResource
```
public RestContext getChildResource(String path)
```
    Returns the context of the child resource associated with the specified path.
    See Also:
    - REST_children
    Parameters:
    
    path - The path of the child resource to resolve.
    
    Returns:
    
    The resolved context, or null if it could not be resolved.
  - getContextPath
```
public String getContextPath()
```
    Returns the context path of the resource.
    See Also:
    - REST_contextPath
    Returns:
    
    The context path of this resource.
    If not specified, returns the context path of the ascendant resource.
  - getRestParams
```
public RestParam[] getRestParams(Method method)
```
    Returns the parameters defined on the specified Java method.
    
    Parameters:
    
    method - The Java method to check.
    
    Returns:
    
    The parameters defined on the Java method.
  - getMediaTypeForName
```
public String getMediaTypeForName(String name)
```
    Returns the media type for the specified file name.
    See Also:
    - REST_mimeTypes
    Parameters:
    
    name - The file name.
    
    Returns:
    
    The MIME-type, or null if it could not be determined.
  - isStaticFile
```
public boolean isStaticFile(String p)
```
    Returns true if the specified path refers to a static file.
    Static files are files pulled from the classpath and served up directly to the browser.
    See Also:
    - REST_staticFiles
    Parameters:
    
    p - The URL path remainder after the servlet match.
    
    Returns:
    
    true if the specified path refers to a static file.
  - getCallMethods
```
public Map<String,RestJavaMethod> getCallMethods()
```
    Returns the REST Java methods defined in this resource.
    These are the methods annotated with the @RestMethod annotation.
    
    Returns:
    
    An unmodifiable map of Java method names to call method objects.
  - findParams
```
protected RestParam[] findParams(Method method,
                                 UrlPathPattern pathPattern,
                                 boolean isPreOrPost)
                          throws javax.servlet.ServletException
```
    Finds the RestParam instances to handle resolving objects on the calls to the specified Java method.
    
    Parameters:
    
    method - The Java method being called.
    
    pathPattern - The parsed URL path pattern.
    
    isPreOrPost - Whether this is a HookEvent.PRE_CALL or HookEvent.POST_CALL.
    
    Returns:
    
    The array of resolvers.
    
    Throws:
    
    javax.servlet.ServletException - If an annotation usage error was detected.
  - destroy
```
protected void destroy()
```
    Calls Servlet.destroy() on any child resources defined on this resource.
  - createSession
```
public BeanSession createSession(BeanSessionArgs args)
```
    Unused.
    
    Overrides:
    
    createSession in class BeanContext
    
    Parameters:
    
    args - The session arguments.
    
    Returns:
    
    A new session object.
  - createDefaultSessionArgs
```
public BeanSessionArgs createDefaultSessionArgs()
```
    Unused.
    
    Overrides:
    
    createDefaultSessionArgs in class BeanContext
    
    Returns:
    
    A SessionArgs object, possibly a read-only reusable instance.

Class RestContext

See Also:

Field Summary

Fields inherited from class org.apache.juneau.BeanContext

Constructor Summary

Method Summary

Methods inherited from class org.apache.juneau.BeanContext

Methods inherited from class org.apache.juneau.Context

Methods inherited from class java.lang.Object

Field Detail

REST_allowBodyParam

Property:

Description:

Example:

Notes:

REST_allowedMethodParams

Property:

Description:

Example:

Notes:

REST_allowHeaderParams

Property:

Description:

Example:

Notes:

REST_callHandler

Property:

Description:

Example:

Notes:

REST_children

Property:

Description:

Example:

Notes:

See Also:

REST_classpathResourceFinder

Property:

Description:

Example:

Notes:

REST_clientVersionHeader

Property:

Description:

Example:

REST_contextPath

Property:

Description:

Example:

REST_converters

Property:

Description:

Example:

See Also:

See Also:

Notes:

REST_defaultCharset

Property:

Description:

Example:

REST_defaultRequestHeaders

Property:

Description:

Notes:

Example:

REST_defaultResponseHeaders

Property:

Description:

Notes:

Example:

REST_encoders

Property:

Description:

Example:

Notes:

See Also:

REST_guards

Property:

Description:

Example: