3.7 Resolución de dependencias - Reference Documentation
Authors: Graeme Rocher, Peter Ledbrook, Marc Palmer, Jeff Brown, Luke Daley, Burt Beckwith
Version: null
Table of Contents
3.7 Resolución de dependencias
Grails features a dependency resolution DSL that lets you control how plugins and JAR dependencies are resolved.You specify a
Grails ofrece un DSL de resolución de dependencia que le permite controlar cómo se resuelven las dependencias de plugins y de los JAR.Especifica una propiedad grails.project.dependency.resolution property inside the grails-app/conf/BuildConfig.groovy file that configures how dependencies are resolved:grails.project.dependency.resolution dentro del archivo grails-app/conf/BuildConfig.groovy que configura cómo se resuelven las dependencias:grails.project.dependency.resolution = {
// config here
}The default configuration looks like the following:
La configuración por defecto el siguiente aspecto:grails.project.class.dir = "target/classes" grails.project.test.class.dir = "target/test-classes" grails.project.test.reports.dir = "target/test-reports" //grails.project.war.file = "target/${appName}-${appVersion}.war"grails.project.dependency.resolution = { // inherit Grails' default dependencies inherits("global") { // uncomment to disable ehcache // excludes 'ehcache' } log "warn" repositories { grailsPlugins() grailsHome() grailsCentral() // uncomment these to enable remote dependency resolution // from public Maven repositories //mavenCentral() //mavenLocal() //mavenRepo "http://snapshots.repository.codehaus.org" //mavenRepo "http://repository.codehaus.org" //mavenRepo "http://download.java.net/maven/2/" //mavenRepo "http://repository.jboss.com/maven2/" } dependencies { // specify dependencies here under either 'build', 'compile', // 'runtime', 'test' or 'provided' scopes eg. // runtime 'mysql:mysql-connector-java:5.1.16' } plugins { compile ":hibernate:$grailsVersion" compile ":jquery:1.6.1.1" compile ":resources:1.0" build ":tomcat:$grailsVersion" } }
The details of the above will be explained in the next few sections.
Los detalles sobre lo anterior se explica en las siguientes secciones.
3.7.1 Configuración y dependencias
Grails features five dependency resolution configurations (or 'scopes'):
Grails ofrece cinco configuraciones de resolución de dependencia (o 'ámbitos'):
-
build: Dependencies for the build system only -
compile: Dependencies for the compile step -
runtime: Dependencies needed at runtime but not for compilation (see above) -
test: Dependencies needed for testing but not at runtime (see above) -
provided: Dependencies needed at development time, but not during WAR deployment
dependencies block you can specify a dependency that falls into one of these configurations by calling the equivalent method. For example if your application requires the MySQL driver to function at runtime you can specify that like this:build: dependencias sólo para el sistema de compilación.compile: dependencias para el tiempo de compilación.runtime: dependencias necesarias en tiempo de ejecución, pero no para la compilación (véase más arriba).test: dependencias necesarias para las pruebas, pero no en tiempo de ejecución (véase más arriba).provided: dependencias necesarias en el tiempo de desarrollo, pero no durante el despliegue de WAR.
dependencies puede especificar una dependencia que corresponde con una de estas configuraciones llamando al método equivalente. Por ejemplo, si su aplicación requiere el controlador MySQL funcione en tiempo de ejecución(runtime) puede especificaro así:runtime 'com.mysql:mysql-connector-java:5.1.16'
This uses the string syntax:
Esto utiliza la sintaxis de cadena: group:name:version. You can also use a Map-based syntax:group:name:version. También puede utilizar una sintaxis basada en mapas:runtime group: 'com.mysql',
name: 'mysql-connector-java',
version: '5.1.16'In Maven terminology,
En la terminología de Maven, group corresponds to an artifact's groupId and name corresponds to its artifactId.Multiple dependencies can be specified by passing multiple arguments:group corresponde al groupId de un artefacto y name corresponde a su artifactId.Varias dependencias pueden especificarse pasando varios argumentos:runtime 'com.mysql:mysql-connector-java:5.1.16',
'net.sf.ehcache:ehcache:1.6.1'// oruntime(
[group:'com.mysql', name:'mysql-connector-java', version:'5.1.16'],
[group:'net.sf.ehcache', name:'ehcache', version:'1.6.1']
)Disabling transitive dependency resolution
By default, Grails will not only get the JARs and plugins that you declare, but it will also get their transitive dependencies. This is usually what you want, but there are occasions where you want a dependency without all its baggage. In such cases, you can disable transitive dependency resolution on a case-by-case basis:Deshabilitar la resolución de dependencias transitiva
De forma predeterminada, Grails no sólo obtendrá los jars y plugins que se declaran, sino también sus dependencias transitivas. Esto suele ser lo que se desea, pero hay ocasiones donde desea una dependencia sin todo su equipaje. En tales casos, puede deshabilitar la resolución de dependencia transitivas:runtime('com.mysql:mysql-connector-java:5.1.16',
'net.sf.ehcache:ehcache:1.6.1') {
transitive = false
}// o
runtime group:'com.mysql',
name:'mysql-connector-java',
version:'5.1.16',
transitive:falseExcluding specific transitive dependencies
A far more common scenario is where you want the transitive dependencies, but some of them cause issues with your own dependencies or are unnecessary. For example, many Apache projects have 'commons-logging' as a transitive dependency, but it shouldn't be included in a Grails project (we use SLF4J). That's where theexcludes option comes in:Excluyendo las dependencias transitivas específicas
Un escenario mucho más común es cuando desea las dependencias transitivas, pero algunos de ellos causan problemas con sus propias dependencias o son innecesarias. Por ejemplo, muchos proyectos de Apache tienen 'commons-logging' como una dependencia transitiva, pero no debería ser incluido en un proyecto Grails (utilizamos SLF4J). Ahí es donde la opciónexcludes interviene:runtime('com.mysql:mysql-connector-java:5.1.16',
'net.sf.ehcache:ehcache:1.6.1') {
excludes "xml-apis", "commons-logging"
}// o
runtime(group:'com.mysql', name:'mysql-connector-java', version:'5.1.16') {
excludes([ group: 'xml-apis', name: 'xml-apis'],
[ group: 'org.apache.httpcomponents' ],
[ name: 'commons-logging' ])As you can see, you can either exclude dependencies by their artifact ID (also known as a module name) or any combination of group and artifact IDs (if you use the Map notation). You may also come across
Como puede ver, puede excluir las dependencias por su ID de artefacto (también conocido como un nombre de módulo) o cualquier combinación de ID de grupo y artefacto (si se utiliza la notación del mapa). También puede utilizar exclude as well, but that can only accept a single string or Map:exclude, pero este sólo puede aceptar una sola cadena o mapa:runtime('com.mysql:mysql-connector-java:5.1.16',
'net.sf.ehcache:ehcache:1.6.1') {
exclude "xml-apis"
}Using Ivy module configurations
If you use Ivy module configurations and wish to depend on a specific configuration of a module, you can use thedependencyConfiguration method to specify the configuration to use.Utilizando las configuraciones de módulo de Ivy
Si utiliza las configuraciones de módulo de Ivy y desea depender de una configuración específica de un módulo, puede utilizar el métododependencyConfiguration para especificar la configuración a usar.provided("my.org:web-service:1.0") { dependencyConfiguration "api" }
If the dependency configuration is not explicitly set, the configuration named
Si no se establece explícitamente la configuración de la dependencia, la configuración denominada "default" will be used (which is also the correct value for dependencies coming from Maven style repositories).
"default" se utilizará (que es también el valor correcto para dependencias procedentes de repositorios de estilo Maven).
3.7.2 Repositorios de dependencias
Remote Repositories
Initially your BuildConfig.groovy does not use any remote public Maven repositories. There is a defaultgrailsHome() repository that will locate the JAR files Grails needs from your Grails installation. To use a public repository, specify it in the repositories block:Repositorios remotos
Inicialmente su BuildConfig.groovy no utiliza los repositorios Maven públicos remotos. Existe un repositorio por defectograilsHome() que buscará los archivos JAR Grails necesarios para la instalación de Grails. Para usar un público, especifiquelo en bloque repositories:repositories {
mavenCentral()
}In this case the default public Maven repository is specified. To use the SpringSource Enterprise Bundle Repository you can use the
En este caso se especifica el repositorio de Maven público predeterminado. Para utilizar el repositorio de paquetes empresarial de SpringSource (Enterprise Bundle Repository) puede utilizar el método ebr() method:ebr() método:repositories {
ebr()
}You can also specify a specific Maven repository to use by URL:
También puede especificar un repositorio Maven específico utilizando una URL:repositories {
mavenRepo "http://repository.codehaus.org"
}Controlling Repositories Inherited from Plugins
A plugin you have installed may define a reference to a remote repository just as an application can. By default your application will inherit this repository definition when you install the plugin.Repositorios de control heredados de Plugins
Un plugin que ha instalado puede definir una referencia a un repositorio remoto igual que una aplicación. Por defecto la aplicación heredará esta definición de repositorio al instalar el plugin.If you do not wish to inherit repository definitions from plugins then you can disable repository inheritance:
Si no desea heredar las definiciones de repositorio de plugins puede desactivar herencia del repositorio:repositories {
inherit false
}En este caso su aplicación no heredará las definiciones de repositorio de plugins y es su labor proporcionar definiciones adecuadas de repositorio (posiblemente internos).
Local Resolvers
If you do not wish to use a public Maven repository you can specify a flat file repository:repositories {
flatDir name:'myRepo', dirs:'/path/to/repo'
}Resoluciones locales
Si no desea usar un repositorio Maven puede especificar un repositorio de archivos planos:repositories {
flatDir name:'myRepo', dirs:'/path/to/repo'
}~/.m2/repository) as a repository:Para especificar su memoria caché local de Maven (
~/.m2/repository) como un repositorio:repositories {
mavenLocal()
}Custom Resolvers
If all else fails since Grails builds on Apache Ivy you can specify an Ivy resolver:Resoluciones personalizadas
Si todo lo demás falla como Grails se basa en Apache Ivy puede especificar una resolución Ivy:/* * Configure our resolver. */ def libResolver = new org.apache.ivy.plugins.resolver.URLResolver() ['libraries', 'builds'].each { libResolver.addArtifactPattern( "http://my.repository/${it}/" + "[organisation]/[module]/[revision]/[type]s/[artifact].[ext]") libResolver.addIvyPattern( "http://my.repository/${it}/" + "[organisation]/[module]/[revision]/[type]s/[artifact].[ext]") }libResolver.name = "my-repository" libResolver.settings = ivySettingsresolver libResolver
It's also possible to pull dependencies from a repository using SSH. Ivy comes with a dedicated resolver that you can configure and include in your project like so:
También es posible extraer las dependencias de un repositorio mediante SSH. Ivy viene con una resolutor dedicado que puede configurar e incluir en el proyecto como tal:import org.apache.ivy.plugins.resolver.SshResolver … repositories { ... def sshResolver = new SshResolver( name: "myRepo", user: "username", host: "dev.x.com", keyFile: new File("/home/username/.ssh/id_rsa"), m2compatible: true) sshResolver.addArtifactPattern( "/home/grails/repo/[organisation]/[artifact]/" + "[revision]/[artifact]-[revision].[ext]") sshResolver.latestStrategy = new org.apache.ivy.plugins.latest.LatestTimeStrategy() sshResolver.changingPattern = ".*SNAPSHOT" sshResolver.setCheckmodified(true) resolver sshResolver }
Download the JSch JAR and add it to Grails' classpath to use the SSH resolver. You can do this by passing the path in the Grails command line:
Descargue el JAR JSch y añadalo al classpath de Grails para utilizar el resolutor SSH. Puede hacerlo pasando la ruta en la línea de comandos de Grails:grails -classpath /path/to/jsch compile|run-app|etc.
You can also add its path to the
También puede agregar su ruta a la variable de entorno CLASSPATH environment variable but be aware this it affects many Java applications. An alternative on Unix is to create an alias for grails -classpath ... so that you don't have to type the extra arguments each time.CLASSPATH pero tenga en cuenta este afecta a muchas aplicaciones de Java. Una alternativa en Unix es crear un alias para grails - classpath..., por lo que no es necesario que escriba los argumentos adicionales cada vez.Authentication
If your repository requires authentication you can configure this using acredentials block:Autenticación
Si su repositorio requiere autenticación puede configurar esto utilizando el bloquecredentials:credentials {
realm = ".."
host = "localhost"
username = "myuser"
password = "mypass"
}This can be placed in your
Esto puede ser colocado en el archivo USER_HOME/.grails/settings.groovy file using the grails.project.ivy.authentication setting:USER_HOME/.grails/settings.groovy mediante la configuración de grails.project.ivy.authentication:grails.project.ivy.authentication = {
credentials {
realm = ".."
host = "localhost"
username = "myuser"
password = "mypass"
}
}3.7.3 Depurando la resolución de dependencias
If you are having trouble getting a dependency to resolve you can enable more verbose debugging from the underlying engine using the
Si está teniendo problemas para conseguir que una dependencia se resuelva puede habilitar un modo de depueración más detallado del motor subyacente mediante el método log method:log:// log level of Ivy resolver, either 'error', 'warn',
// 'info', 'debug' or 'verbose'
log "warn"3.7.4 Dependencias heredadas
By default every Grails application inherits several framework dependencies. This is done through the line:Inside the
De forma predeterminada cada aplicación Grails hereda varias dependencias del framework. Esto se realiza a través de la línea:inherits "global"BuildConfig.groovy file. To exclude specific inherited dependencies you use the excludes method:inherits "global"BuildConfig.groovy. Para excluir dependencias heredadas específicas usa el método excludes:inherits("global") { excludes "oscache", "ehcache" }
3.7.5 Dependencias por defecto
Most Grails applications have runtime dependencies on several jar files that are provided by the Grails framework. These include libraries like Spring, Sitemesh, Hibernate etc. When a war file is created, all of these dependencies will be included in it. But, an application may choose to exclude these jar files from the war. This is useful when the jar files will be provided by the container, as would normally be the case if multiple Grails applications are deployed to the same container.The dependency resolution DSL provides a mechanism to express that all of the default dependencies will be provided by the container. This is done by invoking the
La mayoría de las aplicaciones Grails tienen dependencias de tiempo de ejecución sobre varios archivos jar que proporcionan el framwork Grails. Estos incluyen bibliotecas como Spring, Sitemesh, Hibernate, etc… Cuando se crea un archivo war, todas estas dependencias se incluirá en él. Sin embargo, una aplicación puede excluir estos archivos jar del war. Esto es útil cuando los archivos jar serán proporcionados por el contenedor, ya que normalmente sería el caso si varias aplicaciones Grails se despliegan en el mismo contenedor.La resolución de dependencias DSL proporciona un mecanismo para expresar que todas las dependencias predeterminado serán proporcionados por el contenedor. Esto se hace invocando al método defaultDependenciesProvided method and passing true as an argument:defaultDependenciesProvided y pasando true como argumento:grails.project.dependency.resolution = { defaultDependenciesProvided true // all of the default dependencies will
// be "provided" by the container inherits "global" // inherit Grails' default dependencies repositories {
grailsHome()
…
}
dependencies {
…
}
}defaultDependenciesProvidedmust come beforeinherits, otherwise the Grails dependencies will be included in the war.
defaultDependenciesProvideddebe venir antes deinherits, de lo contrario las dependencias Grails se incluirá en el war.
3.7.6 Informes de dependencias
As mentioned in the previous section a Grails application consists of dependencies inherited from the framework, the plugins installed and the application dependencies itself.To obtain a report of an application's dependencies you can run the dependency-report command:By default this will generate reports in the
Como se menciona en la sección anterior una aplicación Grails consiste en dependencias heredadas del framwork, los plugins instalados y las dependencias de las aplicaciones en sí.Para obtener un informe de las dependencias de una aplicación puede ejecutar el comando dependency-report:grails dependency-report
target/dependency-report directory. You can specify which configuration (scope) you want a report for by passing an argument containing the configuration name:grails dependency-report
target/dependency-report. Puede especificar qué configuración (alcance) desea en un informe pasando un argumento que contiene el nombre de configuración:grails dependency-report runtime
3.7.7 Dependencias Jar de plugins
Specifying Plugin JAR dependencies
The way in which you specify dependencies for a plugin is identical to how you specify dependencies in an application. When a plugin is installed into an application the application automatically inherits the dependencies of the plugin.To define a dependency that is resolved for use with the plugin but not exported to the application then you can set theexport property of the dependency:Especificación de las dependencias JAR de un plugin
La forma en que se especifican las dependencias para un plugin es idéntica a la que permite especificar las dependencias en una aplicación. Cuando se instala un plugin en una aplicación la aplicación hereda automáticamente las dependencias del plugin.Para definir una dependencia que se resuelve para su uso con el plugin pero no se exporta a la aplicación, puede definir la propiedadexport de la dependencia:test('org.spockframework:spock-core:0.5-groovy-1.8') {
export = false
}In this case the Spock dependency will be available only to the plugin and not resolved as an application dependency. Alternatively, if you're using the Map syntax:
En este caso la dependencia Spock estará disponibles sólo para el plugin y no será resuelta como una dependencia de la aplicación. Alternativamente, si utiliza la sintaxis de mapa:test group: 'org.spockframework', name: 'spock-core',
version: '0.5-groovy-1.8', export: falseYou can useexported = falseinstead ofexport = false, but we recommend the latter because it's consistent with the Map argument.
Puede utilizarexported = falseen lugar deexport = false, pero recomendamos este último porque es coherente con el argumento de mapa.
Overriding Plugin JAR Dependencies in Your Application
If a plugin is using a JAR which conflicts with another plugin, or an application dependency then you can override how a plugin resolves its dependencies inside an application using exclusions. For example:Reemplazar las dependencias JAR de un plugin en su aplicación
Si un plugin está utilizando un JAR que crea conflictos con otro plugin, o con una dependencia de la aplicación, se puede modificar cómo un plugin resuelve sus dependencias dentro de una aplicación mediante las exclusiones. Por ejemplo:plugins {
compile(":hibernate:$grailsVersion") {
excludes "javassist"
}
}dependencies {
runtime "javassist:javassist:3.4.GA"
}In this case the application explicitly declares a dependency on the "hibernate" plugin and specifies an exclusion using the
En este caso la aplicación explícitamente declara una dependencia en el plugin de "hibernate" y especifica una exclusión utilizando el método excludes method, effectively excluding the javassist library as a dependency.
excludes, excluyendo la biblioteca de javassist como una dependencia.
3.7.8 Integración con Maven
When using the Grails Maven plugin, Grails' dependency resolution mechanics are disabled as it is assumed that you will manage dependencies with Maven's
Cuando se utiliza el plugin Grails Maven, los mecánismos de resolución de dependencias de Grails están deshabilitados porque se supone que gestionará las dependencias con el archivo de pom.xml file.However, if you would like to continue using Grails regular commands like run-app, test-app and so on then you can tell Grails' command line to load dependencies from the Maven pom.xml file instead.To do so simply add the following line to your BuildConfig.groovy:pom.xml de Maven.Sin embargo, si desea seguir utilizando los comandos Grails como run-app, test-app,etc… puede indicarle a la línea de comandos de Grails que cargue las dependencias del archivo pom.xml Maven en su lugar.Así que simplemente añada la siguiente línea a su BuildConfig.groovy :grails.project.dependency.resolution = {
pom true
..
}
The line
La línea pom true tells Grails to parse Maven's pom.xml and load dependencies from there.
pom true le dice a Grails que analice el pom.xml de Maven y cargue las dependencias desde allí.
3.7.9 Desplegando a un repositorio Maven
If you use Maven to build your Grails project, you can use the standard Maven targets
Si utiliza a Maven para construir su proyecto Grails, puede utilizar el target estándar de Maven mvn install and mvn deploy.
If not, you can deploy a Grails project or plugin to a Maven repository using the maven-publisher plugin.The plugin provides the ability to publish Grails projects and plugins to local and remote Maven repositories. There are two key additional targets added by the plugin:
- maven-install - Installs a Grails project or plugin into your local Maven cache
- maven-deploy - Deploys a Grails project or plugin to a remote Maven repository
pom.xml for you unless a pom.xml is already present in the root of the project, in which case this pom.xml file will be used.mvn install and mvn deploy.
Si no es así, puede desplegar un proyecto Grails o un plugin en un repositorio de Maven utilizando el plugin maven-publisher.El plugin permite publicar proyectos Grails y plugins en repositorios Maven locales y remotos. Hay dos target principales adicionales agregados por el plugin:
- maven-install - instala un plugin o un proyecto Grails en la caché local de Maven.
- maven-deploy - despliega un proyecto Grails o plugin para un repositorio Maven remoto.
pom.xml válido a menos que un pom.xml ya está presente en la raíz del proyecto, en cuyo caso se utilizará este archivo pom.xml.maven-install
Themaven-install command will install the Grails project or plugin artifact into your local Maven cache:grails maven-install
maven-install
El comandomaven-install instalará el proyecto o plugin Grails en la caché local de Maven:grails maven-install
maven-deploy
Themaven-deploy command will deploy a Grails project or plugin into a remote Maven repository:grails maven-deploy
<distributionManagement> configuration within a pom.xml or that you specify the id of the remote repository to deploy to:maven-deploy
El comandomaven-deploy desplegará un proyecto Grails o plugin en un repositorio de Maven remoto:grails maven-deploy
<distributionmanagement> dentro de un pom.xml o que especifica el id del repositorio remoto en el que desplegar:grails maven-deploy --repository=myRepo
The
El argumento repository argument specifies the 'id' for the repository. Configure the details of the repository specified by this 'id' within your grails-app/conf/BuildConfig.groovy file or in your $USER_HOME/.grails/settings.groovy file:repository especifica el 'id' para el repositorio. Configure los detalles del repositorio especificado por este 'id' en el archivo grails-app/conf/BuildConfig.groovy o en el archivo $USER_HOME/.grails/settings.groovy:grails.project.dependency.distribution = {
localRepository = "/path/to/my/local"
remoteRepository(id: "myRepo", url: "http://myserver/path/to/repo")
}The syntax for configuring remote repositories matches the syntax from the remoteRepository element in the Ant Maven tasks. For example the following XML:
La sintaxis para configurar repositorios remotos coincide con la sintaxis del elemento remoteRepository en las tareas Ant Maven. Por ejemplo, el siguiente XML:<remoteRepository id="myRepo" url="scp://localhost/www/repository"> <authentication username="..." privateKey="${user.home}/.ssh/id_dsa"/> </remoteRepository>
Can be expressed as:
Puede ser expresada como:remoteRepository(id: "myRepo", url: "scp://localhost/www/repository") { authentication username: "...", privateKey: "${userHome}/.ssh/id_dsa" }
By default the plugin will try to detect the protocol to use from the URL of the repository (ie "http" from "http://.." etc.), however to specify a different protocol you can do:
De forma predeterminada el plugin intentará detectar el protocolo a usar desde la URL del repositorio (es decir "http" desde "http://..." etc.), sin embargo para especificar otro protocolo puede hacer:grails maven-deploy --repository=myRepo --protocol=webdav
The available protocols are:
Los protocolos disponibles son:
- http
- scp
- scpexe
- ftp
- webdav
- http
- scp
- scpexe
- ftp
- webdav
Groups, Artifacts and Versions
Maven defines the notion of a 'groupId', 'artifactId' and a 'version'. This plugin pulls this information from the Grails project conventions or plugin descriptor.Versiones, artefactos y grupos
Maven define la noción de 'IdGrupo', 'artifactId' y 'versión'. Este plugin extrae esta información de los convenciones de proyecto Grails o del descriptor del plugin.Projects
For applications this plugin will use the Grails application name and version provided by Grails when generating thepom.xml file. To change the version you can run the set-version command:Proyectos
Para las aplicaciones de este plugin utilizará el nombre de la aplicación de Grails y la versión proporcionada por Grails al generar el archivopom.xml. Para cambiar la versión puede ejecutar el comando set-version:grails set-version 0.2
The Maven
El groupId will be the same as the project name, unless you specify a different one in Config.groovy:groupId de Maven será el mismo que el nombre del proyecto, a menos que se especifique otro diferente en Config.groovy:grails.project.groupId="com.mycompany"Plugins
With a Grails plugin thegroupId and version are taken from the following properties in the GrailsPlugin.groovy descriptor:Plugins
Con un plugin de Grails elgroupId y version proceden de las siguientes propiedades en el descriptor de GrailsPlugin.groovy:String groupId = 'myOrg' String version = '0.1'
The 'artifactId' is taken from the plugin name. For example if you have a plugin called
El 'artifactId' se toma del nombre del plugin. Por ejemplo, si tienes un plugin llamado FeedsGrailsPlugin the artifactId will be "feeds". If your plugin does not specify a groupId then this defaults to "org.grails.plugins".FeedsGrailsPlugin el artifactId será "feeds". Si tu plugin no especifica el groupId entonces por defecto utiliza "org.grails.plugins".
3.7.10 Dependencias de plugin
As of Grails 1.3 you can declaratively specify plugins as dependencies via the dependency DSL instead of using the install-plugin command:
Como en Grails 1.3 puede especificar los plugins declarandolos como dependencias a través de la dependencia DSL en lugar de utilizar el comando install-plugin:grails.project.dependency.resolution = {
…
repositories {
…
} plugins {
runtime ':hibernate:1.2.1'
} dependencies {
…
}
…
}If you don't specify a group id the default plugin group id of
Si no especifica un id de grupo se utiliza el id de grupo del plugin predeterminado de org.grails.plugins is used. You can specify to use the latest version of a particular plugin by using "latest.integration" as the version number:org.grails.plugins. Se puede especificar el uso de la versión más reciente de un plugin determinado mediante "latest.integration" como el número de versión:plugins {
runtime ':hibernate:latest.integration'
}Integration vs. Release
The "latest.integration" version label will also include resolving snapshot versions. To not include snapshot versions then use the "latest.release" label:Integration vs. Release
La etiqueta de versión "latest.integration" también incluirá resolver versiones snapshot. Para no incluir versiones snapshot utilice la etiqueta "latest.release":plugins {
runtime ':hibernate:latest.release'
}The "latest.release" label only works with Maven compatible repositories. If you have a regular SVN-based Grails repository then you should use "latest.integration".And of course if you use a Maven repository with an alternative group id you can specify a group id:
La etiqueta de "latest.release" sólo funciona con repositorios compatibles con Maven. Si tienes un repositorio basado en SVN Grails debe utilizar "latest.integration".Y por supuesto si utiliza un repositorio Maven con un id de grupo alternativo puede especificar un id de grupo:
plugins {
runtime 'mycompany:hibernate:latest.integration'
}Plugin Exclusions
You can control how plugins transitively resolves both plugin and JAR dependencies using exclusions. For example:Exclusiones de plugin
Puede controlar cómo los plugins resuelven transitoriamente tanto las dependencias de plugin como de JAR usando las exclusiones. Por ejemplo:plugins {
runtime(':weceem:0.8') {
excludes "searchable"
}
}Here we have defined a dependency on the "weceem" plugin which transitively depends on the "searchable" plugin. By using the
Aquí hemos definido una dependencia en el plugin "weceem" que transitoriamente depende el plugin "searchable". Mediante el uso del método excludes method you can tell Grails not to transitively install the searchable plugin. You can combine this technique to specify an alternative version of a plugin:excludes puede decirle a Grails que NO resuelva transitoriamente el plugin para búsquedas. Puede combinar esta técnica para especificar una versión alternativa de un plugin:plugins {
runtime(':weceem:0.8') {
excludes "searchable" // excludes most recent version
}
runtime ':searchable:0.5.4' // specifies a fixed searchable version
}You can also completely disable transitive plugin installs, in which case no transitive dependencies will be resolved:
Puede deshabilitar también completamente la instalación transitiva de plugins, en cuyo caso se resolverán las dependencias no transitivas:plugins {
runtime(':weceem:0.8') {
transitive = false
}
runtime ':searchable:0.5.4' // specifies a fixed searchable version
}
