Laden Sie eine Ressource im Frühjahr als Zeichenfolge

1. Übersicht

In diesem Tutorial werden verschiedene Möglichkeiten untersucht, wie Sie den Inhalt einer Ressource, die Text als Zeichenfolge enthält, in unsere Spring Beans einfügen können .

Wir werden die Ressource lokalisieren und ihren Inhalt lesen.

Außerdem zeigen wir, wie die geladenen Ressourcen auf mehrere Beans verteilt werden. Wir werden dies durch die Verwendung von Anmerkungen zeigen, die sich auf die Abhängigkeitsinjektion beziehen. Dasselbe kann jedoch auch erreicht werden, indem die XML-basierte Injektion verwendet und die Beans in der XML-Eigenschaftendatei deklariert werden.

2. Ressource verwenden

Wir können das Auffinden einer Ressourcendatei mithilfe der Ressourcenschnittstelle vereinfachen . Spring hilft uns beim Suchen und Lesen einer Ressource mithilfe des Ressourcenladers, der abhängig vom angegebenen Pfad entscheidet, welche Ressourcenimplementierung ausgewählt werden soll. Die Ressource ist effektiv eine Möglichkeit, auf den Inhalt der Ressource und nicht auf den Inhalt selbst zuzugreifen.

Sehen wir uns einige Möglichkeiten an, wie Sie eine Ressourceninstanz für Ressourcen im Klassenpfad abrufen können.

2.1. Mit Resource

Wir können die Klasse ResourceLoader verwenden, wenn wir das verzögerte Laden bevorzugen:

ResourceLoader resourceLoader = new DefaultResourceLoader(); Resource resource = resourceLoader.getResource("classpath:resource.txt");

Wir können den ResourceLoader auch mit @Autowired in unsere Bean injizieren :

@Autowired private ResourceLoader resourceLoader;

2.2 Verwenden von @Resource

Mit @Value können wir eine Ressource direkt in eine Spring Bean injizieren :

@Value("classpath:resource.txt") private Resource resource;

3. Konvertieren von Ressource zu Zeichenfolge

Sobald wir Zugriff auf die Ressource haben, müssen wir sie in einen String einlesen können . Erstellen wir eine ResourceReader- Dienstprogrammklasse mit einer statischen Methode asString , um dies für uns zu tun.

Zuerst müssen wir einen InputStream erwerben :

InputStream inputStream = resource.getInputStream();

Unser nächster Schritt besteht darin, diesen InputStream in einen String zu konvertieren . Wir können die Spring-eigene FileCopyUtils # copyToString- Methode verwenden:

public class ResourceReader { public static String asString(Resource resource) { try (Reader reader = new InputStreamReader(resource.getInputStream(), UTF_8)) { return FileCopyUtils.copyToString(reader); } catch (IOException e) { throw new UncheckedIOException(e); } } // more utility methods }

Es gibt viele andere Möglichkeiten, dies zu erreichen, beispielsweise die Verwendung von copyToString der StreamUtils- Klasse von Spring

Erstellen Sie auch eine andere Dienstprogrammmethode readFileToString, die die Ressource für einen Pfad abruft , und rufen Sie die asString- Methode auf, um sie in einen String zu konvertieren .

public static String readFileToString(String path) { ResourceLoader resourceLoader = new DefaultResourceLoader(); Resource resource = resourceLoader.getResource(path); return asString(resource); }

4. Hinzufügen einer Konfiguration Klasse

Wenn jede Bohne einzuspritzen Ressource hatte String einzeln s, gibt es eine Chance sowohl Code - Duplizierung und Nutzung von Speichern durch Bohnen ihre eigene individuelle Kopie des mit String .

Wir können eine sauberere Lösung erzielen, indem wir den Inhalt der Ressource beim Laden des Anwendungskontexts in eine oder mehrere Spring Beans einfügen. Auf diese Weise können wir die Implementierungsdetails zum Lesen der Ressource vor den verschiedenen Beans verbergen, die diesen Inhalt verwenden müssen.

@Configuration public class LoadResourceConfig { // Bean Declarations }

4.1. Verwenden einer Bean, die die Ressourcenzeichenfolge enthält

Deklarieren wir Beans, um den Ressourceninhalt in einer @ Configuration- Klasse zu speichern :

@Bean public String resourceString() { return ResourceReader.readFileToString("resource.txt"); }

Fügen Sie nun die registrierten Beans in die Felder ein, indem Sie eine @ Autowired- Annotation hinzufügen :

public class LoadResourceAsStringIntegrationTest { private static final String EXPECTED_RESOURCE_VALUE = "..."; // The string value of the file content @Autowired @Qualifier("resourceString") private String resourceString; @Test public void givenUsingResourceStringBean_whenConvertingAResourceToAString_thenCorrect() { assertEquals(EXPECTED_RESOURCE_VALUE, resourceString); } }

In diesem Fall verwenden wir die Annotation @Qualifier und den Namen der Bean, da möglicherweise mehrere Felder desselben Typs eingefügt werden müssen - String .

Wir sollten beachten, dass der im Qualifizierer verwendete Bean-Name vom Namen der Methode abgeleitet ist, die die Bean in der Konfigurationsklasse erstellt.

5. Verwenden von SpEL

Lassen Sie uns abschließend sehen, wie wir die Spring Expression Language verwenden können, um den Code zu beschreiben, der zum Laden einer Ressourcendatei direkt in ein Feld in unserer Klasse erforderlich ist.

Verwenden Sie die Annotation @Value , um den Dateiinhalt in das Feld resourceStringUsingSpel einzufügen :

public class LoadResourceAsStringIntegrationTest { private static final String EXPECTED_RESOURCE_VALUE = "..."; // The string value of the file content @Value( "#{T(com.baeldung.loadresourceasstring.ResourceReader).readFileToString('classpath:resource.txt')}" ) private String resourceStringUsingSpel; @Test public void givenUsingSpel_whenConvertingAResourceToAString_thenCorrect() { assertEquals(EXPECTED_RESOURCE_VALUE, resourceStringUsingSpel); } }

Hier haben wir ResourceReader # readFileToString aufgerufen , der den Speicherort der Datei mithilfe eines "Klassenpfads" beschreibt - vorangestellter Pfad in unserer @ Value- Annotation.

Um die Codemenge im SpEL zu reduzieren, haben wir in der Klasse ResourceReader eine Hilfsmethode erstellt, die Apache Commons FileUtils verwendet , um über den angegebenen Pfad auf die Datei zuzugreifen:

public class ResourceReader { public static String readFileToString(String path) throws IOException { return FileUtils.readFileToString(ResourceUtils.getFile(path), StandardCharsets.UTF_8); } }

6. Fazit

In diesem Tutorial haben wir einige Möglichkeiten zum Konvertieren einer Ressource in einen String beschrieben .

Zunächst haben wir gesehen, wie eine Ressource für den Zugriff auf die Datei erstellt und von Ressource zu Zeichenfolge gelesen wird .

Als Nächstes haben wir auch gezeigt, wie Sie die Implementierung zum Laden von Ressourcen ausblenden und den Inhalt von Zeichenfolgen für mehrere Beans freigeben können , indem Sie qualifizierte Beans in einer @Configuration erstellen und die Zeichenfolgen automatisch verdrahten.

Schließlich haben wir SpEL verwendet, das eine kompakte und sofortige Lösung bietet, obwohl eine benutzerdefinierte Hilfsfunktion erforderlich ist, um zu verhindern, dass es zu komplex wird.

Wie immer finden Sie den Code für die Beispiele auf GitHub