streamalism.org

1. Introduktion

I denne vejledning ser vi forskellige måder at få adgang til og indlæse indholdet af en fil, der er på klassestien ved hjælp af Spring.

2. Brug Ressource

Det Ressource interface hjælper med at abstrahere adgang til ressourcer på lavt niveau. Faktisk understøtter det håndtering af alle slags filressourcer på en ensartet måde.

Lad os starte med at se på forskellige metoder til at opnå en Ressource eksempel.

2.1. Manuelt

For at få adgang til en ressource fra klassestien kan vi simpelthen bruge ClassPathResource:

public Resource loadEmployeesWithClassPathResource () {return new ClassPathResource ("data / workers.dat"); }

Som standard, ClassPathResource fjerner nogle kedelplader til valg mellem trådens kontekstklasselæsser og standardsystemklasselæsseren.

Vi kan dog også angive klasselæsseren, der skal bruges enten direkte:

returner nye ClassPathResource ("data / ansatte.dat", this.getClass (). getClassLoader ());

Eller indirekte gennem en bestemt klasse:

returnere nye ClassPathResource ("data / ansatte.dat", Employee.class.getClassLoader ());

Bemærk, at fra Ressource, kan vi let springe til Java-standardrepræsentationer som f.eks InputStream eller Fil.

En anden ting at bemærke her er, at ovenstående metode kun fungerer for absolutte stier. Hvis du vil specificere en relativ sti, kan du passere et sekund klasse argument. Stien vil være relativt til denne klasse:

ny ClassPathResource ("../../../ data / ansatte.dat", eksempel.klasse) .getFile ();

Filstien ovenfor er i forhold til Eksempel klasse.

2.2. Ved brug af @Værdi

Vi kan også indsprøjte en Ressource med @Værdi:

@Value ("classpath: data / resource-data.txt") Resource resourceFile;

Og @Værdi understøtter også andre præfikser, ligesom fil: og url:.

2.3. Brug af ResourceLoader

Eller hvis vi vil indlade vores ressource i doven, kan vi bruge den ResourceLoader:

@Autowired ResourceLoader resourceLoader;

Og så henter vi vores ressource med getResource:

public Resource loadEmployeesWithResourceLoader () {return resourceLoader.getResource ("classpath: data / workers.dat"); }

Bemærk også det ResourceLoader er implementeret af al beton ApplicationContexts, hvilket betyder, at vi også simpelthen kan stole på ApplicationContext hvis det passer bedre til vores situation:

ApplicationContext kontekst; public Resource loadEmployeesWithApplicationContext () {return context.getResource ("classpath: data / workers.dat"); }

3. Brug ResourceUtils

Som en advarsel er der en anden måde at hente ressourcer om foråret på, men ResourceUtils Javadoc er klar over, at klassen primært er til internt brug.

Hvis vi ser anvendelser af ResourceUtils i vores kode:

offentlig File loadEmployeesWithSpringInternalClass () kaster FileNotFoundException {return ResourceUtils.getFile ("classpath: data / workers.dat"); }

Vi bør nøje overveje begrundelsen som det er sandsynligvis bedre at bruge en af ​​standardmetoderne ovenfor.

4. Læsning af ressourcedata

Når vi har en Ressource, det er let for os at læse indholdet. Som vi allerede har diskuteret, kan vi let få en Fil eller en InputStream henvisning fra Ressource.

Lad os forestille os, at vi har følgende fil, data / medarbejdere. dat, på klassestien:

Joe Medarbejder, Jan Medarbejder, James T. Medarbejder

4.1. Læsning som en Fil

Nu kan vi læse dets indhold ved at ringe getFile:

@Test offentlig ugyldig nårResourceAsFile_thenReadSuccessful () kaster IOException {File resource = new ClassPathResource ("data / workers.dat"). GetFile (); String medarbejdere = nye String (Files.readAllBytes (resource.toPath ())); assertEquals ("Joe Medarbejder, Jan Medarbejder, James T. Medarbejder", medarbejdere); }

Selvom, bemærk at denne tilgang forventer, at ressourcen skal være til stede i filsystemet og ikke i en jar-fil.

4.2. Læsning som en InputStream

Lad os dog sige, at vores ressource er inde i en krukke.

Derefter kan vi i stedet læse en Ressource som en InputStream:

@Test offentlig ugyldig nårResourceAsStream_thenReadSuccessful () kaster IOException {InputStream ressource = ny ClassPathResource ("data / ansatte.dat"). GetInputStream (); prøv (BufferedReader-læser = ny BufferedReader (ny InputStreamReader (ressource))) {Stringmedarbejdere = reader.lines () .collect (Collectors.joining ("\ n")); assertEquals ("Joe Medarbejder, Jan Medarbejder, James T. Medarbejder", medarbejdere); }}

5. Konklusion

I denne hurtige artikel har vi set et par måder at få adgang til og læse en ressource fra klassestien ved hjælp af Spring inklusive ivrig og doven indlæsning og på filsystemet eller i en krukke.

Og som altid har jeg sendt alle disse eksempler ud på GitHub.