Scala está diseñado para ser compatible y interoperable con Java. Esto significa que puedes utilizar clases de Java directamente en Scala y viceversa, lo que facilita la integración de bibliotecas y el aprovechamiento del ecosistema Java existente en proyectos Scala.
// Ejemplo de interoperabilidad Scala-Java
// Clase Java simple
// Archivo: Persona.java
// package com.ejemplo;
// public class Persona {
// private String nombre;
// private int edad;
// public Persona(String nombre, int edad) {
// this.nombre = nombre;
// this.edad = edad;
// }
// public String getNombre() {
// return nombre;
// }
// public void setNombre(String nombre) {
// this.nombre = nombre;
// }
// public int getEdad() {
// return edad;
// }
// public void setEdad(int edad) {
// this.edad = edad;
// }
// @Override
// public String toString() {
// return "Persona{" +
// "nombre='" + nombre + '\'' +
// ", edad=" + edad +
// '}';
// }
// }
// Ejemplo de uso en Scala
object InteroperabilidadJavaScala extends App {
// Importación de la clase Java
import com.ejemplo.Persona
// Creación de objeto Persona (Java)
val personaJava = new Persona("Juan", 30)
// Acceso a métodos y propiedades Java desde Scala
println(s"Nombre: ${personaJava.getNombre}")
println(s"Edad: ${personaJava.getEdad}")
// Modificación de propiedades desde Scala
personaJava.setNombre("Pedro")
personaJava.setEdad(25)
// Impresión del objeto modificado
println(personaJava)
}
Definición de la Clase Java: La clase Persona se define en Java dentro del paquete com.ejemplo. Esta clase tiene propiedades (nombre y edad) con sus respectivos getters y setters, además de un método toString para representar el objeto como una cadena.
Uso en Scala: En Scala, se importa la clase Persona de Java utilizando import com.ejemplo.Persona.
Creación de Objeto Java: val personaJava = new Persona("Juan", 30) crea un objeto Persona utilizando el constructor definido en Java.
Acceso a Métodos y Propiedades: Desde Scala, se accede a los métodos getNombre() y getEdad() para obtener la información de la persona creada.
Modificación de Propiedades: Se utilizan los métodos setNombre() y setEdad() para modificar las propiedades de la persona desde Scala.
Impresión del Objeto Modificado: Finalmente, se imprime el objeto personaJava después de haber sido modificado para verificar los cambios realizados.
Importación de Clases: Las clases Java se importan en Scala de manera similar a como se importan en Java, especificando el paquete completo de la clase.
Uso de Métodos y Propiedades: Los métodos y propiedades de las clases Java se acceden y utilizan de la misma manera que en Java, respetando la visibilidad y métodos definidos.
Interoperabilidad Bidireccional: Scala y Java pueden intercambiar objetos y llamar métodos entre sí de manera fluida, lo que facilita la integración de código y bibliotecas existentes.
El uso de bibliotecas populares en Scala, como Apache Spark, Akka y Play Framework, es fundamental para desarrollar aplicaciones robustas y escalables en diferentes dominios, desde procesamiento de datos hasta construcción de sistemas concurrentes y desarrollo web. A continuación, te proporcionaré una breve descripción y ejemplos de uso de cada una de estas bibliotecas:
Apache Spark es un framework de procesamiento de datos en memoria distribuido, diseñado para ejecutar aplicaciones rápidas de análisis de datos en clústeres de computadoras. Proporciona APIs en Scala, Java, Python y R, siendo Scala la opción nativa y más utilizada.
Para contar la cantidad de palabras en un archivo de texto usando Spark en Scala:
import org.apache.spark.sql.SparkSession
object ContadorPalabrasSpark {
def main(args: Array[String]): Unit = {
val spark = SparkSession.builder()
.appName("Contador de Palabras")
.master("local[*]") // Se ejecuta localmente usando todos los núcleos
.getOrCreate()
val sc = spark.sparkContext
val textoRDD = sc.textFile("ruta/al/archivo.txt")
val contarPalabras = textoRDD.flatMap(linea => linea.split(" "))
.map(palabra => (palabra, 1))
.reduceByKey(_ + _)
contarPalabras.foreach(println)
spark.stop()
}
}
Play Framework es un framework web escalable y de código abierto para construir aplicaciones web y RESTful en Scala (también soporta Java). Proporciona un entorno de desarrollo y herramientas para la creación rápida de aplicaciones web modernas.
Un ejemplo sencillo de controlador en Play Framework en Scala:
// Controlador en Play Framework
// Archivo: HomeController.scala
package controllers
import play.api.mvc._
class HomeController(cc: ControllerComponents) extends AbstractController(cc) {
def index() = Action { implicit request: Request[AnyContent] =>
Ok("¡Hola desde Play Framework en Scala!")
}
def saludar(nombre: String) = Action { implicit request: Request[AnyContent] =>
Ok(s"¡Hola, $nombre!")
}
}
SBT (Scala Build Tool) es la herramienta estándar de construcción de proyectos Scala. Permite gestionar dependencias, compilar código, ejecutar pruebas y generar artefactos de manera eficiente. Aquí te mostraré cómo gestionar dependencias utilizando SBT.
Para ilustrar el manejo de dependencias con SBT, utilizaremos un archivo de configuración build.sbt típico y mostraremos cómo agregar y manejar dependencias.
build.sbt
name := "MiProyectoScala"
version := "1.0"
scalaVersion := "2.13.8"
// Dependencias
libraryDependencies ++= Seq(
"org.apache.spark" %% "spark-core" % "3.2.0", // Ejemplo de dependencia de Apache Spark
"com.typesafe.akka" %% "akka-actor-typed" % "2.6.19", // Ejemplo de dependencia de Akka
"com.typesafe.play" %% "play-json" % "2.10.0" // Ejemplo de dependencia de Play Framework (para JSON)
)
Configuración Básica (name, version, scalaVersion):
name := "MiProyectoScala" define el nombre del proyecto.version := "1.0" especifica la versión del proyecto.scalaVersion := "2.13.8" indica la versión de Scala que se utilizará en el proyecto.Gestión de Dependencias (libraryDependencies):
libraryDependencies ++= Seq(...) se utiliza para definir las dependencias del proyecto.%% se usa en lugar de % para indicar que SBT debe agregar automáticamente el sufijo Scala binario compatible con la versión de Scala utilizada (_2.13 en este caso).Ejemplos de Dependencias:
"org.apache.spark" %% "spark-core" % "3.2.0" agrega la dependencia de Apache Spark Core en su última versión estable."com.typesafe.akka" %% "akka-actor-typed" % "2.6.19" agrega la dependencia de Akka Actor Typed."com.typesafe.play" %% "play-json" % "2.10.0" agrega la dependencia de Play Framework para manejo de JSON.Una vez configurado el archivo build.sbt con las dependencias necesarias, puedes usar SBT desde la terminal para manejar tu proyecto:
sbt compile para compilar el código fuente del proyecto.sbt test para ejecutar pruebas unitarias definidas en el proyecto.sbt update para actualizar las dependencias del proyecto según lo definido en build.sbt.sbt run para ejecutar la aplicación Scala.