Quiero usar gradle + hibernate

Hola quiero iniciar un proyecto con usando gradle + hibernate+, peor no se por donde iniciar.
El asunto viene en que dependencias añadir para poder usar hibernate + gradle?

Saludos

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de benek

Instala Gradle

Ya lei ambos

Ya los lei,antes de postear, el asunto es que no se como se añaden librerias como en el pom.xml de mvn

Imagen de benek

Cierto

Cierto, no viene en ninguno de los dos manejo de dependencias.

Las dependencias las defines dentro del build.gradle, para Hibernate sería algo así:

dependencies {
    runtime group: 'org.hibernate', name: 'hibernate', version: '3.0.5', transitive: true
}

Puedes agregar tus dependencias con la notación de Ivy o la de Maven.

Pero antes debes agregar un repositorio, por ejemplo MavenCentral:

repositories {
    mavenCentral()
}

Y eso hará que Gradle busque la dependencia dentro del repo de Maven.

Imagen de ezamudio

dependencias

Gradle utiliza Ivy para el manejo de dependencias, por lo que puedes usar un repo de Ivy si tienes uno, o el repo central de Maven como ya indicó Benek. Las dependencias las puedes definir como te puso benek o de manera más breve así:

repositories {
  mavenLocal()
  mavenCentral()
}
dependencies {
  compile 'org.hibernate:hibernate:3.0.5', 'org.slf4:slf4j-api:1.6.1'
  runtime 'org.slf4j:slf4j-simple:1.6.1'
  testCompile 'org.junit:junit:4.8.2'
  testRuntime 'org.springframework:spring-test:3.0.5.RELEASE'
}

La configuración anterior tiene estos efectos:

Al momento de compilar, se cargará hibernate 3.0.5 y todas sus dependencias directas que vengan indicadas en el repo de Maven.

Al momento de ejecutar la app (si la ejecutas con Gradle, dentro de una tarea), se usarán las dependencias de compile y además se agregarán las de runtime.

Al momento de compilar las pruebas unitarias, se usarán las dependencias de compile y las de testCompile. Y al momento de ejecutar las pruebas unitarias, se usarán las dependencias de compile, testCompile y testRuntime (según recuerdo, al momento de UT no se incluyen las de runtime). Y tú puedes crear tus propias configuraciones, por ejemplo para pruebas de integración o algo así:

configurations {
  integrationTest extendsFrom testCompile
}
dependencies {
  integrationTest 'alguna.dependencia:paraIntegration:1.0'
}

Si estás manejando multiproyecto, desde un subproyecto puedes incluir otro proyecto como dependencia haciendo referencia directa a él:

dependencies {
  compile project(':ruta:al:proyecto1')
}

Y dado que a fin de cuentas esto lo interpreta Groovy, puedes usar GStrings si gustas. Por ejemplo si tienes muchas dependencias de Spring y no quieres estar repitiendo el número de versión puedes hacer algo así:

springVersion="3.0.5.RELEASE"

dependencies {
  compile "org.springframework:spring-core:$springVersion", "org.springframework:spring-beans:$springVersion"
  testCompile "org.springframework:spring-test:$springVersion"
  testRuntime "org.springframework:spring-aop:$springVersion"
}

Y así, cuando quieras cambiar la versión de Spring solamente lo haces en un lugar (puedes hacer algo similar con Hibernate si es que todas las bibliotecas que vas a usar tienen la misma versión, pero creo que Hibernate no unifica sus versiones).