Explora la interoperabilidad de Swift y Java

Hola, mi nombre es Konrad. Soy ingeniero en el equipo de lenguaje Swift. Hoy quiero presentarles un nuevo esfuerzo que iniciamos este año: la interoperabilidad entre Swift y Java. Esto nos entusiasma, ya que amplía la gama de apps en las que podemos usar Swift. Con la interoperabilidad, podemos introducir Swift de a poco en bases de código existentes escritas en otros lenguajes. No hay que hacer reescrituras grandes, sino que solo agregamos una nueva funcionalidad o reemplazamos una existente con Swift sin modificar el resto de la base de código existente. Y podemos reutilizar bibliotecas existentes implementadas en otros lenguajes. Podemos reemplazarlas con bibliotecas escritas en Swift. Y la forma en que abordamos la interoperabilidad va más allá del lenguaje, ya que se integra con las herramientas de compilación más apropiadas para cada ecosistema. Como CMake para proyectos C o C++, o Gradle para proyectos Java. La interoperabilidad con los lenguajes C son una funcionalidad de primera de Swift desde el primer día. Permitió a Swift integrarse perfectamente con el ecosistema de desarrolladores de Apple existente y así convertirse en el lenguaje principal para desarrollar en estas plataformas. Hace dos años, presentamos el esfuerzo de interoperabilidad de C++, que permitió la combinación perfecta de bibliotecas de C++ y Swift en una base de código. Esto abrió muchas posibilidades para usar Swift en más lugares. Para más información sobre esto, consulta “Swift and C++ combinados” de la WWDC23, o “Combinar C, C++ y Swift de forma segura” de este año. Al hablar de interoperabilidad, podemos centrarnos en dos direcciones. Primero, podemos escribir una app principalmente en Swift e invocar a algún código escrito en Java. O podemos centrarnos en hacer que sea fácil y eficiente invocar Swift desde Java. La interoperabilidad de Swift con Java admite ambas direcciones. Las herramientas y técnicas que usamos en cada dirección son apenas diferentes, pero se pueden usar todas juntas en un solo proyecto. Antes de pasar a ejemplos específicos, repasaremos las diferencias entre los entornos de ejecución de Java y Swift. Luego, exploraremos tres ejemplos prácticos de cómo poner en práctica la interoperabilidad de Java. En primer lugar, con la funcionalidad de métodos nativos existentes de Java. También exploraremos cómo hacer que una biblioteca Java completa sea accesible para Swift. Finalmente, exploraremos lo opuesto y ajustaremos una biblioteca Swift completa para que un proyecto Java la pueda tomar fácilmente. Comencemos con los dos tiempos de ejecución. Después de todo, el entorno de ejecución de Java es muy diferente a otros lenguajes nativos con los que Swift ya tiene interoperabilidad. Aunque podríamos decir que Swift es quizás el lenguaje nativo más parecido a Java que existe. Ambos lenguajes ofrecen clases con un modelo de herencia similar. Ambos proporcionan una forma de administración automática de memoria, en gran medida transparente. Ambos ofrecen un sistema genérico que es bastante similar, aunque representado de manera diferente en tiempo de ejecución. Finalmente, se pueden lanzar errores de Swift, al igual que las excepciones de Java. Aunque la cantidad de información que transportan en tiempo de ejecución es ligeramente diferente. Lo importante es que al elegir cómo vamos a interactuar con esas funcionalidades, podamos expresar la mayoría de las API de un lenguaje en el otro. Repasamos las diferencias y similitudes entre estos lenguajes. Ahora veamos cómo ampliar una app de Java existente. Comencemos de manera simple: implementemos una sola función en Swift. Para eso, usaremos la funcionalidad del lenguaje Java llamada Métodos Nativos. Métodos Nativos de Java son parte de la API Java Native Interface, también conocida como JNI. JNI es parte de Java desde 1997, antes del iPod, y se diseñó para que Java interopere con el código nativo. Se usa a menudo para lograr objetivos de rendimiento, moviendo trabajo fuera de la pila de Java o para usar bibliotecas nativas sin equivalente en Java. Todavía es una de las formas principales en que Java y el código nativo interoperan, y las API no cambiaron mucho desde entonces. Entonces, tiene sentido comenzar nuestra exploración con la JNI. Para familiarizarnos un poco con JNI, sigamos los pasos principales para usar JNI sin ninguna biblioteca o herramienta de soporte. En el lado de la app de Java, defines una función nativa, que se implementará con el código nativo. Para ilustrar cómo JNI maneja el paso de objetos al código nativo, usamos los tipos Uppercase Integer como argumentos y tipo de retorno de esta función. A diferencia de los valores Int primitivos, estos son objetos Java y tendremos que trabajar con ellos. Luego debes usar el compilador Java con un indicador “-h” en cualquier archivo que contenga métodos nativos. Esto resultará en un archivo de encabezado C que contiene declaraciones de funciones C que los JVM intentarán invocar cuando se invoque el método nativo de Java correspondiente. La declaración tiene un nombre bastante detallado: Java_com_example_JNIExample_compute, que coincide con el paquete, la clase y el nombre del método nativo. Acepta algo llamado entorno JNI y el parámetro jobject para la referencia This del objeto Java en el que llamamos al método y todos los parámetros de la declaración de función Java original. Finalmente, debes implementar esta función en el idioma nativo de tu elección: para nosotros sería Swift.

Es mucho código, ¿verdad? Aunque el código estándar está eclipsando la implementación lógica real, que está aquí. Es importante. Existen numerosas posibilidades de que algo salga mal, lo que podría provocar un accidente fatal. En resumen, JNI es una forma útil de invocar código nativo desde los JVM, pero también es muy difícil de usar correctamente. Para que las implementaciones de métodos sean eficientes, es posible que necesitemos almacenamiento en caché y otras técnicas que compliquen aún más el código. Hay pasos de compilación adicionales y encabezados C a considerar. Es muy común cometer errores al hacer coincidir manualmente todas las firmas de métodos y cadenas mágicas. También tenemos que administrar con cuidado la vida útil de cualquier objeto Java creado o recibido. Se puede realizar JNI sin apoyo adicional, pero no es una gran experiencia. Lo que nos lleva a SwiftJava, el nuevo hogar del esfuerzo de interoperabilidad de Swift y Java. Estamos construyendo SwiftJava para ofrecer a los desarrolladores de Swift y Java una forma flexible, segura y de alto rendimiento de interactuar entre esos dos lenguajes.

SwiftJava consta de algunas piezas que puedes usar solas o en conjunto. Primero, un paquete Swift: ofrece la biblioteca JavaKit y las macros, que hacen que trabajar con código JNI sea más seguro, como mostramos en el ejemplo anterior. También tenemos la biblioteca Java SwiftKit. Ayuda a las apps de Java a administrar eficazmente los objetos Swift. Y la herramienta de línea de comandos Swift-Java y más integraciones de sistemas de compilación, como, el módulo SwiftPM o las formas en curso de integración con herramientas de compilación Java populares, como Gradle. Volvamos a hacer el último ejemplo, pero esta vez usaremos las herramientas de SwiftJava. En lugar de un compilador Java, usemos la herramienta de línea de comandos Swift-Java para generar el puente necesario. Necesitamos darle un nombre de módulo donde se deben escribir las fuentes generadas y alguna configuración adicional. En proyectos más complejos, esto podría activarse con un complemento de compilación en SwiftPM o un sistema de compilación diferente. El resultado de este flujo de trabajo es un archivo Swift con decoraciones que describen la clase Java importada. Si el tipo Java tiene métodos miembro, estos también aparecen en el tipo Swift correspondiente, lo que nos permite volver a invocar estas funciones Java desde Swift. Finalmente, el protocolo JNIExampleNativeMethods generado contiene todos los métodos nativos que podemos implementar para este tipo. Esto sirve como reemplazo del encabezado C que estábamos usando antes. Para implementar realmente su función de cálculo nativa, necesitamos escribir una extensión en la clase JNIExample generada y ajustarla al protocolo JNIExampleNativeMethods. También tenemos que anotarlo usando la macro JavaImplementation que proporciona JavaKit. Luego, el compilador nos permitirá implementar la firma de función requerida correctamente. Debemos recordar hacer anotaciones con la macro JavaMethod, que maneja algunos detalles JNI adicionales. Gracias a SwiftJava, la implementación de nuestros métodos ahora es mucho más sencilla y podemos centrarnos en nuestra lógica de negocios. Pero lo mejor es que ahora que estamos en Swift, podemos usar la biblioteca Swift que queramos. Por ejemplo, podría querer usar una implementación nativa de algún algoritmo criptográfico. El ecosistema Swift tiene una excelente biblioteca para eso, y puedo importar el módulo criptográfico y, por ejemplo, calcular el hash SHA256 para los datos pasados. Quizás recuerdes la lista de problemas que tuvimos en nuestra implementación anterior de JNI. La mayoría no son tanto sobre JNI, sino sobre lo difícil que fue usarlo correctamente. Gracias al enfoque de SwiftJava hacia JNI, podemos evitar gran parte del código estándar y el código resultante es más fácil de mantener y guardar de forma predeterminada. No necesitamos interactuar con los encabezados C. En su lugar, podemos confiar en firmas de funciones generadas bien tipificadas. Esto nos ahorra errores, cuya depuración puede llevar mucho tiempo. Por último, la administración de la vida útil de los objetos mejoró mucho en comparación con escribir manualmente la unión entre los lenguajes. Esto es crucial para escribir código seguro para la memoria, superando las barreras del lenguaje. En general, es más agradable y seguro realizar cualquier tipo de interacciones JNI con SwiftJava en lugar de escribirlo a mano. Pero apenas comenzamos. SwiftJava tiene mucho más para ofrecer. También consideremos una situación en la que nos gustaría usar una biblioteca Java de Swift. Usaremos la misma herramienta Swift-Java, pero esta vez nos centraremos en cómo abordaríamos la importación de toda una biblioteca Java, no solo un tipo. Por ejemplo, quiero usar la popular biblioteca Java Apache Commons CSV de Swift. Necesito encontrar la biblioteca en sí, y todas sus dependencias posteriores. La resolución de dependencias se complica muy rápido, ya que las bibliotecas Java a menudo tienen muchas dependencias transitivas, que tienen sus dependencias, y así sucesivamente. Por suerte, SwiftJava puede encargarse de esto por nosotros. Lo que debemos hacer es preparar las coordenadas del artefacto de la biblioteca que nos gustaría usar. Por lo general, los encuentras fácilmente en línea. Puedes preguntarle a quien desarrolle con Java de tu equipo si tienes dudas. La dependencia se expresará como un triple de: un ID de artefacto que identifica el artefacto específico, un ID de grupo que identifica la organización que publica la biblioteca y un número de versión. Luego, usaremos la integración de Gradle de SwiftJava, que es una herramienta de compilación y administrador de dependencias popular en el ecosistema Java. Para expresar esta dependencia en Gradle, debemos colocar columnas entre estos tres valores. Así, formamos un descriptor de dependencia en un formato que Gradle entiende. Conocemos las coordenadas de dependencia, ahora tenemos dos opciones para elegir cómo descargarlas y ajustarlas en nuestro destino JavaApacheCommonsCSV. El primer método es usar el complemento de herramienta de compilación SwiftJava. Dentro del archivo swift-java.config, agregaríamos una sección de dependencias que enumera todas las dependencias raíz que nos gustaría resolver. Es bastante agradable. Ahora el complemento invocará automáticamente Gradle para resolver las dependencias cada vez que compilemos nuestro proyecto SwiftPM. SwiftPM aplica un entorno limitado de seguridad para que los complementos creados no puedan acceder a archivos y redes arbitrarios. Entonces, si deseas usar este enfoque, puedes deshabilitar la zona protegida de seguridad al compilar el proyecto. Puede que esto no sea viable en todos los entornos, por eso te proponemos un enfoque alternativo. Podemos usar el comando Resolve de la herramienta de línea de comandos Swift-Java. Al pasarle un nombre de módulo que contenga el archivo de configuración, la herramienta resolverá las dependencias y escribirá la ruta de clase resultante en un archivo. Como esto se realiza fuera de la compilación de SwiftPM, no debemos deshabilitar la zona protegida. Sin embargo, esto significa que deberás activar manualmente la resolución de dependencia de esta manera antes de compilar el proyecto. Es como un intercambio y tú puedes elegir el modelo que mejor se adapte a tu flujo de trabajo.

De todas formas, ahora podemos usar la biblioteca Java de Swift. Tenemos que importar JavaKit y los módulos JavaApacheCommonsCSV. Luego iniciamos los JVM dentro de nuestro proceso Swift para ejecutar el código Java. Y estamos listos para usar Java desde dentro de nuestra app de Swift. Como aquí, usamos el FileReader del JDK y lo pasamos a la biblioteca CSV que recién importamos. Incluso podemos usar los bucles foreach de Swift directamente en las colecciones Java devueltas.

Aprendimos cómo SwiftJava usa Gradle y SwiftPM para brindar una excelente experiencia de usuario. Podemos importar bibliotecas Java enteras sin tener que modificar ninguna de las fuentes Java. El código Swift generado por el origen hace uso de los tipos de contenedor JDK proporcionados por JavaKit y maneja los tipos definidos por el usuario. JavaKit también simplifica la administración de la vida útil de los objetos Java al promover referencias a objetos Java a referencias globales de ser necesario. La última técnica que veremos hoy es hacer que una biblioteca Swift completa esté disponible para una app Java. Es un caso de uso muy importante porque nos permite implementar una lógica de negocio central crucial en Swift y usarla en todas nuestras apps y servicios, hayan adoptado Swift o no.

Antes mencionamos que la interoperabilidad debe ser recíproca. La dirección de Java a Swift es una gran experiencia: más proyectos usan Swift y es divertido, un aspecto social importante de la introducción de un nuevo lenguaje a una base de código. Si quisiéramos abordar la exposición de una biblioteca Swift completa con las técnicas anteriores, tendríamos que escribir muchas funciones de ajustes en el lado de Java. Para unas pocas funciones está bien, pero si hablamos de una biblioteca completa, es momento de considerar un enfoque diferente. Como hicimos para exponer una biblioteca Java a Swift, ahora hagamos que invocar Swift sea lo más sencillo y directo posible para Java. Ajustemos todos los tipos de nuestra biblioteca Swift con clases Java y los vamos a distribuir todos juntos como una biblioteca Java. Esta vez no usaremos JNI. En su lugar, usaremos la nueva API Foreign Function and Memory que se estabilizó en marzo del año pasado y ahora está disponible desde Java 22. Esta API ofrece un control mejorado sobre la memoria nativa y cómo se forman las llamadas nativas. En algunas situaciones se puede usar como reemplazo de JNI. Al usar estas nuevas API, podemos crear una integración muy profunda entre el tiempo de ejecución y la administración de memoria de Java y Swift. De otra manera, esto no hubiera sido posible. Como resultado, la seguridad y el rendimiento mejoran a medida que realizamos llamadas nativas desde Java. Aquí, usaremos el tipo de estructura Swift que representa algún objeto comercial que me gustaría exponer a Java. Es un tipo de valor, no tiene una identidad de objeto estable, algo que los objetos Java no pueden expresar. Por eso, deberemos tener cuidado al tratar con este objeto en Java. También tiene una propiedad public, un inicializador y algunos métodos para operar en él. Para exponer este tipo a Java, usaremos nuevamente la herramienta de línea de comandos Swift-Java. Sin embargo, esta vez lo usaremos en un modo un poco diferente. Le daremos una ruta de entrada Swift y directorios de salida para las fuentes Swift y Java generadas. Luego, la herramienta tomará todas las fuentes de la ruta de entrada y generará clases Java, que sirven como accesores para los tipos y funciones de Swift. También generaremos algún código auxiliar Swift necesario. Finalmente, todo, incluso el código Swift creado como una biblioteca dinámica, se compilará y empaquetará en una biblioteca Java. La clase Java generada se verá así. Implementa la interfaz de valor Swift porque era una estructura. La clase contiene un segmento de memoria propia, que efectivamente es un puntero a la instancia en la memoria nativa. También representa todos los inicializadores, propiedades y funciones public que usan sus firmas Java equivalentes. Dentro de estos, generamos un código de origen eficiente para realizar llamadas nativas con las API de Foreign Function. Dentro de nuestra app Java, podemos depender de la generación de fuentes Java. Para crear y administrar valores Swift nativos, necesitaremos un SwiftArena, que se encarga de la asignación de memoria y la vida útil de los objetos Swift. Con Arena preparado, podemos simplemente invocar el constructor de valores Swift, como si fuera una clase Java normal. Aprovechemos para hablar un poco más sobre cómo se administran aquí los recursos de memoria nativos y de Java. Primero, se asigna un nuevo objeto contenedor de Java en el montón de Java, que es administrado por el recolector de basura de los JVM. Luego, el constructor generado por el origen usa el pasado en SwiftArena para asignar e iniciar una instancia del tipo de valor Swift en el montón nativo. Por lo general, los tipos de valores como nuestra estructura SwiftyBusiness se asignan en la pila, pero como necesitamos una dirección de memoria estable, la asignamos en el montón. Esto nos permite apuntar de forma segura a esta dirección de memoria desde el objeto contenedor de Java. Finalmente, el contenedor de Java ya no se usa, y el recolector de basura decidirá recolectarlo y destruirlo. Esto también destruirá la instancia nativa en el lado de Swift. En términos de administración de memoria, esto es seguro. Pero, a diferencia de Swift, confiar en la finalización de objetos así pone una gran tensión en el GC debido al seguimiento adicional que necesita realizar para dichos objetos. Y genera un momento impredecible en el que se desinicializa el valor Swift nativo. Si bien este es un patrón fácil para comenzar, te mostraré una mejor forma de administrar la memoria nativa. En lugar de usar Auto Arena, podemos usar una sintaxis Java try-with-resources en combinación con un tipo Confined Arena. La asignación de objetos se realizará de igual manera aquí, pero el intento con recursos cambia la forma en que se destruyen los objetos. En concreto, al finalizar el triscopio, Arena se cerrará. Esto desencadena la destrucción del objeto contenedor de Java y, por consiguiente, la destrucción del valor Swift en el montón nativo. Este enfoque es mucho mejor. No cargamos al GC con la finalización de objetos, lo que puede ser problemático cuando se realiza en grandes cantidades. También recuperamos la propiedad de desinicialización de objetos bien definida y ordenada, de la que dependen muchos programas Swift. Por lo tanto, siempre que sea posible, intenta usar Scoped Arenas, en lugar de GC para obtener un mejor comportamiento y rendimiento de la app. En resumen: pudimos ajustar una biblioteca Swift completa con solo una invocación de la herramienta de línea de comandos Swift-Java. Podemos crear bibliotecas Swift ajustadas en Java e incluso publicarlas, lo que hace que sean fáciles de usar en proyectos Java y simplifica la adopción de Swift en tus equipos. Con las modernas API de Foreign Function and Memory, podemos controlar las asignaciones y duraciones de los objetos, incluso de los tipos de valores Swift. Hoy cubrimos muchas técnicas diferentes para trabajar con Swift y Java, y puedes usarlas por separado o juntas, según las necesidades de tu proyecto. Si bien apenas comenzamos y queda mucho por pulir y refinar, SwiftJava ya ofrece un gran enfoque para la interoperabilidad entre estos lenguajes. Al usar las bibliotecas de soporte de SwiftKit y JavaKit, puedes escribir un código seguro y eficiente que use un lenguaje en lugar del otro. Y, las macros de JavaKit y la herramienta de línea de comandos Swift-Java generan automáticamente cualquier código repetitivo que de otro modo sería difícil de mantener.

Por último, me gustaría invitarles a unirse al desarrollo de este proyecto. Es de código abierto y está disponible en la organización Swiftlang Github. Todavía quedan muchos desafíos apasionantes por resolver e ideas por explorar. Si aún no quieres contribuir, pero te gustaría aprender más sobre Swift y Java o compartir tus ideas y comentarios, la mejor manera es unirte a los foros de Swift. Gracias por acompañarme. En cuanto a mí, creo que me tomaré una taza de café.