Spring boot es una extensión de Spring framework que facilita el desarrollo de aplicaciones web y microservicios usando java, kotlin o groovy. En esta ocasión crearemos una API REST con Spring Boot y kotlin.
Requisitos
- Un editor de código como IntelliJ o Visual Studio Code.
- Kotlin y Gradle.
Spring initializr
Crearemos un proyecto Spring Boot usando la herramienta web spring initializr. Comenzaremos navegando a https://start.spring.io/ .
Configuramos un proyecto gradle-kotin con kotlin y la versión 3.5.5 de Spring Boot. En el apartado dependencias seleccionamos Spring Web, Spring Web DevTools, Spring Data Jpa y H2 Database.
Spring Web proporciona un servidor Tomcat (entre otras funcionalidades web ), DevTools reanuda automáticamente la aplicación cuando los cambios son guardados, Data Jpa persiste datos SQL con Hibernate y H2 es una base de datos en memoria.
En el apartado metadatos escribimos car como nombre de artefacto. Finalmente hacemos click en generar proyecto para obtener un zip que incluye todos los archivos necesarios.
Abrir proyecto desde el IDE
Desde Visual Studio Code abrimos la carpeta descomprimida: File -> Open Folder. Donde vemos la jerarquía de directorios y ficheros generados por Spring Initializr.
Método main
\src\main\kotlin\com\djl\car: Esta carpeta contiene el archivo CarApplication.kt con el método main, que es el punto de entrada de la aplicación.
package com.djl.car
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class CarApplication
fun main(args: Array<String>) {
runApplication<CarApplication>(*args)
En este mismo directorio creamos 2 carpetas que usaremos más adelante: model y controller.
$ mkdir model $ mkdir controller
Archivo application.properties
En la carpeta resources encontramos el archivo application.properties que nos permite configurar varios apartados del proyecto. Lo abrimos y rellenamos con lo siguiente:
spring.application.name=car spring.devtools.livereload.enabled=true spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= spring.h2.console.enabled=true spring.h2.console.path=/h2console/ spring.jpa.database-platform=org.hibernate.dialect.H2Dialect spring.jpa.hibernate.ddl-auto = update spring.jpa.show-sql=true
La mayoría de las propiedades están relacionadas con la base de datos. A destacar las de spring.h2.console.enabled=true y spring.h2.console.path. Estas propiedades habilitan la consola h2 en http://localhost:8080/h2console/. Donde podemos ver la información de nuestra db.
Crear el Modelo
Dentro del directorio model añadimos la clase Car.kt.
package com.djl.car
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue
@Entity
class Car(
var brand: String,
var licencePlate: String,
@Id @GeneratedValue
var id: Long? = null
)
La clase Car tiene 2 campos de tipo String (brand y licensePlate) y un id de tipo Long auto incremental.
En el mismo directorio añadimos la interface CarRepository.kt que proporciona varios métodos para interactuar con la base de datos, como findAll() o saveAll().
package com.djl.car
import org.springframework.data.repository.CrudRepository;
interface CarRepository : CrudRepository<Car, Long> {}
Crear el Controlador
Dentro del directorio controller creamos un nuevo archivo con el nombre CarController.kt y escribimos el siguiente código.
package com.djl.car
import org.springframework.web.bind.annotation.*
@RestController
@RequestMapping("/api/car")
class CarController(private val repository: CarRepository) {
@GetMapping
fun findAll() = repository.findAll()
}
Las anotaciones @RestController y @RequestMapping implementan una HTTP API en la url http://localhost:8080/api/car. Mediante el constructor inyectamos nuestro CarRepository para acceder a los objetos de la base de datos.
Poblar la Base de datos
Ahora creamos un archivo de configuración para poblar la base de datos H2 con algunos objetos de prueba.
package com.djl.car
import org.springframework.boot.ApplicationRunner
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class CarConfiguration {
@Bean
fun databaseInitializer(repository: CarRepository) = ApplicationRunner {
val cars = listOf(
Car("BMW M3", "6122 ghj"),
Car("Audi S3", "3456 cbs"),
Car("Volkswagen Golf GTI", "5687 gl7"))
repository.saveAll(cars)
}
}
Ejecutar proyecto Spring Boot Kotlin con Gradle
Desde el directorio del proyecto ejecutamos el siguiente comando:
./gradlew bootRun
Esto inicia el servidor Tomcat en el puerto http://localhost:8080/. Si accedemos mediante el navegador web a http://localhost:8080/api/car, vemos la información guardada en la db en formato JSON.
0 comentarios