Uso de Groovy como lenguaje de scripting

Question

Prefiero usar lenguajes de scripting para tareas cortas, cualquier cosa como un bot de http realmente simple, importación/exportación masiva de datos a/desde algún lugar, etc ... ... scripts básicos desechables y simples cosas. El punto es que un lenguaje de scripting es solo una herramienta eficiente para escribir programas rápidos. En cuanto a mi comprensión de Groovy en este punto ...

Si programaras en Groovy, y quieres escribir un guión rápido, ¿no te verías obligado a volver a la sintaxis regular de Java (y sabemos cómo puede ser complicado en comparación con un lenguaje de scripting) para hacer algo más complicado. Por ejemplo, si quiero hacer algunas secuencias de comandos http, ¿no estaría simplemente de regreso usando la sintaxis de Java para invocar Commons HttpClient? Para mí, el objetivo de un lenguaje de scripting es construir de forma rápida y menos forzada. Y aquí hay otra cosa, no parece que haya ningún incentivo para que se desarrollen bibliotecas basadas en groovy cuando ya hay tantos buenos de Java por ahí, haciendo que groovy parezca ser un lenguaje dependiente de Java con características de scripting menores.

Así que ahora mismo me pregunto si podría cambiar a Groovy como un lenguaje de scripting o continuar usando un lenguaje de scripting más común como Perl, Python o Ruby.

Answer 1

@Zombies, permítame mostrarle un ejemplo rápido de un guión que escribí recientemente:

def fetch(build, toFile) { 
    new FTPClient().with { 
     connect ftpServer 
     enterLocalPassiveMode() 
     login ftpUser, ftpPassword 
     changeWorkingDirectory "/var/staging/revision-${build}" 
     fileType = FTPClient.BINARY_FILE_TYPE 
     toFile.withOutputStream { ostream -> 
      retrieveFile "build-${build}.zip", ostream 
     } 
     disconnect() 
    } 
} 

Utiliza Commons-NET API, pero creo que estaría de acuerdo que tiene una sintaxis mucho más claro que comparables Programa Java Por lo tanto, no creo que el uso de las API de Java sea contrario al propósito de tener un lenguaje de scripting. Además, le ayuda a aprovechar su conocimiento existente de las API de Java, por lo que es un enfoque muy pragmático.

Answer 2

Uno de los objetivos de Groovy es tener una interoperabilidad transparente con Java. Groovy es, por diseño, "un lenguaje dependiente de Java con funciones de scripting". Sin embargo, no creo que estas características sean menores: Groovy tiene muchas características que no se encuentran en los lenguajes de programación estáticos (como Java).

En resumen: si no le importa en absoluto Java, utilice un lenguaje de scripting de uso más general, como Python o Perl. Si desea utilizar la base de código de Java en una forma script-ish, Groovy es una buena opción.

Answer 3

Por ejemplo, si quiero hacer algunas secuencias de comandos http, ¿no estaría simplemente de regreso usando la sintaxis de Java para invocar Commons HttpClient?

Usted estaría "de vuelta en el uso de Commons HttpClient", pero lo invocaría utilizando la sintaxis de Groovy, no la sintaxis de Java. La sintaxis Groovy es mucho más compacta que la sintaxis de Java y, por lo tanto, es más adecuada para la creación de scripts. En otras palabras, el uso de bibliotecas Java en Groovy requiere mucho menos código que el uso de bibliotecas Java en Java.

no parece que haya ningún incentivo para que las bibliotecas basadas maravilloso que desarrollarse cuando ya hay tantas buenas java uno está ahí fuera

En lugar de desarrollar una nueva biblioteca, un maravilloso el autor de la biblioteca a menudo proporcionará una API de "Groovier" a una biblioteca de Java existente. Los ejemplos incluyen el constructor de Hibernate provisto por Grails y el HTTP Builder (que delega a Commons HttpClient).

Estas API de Groovy proporcionan una alternativa más compacta e idiomática al uso de la API de Java directamente.

Answer 4

Groovy "out of the box" reemplaza una gran cantidad de clases comunes con versiones groovier o construcciones de lenguaje, incluyendo clases para XML, solicitudes HTTP, acceso a bases de datos SQL y expresiones regulares. Para la mayoría de las tareas de scripting, no tendrá que usar bibliotecas de Java (aunque todavía tendrá esa opción). Pero si su script usa librerías de Java, estará mucho más adelante con Groovy en Java directo. Donde Groovy brilla está en el código "pegamento", como configuración de estructuras de datos y archivo de E/S.

El mapa y la lista le permiten crear listas y mapas compatibles con Java; objetos regulares de Java que funcionan con clases de Java. Groovy a menudo convierte una invocación de método Java de varias líneas con declaraciones de variables e inicialización en un único liner.

consideran este breve fragmento para cargar un archivo entero en una cadena:

def fileContents = new File(filename).text 

frente

String fileContents = ""; 
try { 
    BufferedReader reader = new BufferedReader(new FileInputStream(filename)); 
    String line = null; 
    while ((line = reader.readLine()) != null) { 
     text = text + line + "\n"; 
    } 
} catch (IOException e) { 
    e.printStackTrace(); 
} 

El manejo de excepciones a menudo no es una consideración importante en las secuencias de comandos y puede ser ignorado convenientemente.

La principal fortaleza de Groovy como lenguaje de scripting es acceder a la enorme biblioteca de código Java que está disponible de manera directa y conveniente. Si esa no es su necesidad, Groovy aún proporciona un entorno de scripting tan rico como otros idiomas como Perl, Python o Ruby.

Answer 5

Groovy puede ser bastante útil para secuencias de comandos. Recientemente necesité una secuencia de comandos para buscar dependencias de Maven en un directorio lib y terminé con una secuencia de comandos groovy. Este fragmento analiza un pom y te da una lista de jarras. ¡Muy dulce para el análisis de XML!

#!/usr/bin/env groovy 
def pom = new XmlSlurper().parse('pom.xml') 
def repo = "${System.env.HOME}/.m2/repository" 

pom.dependencies.dependency.each { dep -> 
    def jarName = "${dep.artifactId}-${dep.version}.jar" 
    def groupPath = dep.groupId.text().replaceAll('\\.', '/') 
    def jarPath = "${repo}/${groupPath}/${dep.artifactId}/${dep.version}" 
    println "$jarPath/$jarName" 
} 

Answer 6

rocas maravilloso, una vez que se consiga una caída de la sintaxis muy ajustado, que comienzan a utilizarlo para un montón de cosas que acabas de hacer "el lento camino".

El otro día estaba en una discusión que de alguna manera se preguntó cuántos caracteres tenemos en un GUID en uno de nuestros sistemas. En lugar de simplemente contar los dígitos, que era más fácil simplemente hacer esto:

def str = '92228498-6A2F-DBA2-7A2C-F54B9E607E3A' 
int num = 0 
str.each { 
    num++ 
} 
println num 

Whack que en un directorio de secuencias de comandos locales o compartidas y estará allí para el futuro.