Cree una API REST de Spring Boot con Java – Gu铆a completa

     

    Introducci贸n

    DESCANSO son las siglas de REpresentational State Transfer, un enfoque estandarizado para crear servicios web.

    UN API REST es una interfaz de programaci贸n de aplicaciones intermediaria que permite que dos aplicaciones se comuniquen entre s铆 a trav茅s de HTTP, de forma muy similar a como se comunican los servidores con los navegadores.

    RESTful es el enfoque m谩s com煤n para crear servicios web debido a lo f谩cil que es aprender y construir.

    Supongamos que pide algo en un restaurante de comida r谩pida y el cajero le solicita la informaci贸n necesaria para procesar su pedido. Una vez procesado, le entregan el pedido que solicit贸. Esta transacci贸n es un ejemplo de la vida real de c贸mo funciona la API REST.

    En este tutorial, veremos c贸mo crear una API REST en Java con Spring Boot. Aceptar谩 POST y GET solicitar cargas 煤tiles para ver y agregar entradas de una entidad – User.

    Requisitos

    • IDE o editor de texto
    • JDK 1.8+
    • Maven 3+ o Gradle 4+ (confiaremos en Maven para este art铆culo)

    Inicializaci贸n de un proyecto Spring Boot

    Usando Spring Initializr

    Una forma sencilla de inicializar un nuevo proyecto de Spring Boot es utilizando Spring Initializr, que genera autom谩ticamente un proyecto Spring Boot esqueleto para usted:

    Agregaremos algunas dependencias aqu铆 tambi茅n, ya que queremos usarlas en nuestro proyecto:

    • Spring Web – Para incluir Spring MVC y Tomcat incrustado en su proyecto
    • Spring Data JPA – API de persistencia de Java e Hibernate
    • Spring Boot DevTools – Herramientas de desarrollo muy 煤tiles
    • Controlador MySQL – Controlador JDBC (puede ser cualquier base de datos que desee utilizar)

    Luego, presione generar. Luego se descargar谩 un archivo zip que contiene el proyecto generado.

    Usando Spring CLI

    Si usted tiene Spring CLI instalado, entonces puede optar por usar la consola para construir su proyecto base usando este comando:

    spring init --build=maven -p=jar UserDemo
    

    Nota: Spring CLI llama directamente a Spring Initializr para realizar esta operaci贸n. Ambas opciones producir谩n el mismo proyecto.

    Despu茅s de crear su proyecto base, desc谩rguelo e imp贸rtelo a su IDE o editor de texto de su elecci贸n. Si desea crear, compilar y ejecutar su aplicaci贸n a trav茅s de su IDE, aseg煤rese de importarla como un proyecto Maven o Gradle.

    Al importar, la base generada pom.xml en su proyecto se ver谩 as铆:

    <!-- Project information-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <!-- Build information -->
    

    Todas las configuraciones que hizo se reflejar谩n en este archivo. Adem谩s de eso, dependencias predeterminadas, su instant谩nea base 0.0.1-SNAPSHOT, y el plugin de compilaci贸n de Maven tambi茅n se configuran autom谩ticamente.

    Como referencia, si desea construir un Proyecto Gradle, tu build.gradle se ver谩 as铆:

    plugins {
    	id 'org.springframework.boot' version '2.3.5.RELEASE'
    	id 'io.spring.dependency-management' version '1.0.10.RELEASE'
    	id 'java'
    }
    
    group = 'com.howto'
    version = '0.0.1-SNAPSHOT'
    sourceCompatibility = '11'
    
    repositories {
    	mavenCentral()
    }
    
    dependencies {
    	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    	implementation 'org.springframework.boot:spring-boot-starter-web'
    	developmentOnly 'org.springframework.boot:spring-boot-devtools'
    	runtimeOnly 'com.mysql:mysql-connector-java'
    	testImplementation('org.springframework.boot:spring-boot-starter-test') {
    		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    	}
    }
    
    test {
    	useJUnitPlatform()
    }
    

    Conexi贸n de Spring Boot a la base de datos

    A continuaci贸n, antes de empezar a trabajar en la aplicaci贸n, queremos configurar la base de datos. Esto se puede hacer f谩cilmente a trav茅s de Spring Data JPA, que nos permite configurar esta conexi贸n con solo un par de par谩metros.

    Extrae todo lo que debe hacer el desarrollador y nos permite cambiar las bases de datos subyacentes si lo deseamos, simplemente cambiando un par de propiedades.

    Para decirle a Spring c贸mo conectarse a su base de datos preferida, en su application.properties archivo, deber谩 agregar informaci贸n rudimentaria:

    spring.datasource.url = jdbc:mysql://localhost:3306/user
    spring.datasource.username = user
    spring.datasource.password = user
    spring.jpa.hibernate.ddl-auto = update
    spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
    

    Aqu铆, hemos configurado el datasource.url a nuestra URL de conexi贸n JDBC. Esto depende de su base de datos. Hemos proporcionado el username y password necesario para autenticarse en esa base de datos, as铆 como establecer el ddl-auto propiedad a update. los jpa.hibernate.ddl-auto la propiedad influye directamente en el hibernate.hbm2ddl.auto propiedad, y esencialmente define c贸mo Hibernate debe manejar la administraci贸n de herramientas de esquema.

    Para aplicaciones de producci贸n, este valor generalmente se establece en none, como personal dedicado a la gesti贸n de la conducta. En desarrollo, es m谩s com煤n usar update, para permitir que el esquema se actualice cada vez que reinicia la aplicaci贸n, lo que le permite flexibilidad mientras trabaja en el desarrollo.

    Finalmente, hemos configurado el hibernate.dialect propiedad. Hibernate tiene diferentes dialectos para diferentes bases de datos. Puede establecer autom谩ticamente el dialecto seg煤n su configuraci贸n, aunque, para mayor seguridad, siempre es una buena idea especificarlo expl铆citamente.

    Modelo de dominio: creaci贸n de un modelo de usuario

    Ahora que la conexi贸n de la base de datos est谩 funcionando, podemos continuar y saltar al Modelo de dominio. Este es un conjunto de clases, o m谩s bien modelos, que usaremos en nuestra aplicaci贸n. Con Hibernate, tambi茅n se denominan Entidades, as铆 como anotadas por el @Entity anotaci贸n.

    Cada @Entity es recogido por Hibernate, se crea una tabla para 茅l, se mapean los campos y se convierte en una entidad administrada para la base de datos que ha configurado.

    Primero, creemos un sencillo User entidad. Anotaremos la clase con @Entity y el opcional @Table anotaci贸n para especificar el nombre de nuestra tabla.

    Si no se establece, solo usar谩 el mismo nombre que la clase:

    @Entity
    @Table(name = "user")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private long id;
        private String name;
    
        // Constructor, getters and setters   
    }
    

    Para anotar un campo como id de una entidad, utiliza el @Id anotaci贸n, y se establecer谩 como la clave principal de incremento autom谩tico de la tabla. Adem谩s, tambi茅n puede configurar que sea un @GeneratedValue y establecer el GenerationType a AUTO.

    Esta es la configuraci贸n predeterminada, si omite la @GeneratedValue anotaci贸n. Otros valores que puede establecer son IDENTITY, SEQUENCE y TABLE. Estos garantizan un art铆culo propio sobre Hibernate.

    Adem谩s, puede configurar @Column anotaciones para cada uno de los campos, proporcionando un nombre para cada uno de ellos si desea nombres personalizados – @Column(name = "user_id"), salvar铆a el id campo como user_id en lugar de solo id.

    Si desea automatizar la generaci贸n de constructores, captadores y definidores y simplemente evitar el c贸digo repetitivo en total, puede usar herramientas ingeniosas como Lombok.

    Esta clase (entidad) ahora est谩 registrada con Hibernate. Si ejecutamos la aplicaci贸n, considerando nuestro ddl-auto configuraci贸n, la tabla aparecer谩 en su base de datos respectiva, con la tabla correcta y las asignaciones para los tipos de datos.

    Capa de persistencia: creaci贸n de clases de repositorio

    A continuaci贸n, trabajemos en la capa de persistencia. Queremos tener un UserRepository para realizar operaciones CRUD en nuestro User entidades. Para hacer esto, especificaremos una interfaz que se extiende CrudRepositoryy an贸telo con @Repository.

    @Repository es una variante del @Component anotaci贸n, que le permite a Spring saber que es un componente que debe ser administrado por el contenedor de IoC. Espec铆ficamente, los repositorios est谩n destinados a definir la l贸gica para la capa de persistencia.

    los CrudRepository extenssion acepta la clase de entidad, as铆 como la id tipo de datos que debe usar para consultar:

    @Repository
    public interface UserRepository extends CrudRepository<User, Long> {}
    

    CrudRepository declara m茅todos como findAll(), findOne()y save() que constituyen la funcionalidad CRUD b谩sica de un repositorio. Puedes usar esto UserRepository tal cual, para realizar operaciones CRUD en User entidades ahora, sin m谩s configuraci贸n requerida.

    Puede anular parte de este comportamiento, si lo desea, sin embargo, se configura autom谩ticamente para ayudarlo a iniciar algunas funciones b谩sicas.

    Capa empresarial: creaci贸n de un controlador

    Finalmente, llegamos a la capa empresarial, donde implementamos la l贸gica empresarial real del procesamiento de informaci贸n y usamos los componentes de la capa de persistencia, junto con el modelo de dominio para almacenar datos.

    Creemos un controlador, m谩rquelo como @RestController, ya que estamos creando una API REST y agregamos una @RequestMapping lo. @RestController es solo una combinaci贸n de @Controller y @ResponseBody, lo que significa que en lugar de representar p谩ginas, solo responder谩 con los datos que le hemos proporcionado. Esto es natural para las API REST: devuelve informaci贸n una vez que se ha alcanzado un punto final de la API.

    Si desea leer m谩s sobre @RequestMapping y sus variantes derivadas, 隆tenemos un excelente art铆culo dedicado solo a ese tema!

    Sigamos adelante y hagamos un UserController:

    @RestController
    @RequestMapping("/api/user")
    public class UserController {
    
        @Autowired
        private UserRepository userRepository;
            
        @GetMapping
        public List<User> findAllUsers() {
            // Implement
        }
    
        @GetMapping("/{id}")
        public ResponseEntity<User> findUserById(@PathVariable(value = "id") long id) {
           // Implement
        }
    
        @PostMapping
        public User saveUser(@Validated @RequestBody User user) {
            // Implement
        }
    }
    

    Tenemos @Autowired nuestra UserRepository. Se usa para la inyecci贸n de dependencias, ya que la clase de repositorio es una dependencia aqu铆. Si desea leer m谩s sobre las anotaciones de Core Spring Framework, consulte nuestra gu铆a.

    Tambi茅n hemos utilizado el @GetMapping y @PostMapping anotaciones para especificar qu茅 tipos de solicitudes HTTP aceptan y manejan nuestros m茅todos. Estas son variantes derivadas del @RequestMapping anotaci贸n, con una method = RequestMethod.METHOD establecido para los tipos respectivos.

    Comencemos con la implementaci贸n del findAll() punto final:

    @GetMapping
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
    

    Este m茅todo simplemente llama al userRepository a findAll() usuarios y devuelve la lista como respuesta.

    A continuaci贸n, implementemos el punto final para obtener a cada usuario por su id:

    @GetMapping("/{id}")
    public ResponseEntity<User> findUserById(@PathVariable(value = "id") long id) {
        Optional<User> user = userRepository.findById(id);
    
        if(user.isPresent()) {
            return ResponseEntity.ok().body(user.get());
        } else {
            return ResponseEntity.notFound().build();
        }
    }
    

    A con lo dado id podr铆a no estar presente en la base de datos, por lo que ajustamos el devuelto User en un Optional. Si desea leer m谩s sobre Opcional en Java 8, 隆tenemos una gu铆a detallada!

    Entonces, si el user.isPresent(), devolvemos un 200 OK Respuesta HTTP y establezca el user instancia como el cuerpo de la respuesta. De lo contrario, devolvemos un ResponseEntity.notFound().

    Finalmente, creemos un punto final para salvar a los usuarios:

    @PostMapping
    public User saveUser(@Validated @RequestBody User user) {
        return userRepository.save(user);
    }
    

    los save() El m茅todo del repositorio de usuarios guarda un nuevo usuario si a煤n no existe. Si el usuario con el id ya existe, lanza una excepci贸n. Si tiene 茅xito, devuelve el usuario persistente.

    los @Validated La anotaci贸n es un validador de los datos que proporcionamos sobre el usuario y refuerza la validez b谩sica. Si la informaci贸n del usuario no es v谩lida, los datos no se guardan. Tambi茅n el @RequestBody anotaci贸n mapea el cuerpo del POST solicitud enviada al punto final al User instancia que nos gustar铆a guardar.

    Si desea leer m谩s sobre c贸mo obtener el cuerpo HTTP en Spring Boot, 隆lo tenemos cubierto!

    Ahora es el momento de ejecutar la aplicaci贸n y probar si funciona.

    Compilar, construir y ejecutar

    El puerto predeterminado en el que se ejecuta Spring Boot es 8080. Si desea cambiar el puerto por cualquier motivo, puede configurarlo en su application.properties archivo:

    server.port = 9090
    

    Si tiene un IDE como IntelliJ que tiene un amplio soporte para ejecutar proyectos Spring Boot, entonces puede seguir adelante y ejecutarlo de esa manera.

    De lo contrario, usaremos la l铆nea de comando para ejecutar nuestro proyecto. Podemos ejecutar la aplicaci贸n directamente ejecutando ./mvnw spring-boot:run (o ./gradlew bootRun si est谩 usando Gradle) en la l铆nea de comando desde la carpeta de su proyecto base donde pom.xml se encuentra.

    Otra opci贸n es empaquetar su aplicaci贸n en un jar archivo y ejecutarlo de esa manera.

    Para hacer esto, solo tenemos que ejecutar ./mvnw clean package (.gradlew build en Gradle) y ejecute el archivo jar ejecutando este comando:

    $ java -jar target/DemoUser-0.0.1-SNAPSHOT.jar
    

    Si est谩 utilizando Gradle, la ruta al archivo jar ser谩 diferente:

    $ java -jar build/libs/DemoUser-0.0.1-SNAPSHOT.jar
    

    Sabr谩 cu谩ndo su aplicaci贸n se ha ejecutado correctamente si ve estos registros de auditor铆a al final de su l铆nea de comando:

    2020-11-05 13:27:05.073  INFO 21796 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
    2020-11-05 13:27:05.108  INFO 21796 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
    2020-11-05 13:27:05.121  INFO 21796 --- [  restartedMain] com.howto.DemoUser.DemoUserApplication   : Started DemoUserApplication in 1.765 seconds (JVM running for 2.236)
    
    

    Probando las API

    Ahora que su aplicaci贸n est谩 funcionando en http://localhost:8080/, ahora podemos probar los puntos finales para ver si funcionan.

    Para el GET solicitudes, podemos utilizar navegadores, curl o cartero – lo que sea m谩s conveniente para usted.

    Vamos a golpear el http://localhost:8080/api/user punto final con un GET solicitud:

    $ curl http://localhost:8080/api/user
    

    O, en la barra de direcciones de su navegador, visite http://localhost:8080/api/user, y su navegador mostrar谩 una respuesta JSON:

    [
       {
          "id": 1,
          "name":"John"
       },
       {
          "id": 2,
          "name":"Jane"
       },
       {
          "id": 3,
          "name": "Juan"
       }
    ]
    

    Podemos modificar esta URL para incluir un par谩metro de ruta, el id para obtener un usuario espec铆fico. Enviemos una solicitud HTTP GET a http://localhost:8080/api/user/3:

    {
        "id": 3,
        "name": "Juan"
    } 
    

    Finalmente, enviemos una solicitud HTTP POST y agreguemos un usuario a nuestra base de datos, proporcionando los datos requeridos en nuestro modelo. Los campos de la carga 煤til JSON deben coincidir con los nombres de los campos en nuestra base de datos / modelo:

    $ curl --location --request POST 'http://localhost:8080/api/user' 
    --header 'Content-Type: application/json' 
    --data-raw '{ "id": 4, "name": "Jason" }'
    

    La API devolver谩 200 como respuesta con esto como el cuerpo de respuesta del usuario persistente:

    {
        "id": 4,
        "name": "Jason"
    }
    

    Conclusi贸n

    Ah铆 tienes. 隆Ha creado con 茅xito su propia API REST de Spring Boot!

    En este tutorial, hemos creado un proyecto Spring Boot en pleno funcionamiento que expone una API al usuario final. Con esta API, un usuario puede realizar operaciones CRUD en un User entidad.

    Hemos cubierto el modelo de dominio, la capa de persistencia y la capa de negocio, despu茅s de configurar la conexi贸n a la base de datos y configurar el proyecto.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *