org.springframework.core.io

## Interface Resource

- All Superinterfaces:
    InputStreamSource
  All Known Subinterfaces:
    ContextResource, HttpResource, HttpResource, WritableResource
  All Known Implementing Classes:
    AbstractFileResolvingResource, AbstractResource, ByteArrayResource, ClassPathResource, DefaultResourceLoader.ClassPathContextResource, DescriptiveResource, FileSystemResource, FileUrlResource, InputStreamResource, PathResource, ServletContextResource, TransformedResource, TransformedResource, UrlResource, VfsResource

      public interface Resource
      extends InputStreamSource

  Interface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource.

  An InputStream can be opened for every resource if it exists in physical form, but a URL or File handle can just be returned for certain resources. The actual behavior is implementation-specific.

  Since:
    28.12.2003
  Author:
    Juergen Hoeller
  See Also:
    `InputStreamSource.getInputStream()`, `getURL()`, `getURI()`, `getFile()`, `WritableResource`, `ContextResource`, `UrlResource`, `FileUrlResource`, `FileSystemResource`, `ClassPathResource`, `ByteArrayResource`, `InputStreamResource`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `long` | `contentLength()` Determine the content length for this resource.
    `Resource` | `createRelative(String relativePath)` Create a resource relative to this resource.
    `boolean` | `exists()` Determine whether this resource actually exists in physical form.
    `String` | `getDescription()` Return a description for this resource, to be used for error output when working with the resource.
    `File` | `getFile()` Return a File handle for this resource.
    `String` | `getFilename()` Determine a filename for this resource, i.e.
    `URI` | `getURI()` Return a URI handle for this resource.
    `URL` | `getURL()` Return a URL handle for this resource.
    `default boolean` | `isFile()` Determine whether this resource represents a file in a file system.
    `default boolean` | `isOpen()` Indicate whether this resource represents a handle with an open stream.
    `default boolean` | `isReadable()` Indicate whether non-empty contents of this resource can be read via `InputStreamSource.getInputStream()`.
    `long` | `lastModified()` Determine the last-modified timestamp for this resource.
    `default ReadableByteChannel` | `readableChannel()` Return a `ReadableByteChannel`.

    - ### Methods inherited from interface org.springframework.core.io.InputStreamSource

      `getInputStream`

- - ### Method Detail

    - #### exists

          boolean exists()

      Determine whether this resource actually exists in physical form.

      This method performs a definitive existence check, whereas the existence of a `Resource` handle only guarantees a valid descriptor handle.

    - #### isReadable

          default boolean isReadable()

      Indicate whether non-empty contents of this resource can be read via `InputStreamSource.getInputStream()`.

      Will be `true` for typical resource descriptors that exist since it strictly implies `exists()` semantics as of 5.1. Note that actual content reading may still fail when attempted. However, a value of `false` is a definitive indication that the resource content cannot be read.

      See Also:
        `InputStreamSource.getInputStream()`, `exists()`

    - #### isOpen

          default boolean isOpen()

      Indicate whether this resource represents a handle with an open stream. If `true`, the InputStream cannot be read multiple times, and must be read and closed to avoid resource leaks.

      Will be `false` for typical resource descriptors.

    - #### isFile

          default boolean isFile()

      Determine whether this resource represents a file in a file system.

      A value of `true` strongly suggests (but does not guarantee) that a `getFile()` call will succeed.

      This is conservatively `false` by default.

      Since:
        5.0
      See Also:
        `getFile()`

    - #### getURL

          URL getURL()
              throws IOException

      Return a URL handle for this resource.
      Throws:
        `IOException` - if the resource cannot be resolved as URL, i.e. if the resource is not available as a descriptor

    - #### getURI

          URI getURI()
              throws IOException

      Return a URI handle for this resource.
      Throws:
        `IOException` - if the resource cannot be resolved as URI, i.e. if the resource is not available as a descriptor
      Since:
        2.5

    - #### getFile

          File getFile()
                throws IOException

      Return a File handle for this resource.
      Throws:
        `FileNotFoundException` - if the resource cannot be resolved as absolute file path, i.e. if the resource is not available in a file system
        `IOException` - in case of general resolution/reading failures
      See Also:
        `InputStreamSource.getInputStream()`

    - #### readableChannel

          default ReadableByteChannel readableChannel()
                                               throws IOException

      Return a `ReadableByteChannel`.

      It is expected that each call creates a fresh channel.

      The default implementation returns `Channels.newChannel(InputStream)` with the result of `InputStreamSource.getInputStream()`.

      Returns:
        the byte channel for the underlying resource (must not be `null`)
      Throws:
        `FileNotFoundException` - if the underlying resource doesn't exist
        `IOException` - if the content channel could not be opened
      Since:
        5.0
      See Also:
        `InputStreamSource.getInputStream()`

    - #### contentLength

          long contentLength()
                      throws IOException

      Determine the content length for this resource.
      Throws:
        `IOException` - if the resource cannot be resolved (in the file system or as some other known physical resource type)

    - #### lastModified

          long lastModified()
                     throws IOException

      Determine the last-modified timestamp for this resource.
      Throws:
        `IOException` - if the resource cannot be resolved (in the file system or as some other known physical resource type)

    - #### createRelative

          Resource createRelative(String relativePath)
                           throws IOException

      Create a resource relative to this resource.
      Parameters:
        `relativePath` - the relative path (relative to this resource)
      Returns:
        the resource handle for the relative resource
      Throws:
        `IOException` - if the relative resource cannot be determined

    - #### getFilename

          @Nullable
          String getFilename()

      Determine a filename for this resource, i.e. typically the last part of the path: for example, "myfile.txt".

      Returns `null` if this type of resource does not have a filename.

    - #### getDescription

          String getDescription()

      Return a description for this resource, to be used for error output when working with the resource.

      Implementations are also encouraged to return this value from their `toString` method.

      See Also:
        `Object.toString()`