Ho una struttura di cartelle come di seguito:

- main
-- java
-- resources 
-- scalaresources
--- commandFiles 

e in quelle cartelle ho i miei file che devo leggere. Ecco il codice:

def readData(runtype: String, snmphost: String, comstring: String, specificType:  String): Unit = {
  val realOrInvFile = "/commandFiles/snmpcmds." +runtype.trim // these files are under commandFiles folder, which I have to read. 
    try {
      if (specificType.equalsIgnoreCase("Cisco")) {
        val specificDeviceFile: String = "/commandFiles/snmpcmds."+runtype.trim+ ".cisco"
        val realOrInvCmdsList = scala.io.Source.fromFile(realOrInvFile).getLines().toList.filterNot(line => line.startsWith("#")).map{
          //some code 
        }
        val specificCmdsList = scala.io.Source.fromFile(specificDeviceFile).getLines().toList.filterNot(line => line.startsWith("#")).map{
          //some code
        }
      }
    } catch {
      case e: Exception => e.printStackTrace
    }
  }
}

Le risorse in Scala funzionano esattamente come in Java. È meglio seguire le migliori pratiche Java e inserire tutte le risorse in src/main/resourcese src/test/resources.

Esempio di struttura di cartelle:

testing_styles/
├── build.sbt
├── src
│   └── main
│       ├── resources
│       │   └── readme.txt

Scala 2.12.x && 2.13.x leggendo una risorsa

Per leggere le risorse l'oggetto Source fornisce il metodo fromResource .

import scala.io.Source
val readmeText : Iterator[String] = Source.fromResource("readme.txt").getLines

risorse di lettura precedenti alla 2.12 (ancora le mie preferite a causa della compatibilità con jar)

Per leggere le risorse puoi utilizzare getClass.getResource e getClass.getResourceAsStream .

val stream: InputStream = getClass.getResourceAsStream("/readme.txt")
val lines: Iterator[String] = scala.io.Source.fromInputStream( stream ).getLines

feedback di errore migliore (2.12.x && 2.13.x)

Per evitare NPE Java non debuggabili, considerare:

import scala.util.Try
import scala.io.Source
import java.io.FileNotFoundException

object Example {

  def readResourceWithNiceError(resourcePath: String): Try[Iterator[String]] = 
    Try(Source.fromResource(resourcePath).getLines)
      .recover(throw new FileNotFoundException(resourcePath))
 }

buono a sapersi

Tieni presente che getResourceAsStream funziona bene anche quando le risorse fanno parte di un jar , getResource , che restituisce un URL che viene spesso utilizzato per creare un file può causare problemi lì.

in produzione

Nel codice di produzione suggerisco di assicurarmi che il sorgente sia nuovamente chiuso.

Per Scala> = 2.12, usa Source.fromResource:

scala.io.Source.fromResource("located_in_resouces.any")

Soluzione online per Scala> = 2.12

val source_html = Source.fromResource("file.html").mkString

import scala.io.Source

object Demo {

  def main(args: Array[String]): Unit = {

    val fileStream = getClass.getResourceAsStream("/json-sample.js")
    val lines = Source.fromInputStream(fileStream).getLines
    lines.foreach(line => println(line))

  }

}

EDIT: credito all'autore originale. Fare riferimento al blog completo qui

Per Scala 2.11 , se getLines non fa esattamente quello che vuoi, puoi anche copiare il file a dal jar nel file system locale.

Ecco uno snippit che legge una chiave API in formato binario google .p12 da / resources, la scrive in / tmp e quindi utilizza la stringa del percorso del file come input per una scrittura spark-google-spreadsheets .

Nel mondo di sbt-native-packager e sbt-assembly , la copia in locale è utile anche con i test di file binari più scalabili. Basta estrarli dalle risorse in locale, eseguire i test e quindi eliminare.

import java.io.{File, FileOutputStream}
import java.nio.file.{Files, Paths}

def resourceToLocal(resourcePath: String) = {
  val outPath = "/tmp/" + resourcePath
  if (!Files.exists(Paths.get(outPath))) {
    val resourceFileStream = getClass.getResourceAsStream(s"/${resourcePath}")
    val fos = new FileOutputStream(outPath)
    fos.write(
      Stream.continually(resourceFileStream.read).takeWhile(-1 !=).map(_.toByte).toArray
    )
    fos.close()
  }
  outPath
}

val filePathFromResourcesDirectory = "google-docs-key.p12"
val serviceAccountId = "[something]@drive-integration-[something].iam.gserviceaccount.com"
val googleSheetId = "1nC8Y3a8cvtXhhrpZCNAsP4MBHRm5Uee4xX-rCW3CW_4"
val tabName = "Favorite Cities"

import spark.implicits
val df = Seq(("Brooklyn", "New York"), 
          ("New York City", "New York"), 
          ("San Francisco", "California")).
          toDF("City", "State")

df.write.
  format("com.github.potix2.spark.google.spreadsheets").
  option("serviceAccountId", serviceAccountId).
  option("credentialPath", resourceToLocal(filePathFromResourcesDirectory)).
  save(s"${googleSheetId}/${tabName}")

È possibile accedere al file richiesto come di seguito dalla cartella delle risorse in scala

val file = scala.io.Source.fromFile(s"src/main/resources/app.config").getLines().mkString