[JAVA] Une note de révision de l'interface Spring Framework Resource

Aperçu

Ceci est un mémo lorsque j'ai examiné comment accéder aux fichiers de ressources à l'aide de l'interface Resource et de la classe d'implémentation de Spring Framework.

environnement

• Windows 10 Professional 1909
• OpenJDK 13
• Spring Boot 2.2.1

référence

• Core Technologies - 2. Resources
• Package org.springframework.core.io

Resource

Since 28.12.2003

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

Comment obtenir une instance de l'interface Resource

1. Utilisez la classe d'implémentation
2. Utilisez ResourceLoader
3. Utilisez l'annotation «@ Value»

Etc.

Comment utiliser les classes d'implémentation

Comment utiliser la classe d'implémentation de l'interface Resource appropriée en fonction de l'emplacement du fichier de ressources. Par exemple, il existe ClassPathResource pour accéder aux ressources dans le chemin de classe, ʻUrlResource pour accéder aux ressources sur le réseau et FileUrlResource` pour accéder aux ressources sur le système de fichiers.

ClassPathResource

Since 28.12.2003

Resource implementation for class path resources. Uses either a given ClassLoader or a given Class for loading resources.

code

Resource resource = new ClassPathResource("config/app.properties");

Puisque l'interface Resource hérite de l'interface ʻInputStreamSource, vous pouvez obtenir le ʻInputStream du fichier de ressources avec la méthode getInputStream.

String read(Resource resource) {
    try (InputStream in = resource.getInputStream();
         BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
        StringBuilder sb = new StringBuilder();
        String line = null;
        while ((line = reader.readLine()) != null) {
            sb.append(line);
        }
        return sb.toString();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

Étant donné que l'interface Resource possède également une méthode getFile, elle peut être décrite comme suit, mais comme une exception est levée lorsque la ressource se trouve dans le chemin de classe ou sur le réseau, le fichier de ressources se trouve généralement sur le système de fichiers. Je pense que vous ne devriez l'utiliser que dans certains cas.

String read(Resource resource) {
    try {
        return Files.readString(resource.getFile().toPath());
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

UrlResource

Since 28.12.2003

Resource implementation for java.net.URL locators. Supports resolution as a URL and also as a File in case of the "file:" protocol.

code

Resource urlResource = new UrlResource("http://localhost:8887/config/app.properties");

FileUrlResource

Since 5.0.2

Subclass of UrlResource which assumes file resolution, to the degree of implementing the WritableResource interface for it. This resource variant also caches resolved File handles from getFile().

code

Resource fileUrlResource = new FileUrlResource("c://var//config/app.properties");

Comment utiliser ResourceLoader

Since 10.03.2004

Strategy interface for loading resources (e.. class path or file system resources). An ApplicationContext is required to provide this functionality, plus extended ResourcePatternResolver support. DefaultResourceLoader is a standalone implementation that is usable outside an ApplicationContext, also used by ResourceEditor.

ResourceLoader Instance de ressource utilisant la classe d'implémentation de l'interface Si vous obtenez, il y a un avantage que vous n'avez pas à connaître la classe d'implémentation de l'interface Resource.

Dans Spring Boot, ResourceLoader est injecté avec une instance de la classe ʻAnnotationConfigServletWebServerApplicationContext`. (Cette classe est dans le projet Spring Boot)

@Autowired
private ResourceLoader resourceLoader;
// org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext

classpath

L'écriture commençant par classpath: injectera une instance de la classe ClassPathResource.

Resource resource = resourceLoader.getResource("classpath:config/app.properties");
// org.springframework.core.io.ClassPathResource

url

Si elle est écrite dans le schéma http, une instance de la classe ʻUrlResource` sera injectée.

Resource resource = resourceLoader.getResource("http://localhost:8887/config/app.properties");
// org.springframework.core.io.UrlResource

file

Le schéma de fichier injectera une instance de la classe FileUrlResource.

Resource resource = resourceLoader.getResource("file:///c://config/app.properties");
// org.springframework.core.io.FileUrlResource

Comment utiliser l'annotation «@ Value»

En fonction de la valeur de l'annotation Value, Spring Framework injectera une instance de la classe d'implémentation appropriée. Le format de la valeur décrite dans l'annotation est le même que ResourceLoader.

classpath

@Value("classpath:config/app.properties")
private Resource classpathResource;
// org.springframework.core.io.ClassPathResource

url

@Value("http://localhost:8887/config/app.properties")
private Resource urlResource;
// org.springframework.core.io.UrlResource

file

@Value("file:///c://config/app.properties")
private Resource fileUrlResource;
// org.springframework.core.io.FileUrlResource

Comment utiliser ResourceUtils

Since 1.1.5

Utility methods for resolving resource locations to files in the file system. Mainly for internal use within the framework.

Comme décrit dans la documentation de l'API, il s'agit d'une classe utilitaire principalement destinée à être utilisée dans Spring Framework. Il n'y a aucune déclaration indiquant qu'il ne doit pas être utilisé du côté de l'application, mais il doit être utilisé avec prudence car il est destiné à être utilisé dans le cadre.

classpath

File file = ResourceUtils.getFile("classpath:config/app.properties");

url

URL url = ResourceUtils.getURL("http://localhost:8887/config/app.properties");

file

File file = ResourceUtils.getFile("file:///c://var//config/app.properties");

StreamUtils

Since 3.2.2

Simple utility methods for dealing with streams. The copy methods of this class are similar to those defined in FileCopyUtils except that all affected streams are left open when done. All copy methods use a block size of 4096 bytes. Mainly for use within the framework, but also useful for application code.

Spring Framework a également des classes utilitaires qui gèrent les flux. Vous pouvez utiliser la méthode copyToString de cette classe pour simplifier votre code comme suit:

String data = StreamUtils.copyToString(resource.getInputStream(), StandardCharsets.UTF_8);