Spring Boot + Vue JS

cafe-151346_640

En esta ocasión veremos como usar Vue JS en una aplicación Spring Boot.

Creamos nuestra tabla contacto.

contacto.sql

CREATE DATABASE IF NOT EXISTS prueba;

USE prueba;

CREATE TABLE IF NOT EXISTS contacto(id int auto_increment primary key, nombre varchar(100), telefono varchar(12) not null, fecha datetime);

Insertamos algunos valores.

INSERT INTO contacto (nombre,telefono,fecha) VALUES ('Daniel Alcantara','76662323', now()), ('Tomas Torres','5559099', now());

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.codemonkey</groupId>
	<artifactId>servidor</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<name>servidor</name>
	<description>Servidor de servicio web</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<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-thymeleaf</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web-services</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
		<dependency>
		    <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-web-services</artifactId>
		</dependency>
		<dependency>
		    <groupId>wsdl4j</groupId>
	        <artifactId>wsdl4j</artifactId>
		</dependency>

        <dependency>
		   <groupId>org.slf4j</groupId>
           <artifactId>slf4j-api</artifactId>
           <version>1.6.1</version>
		</dependency>

        <dependency>
		  <groupId>org.springframework.data</groupId>
		  <artifactId>spring-data-rest-core</artifactId>
		  <version>3.1.1.RELEASE</version>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>


<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>jaxb2-maven-plugin</artifactId>
    <version>1.6</version>
    <executions>
      <execution>
        <id>xjc</id>
        <goals>
          <goal>xjc</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <schemaDirectory>${project.basedir}/src/main/resources</schemaDirectory>
      <outputDirectory>${project.basedir}/src/main/java/com/codemonkey/clases</outputDirectory>
      <clearOutputDir>false</clearOutputDir>
    </configuration>
  </plugin>


		</plugins>
	</build>


</project>

Nuestro archivo application.yml tendrá el siguiente aspecto:
application.yml

#BANNER
banner:
   charset: UTF-8
   location: banner.txt

spring:
   thymeleaf:
      cache: false
      check-template: true
      check-template-location: true
      content-type: text/html
      enabled: true
      encoding: UTF-8
      suffix: .html
   jpa:
      generate-ddl: true
      database-platform: org.hibernate.dialect.MySQL5Dialect
      show-sql: false
      hibernate.ddl-auto: update
      hibernate.naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
   servlet.multipart.max-file-size: 128KB
   servlet.multipart.max-request-size: 128KB
   http.multipart.enabled: false
   datasource.url: jdbc:mysql://localhost:3306/prueba?useSSL=false
   datasource.driver-class-name: com.mysql.jdbc.Driver
   datasource.username: root
   datasource.password: root

Nuestra entidad Contacto.java. Usaremos la librería lombok para ahorrar escribir código.

package com.codemonkey.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Setter;
import lombok.ToString;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.time.LocalDate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.GenerationType;
import javax.persistence.Table;


@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Table(name="contacto")
@Entity(name="Contacto")
public class Contacto implements java.io.Serializable{
    private static final long serialVersionUID = 7526472295622776147L;
    
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Getter @Setter public int id;
    @Column(name="nombre")
    @Getter @Setter public String nombre;
    @Column(name="telefono")
    @Getter @Setter public String telefono; 
    @Column(name="fecha")
    @Getter @Setter public LocalDate fecha;
}

Ahora un repositorio.
ContactoCrudRepository.java

package com.codemonkey.repository;

import java.util.List;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import com.codemonkey.model.Contacto;

public interface ContactoCrudRepository extends CrudRepository{

    @Query(value="SELECT * FROM contacto ORDER BY id ",nativeQuery=true)
    public List<Contacto> getAllContactos(); 
}

Es necesario notar que dentro de la anotación @Query podemos declarar una consulta SQL nativa. En est caso SELECT * FROM contacto ORDER BY id.

El siguiente paso es declarar un servicio y su implementación.

package com.codemonkey.service;

import java.util.List;
import com.codemonkey.model.Contacto;

public interface ContactoCrudService{
    public List<Contacto> getAllContactos();
}

La implementación de este servicio sería el siguiente:

package com.codemonkey.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;

import com.codemonkey.repository.ContactoCrudRepository;
import com.codemonkey.service.ContactoCrudService;
import com.codemonkey.model.Contacto;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


@Service("contactoCrudService")
public class ContactoCrudServiceImpl implements ContactoCrudService{
    private final Logger LOGGER = LoggerFactory.getLogger(ContactoCrudServiceImpl.class);

    @Autowired
    private ContactoCrudRepository contactoCrudRepository;
    
    @Override
    public List<Contacto&gt getAllContactos(){
        LOGGER.info("--Has entrado a getAllContactos");
        return contactoCrudRepository.getAllContactos();
    }
} 

Creamos el ContactoRestController.java

package com.codemonkey.controller;

//import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import com.codemonkey.model.Contacto;
import com.codemonkey.service.ContactoCrudService;


@RestController
@RequestMapping("/rest")
public class ContactoRestController{

    private final Logger LOGGER = LoggerFactory.getLogger(ContactoRestController.class);
       
    //@Qualifier("contactoService")
    @Autowired
    private ContactoCrudService contactoCrudService;

    //http:localhost:8080/rest/contactosRest
    @GetMapping("/contactosRest")
    public List<Contacto&gt getAllContactos(){
        LOGGER.info("--Has entrado a http://localhost:8080/rest/contactosRest");
        return contactoCrudService.getAllContactos();
    }
}

Ahora una vista. Antes deberíamos aclarar que debemos la importar tres archivos necesarios para trabajar con Vue JS.

<!--Vue JS -->
<script
  src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js">
</script>
<script
  src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.21.1/babel.min.js">
</script>
<!--axios-->
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

contactosVueJS.html

<!DOCTYPE html>
<html lang="es"
      xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
    <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
        <title>Contactos</title>
        <script type="text/javascript" src="/js/funciones.js"></script>
        <link rel="stylesheet" type="text/css" media="all" href="css/estilos.css" th:href="@{css/estilos.css}" />
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css"/>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js"></script>
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js"></script>
  <!--Vue JS -->
<script
  src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js">
</script>
<script
  src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.21.1/babel.min.js">
</script>
<!--axios-->
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

    </head>
    <body>
<div class="jumbotron text-center">
   <h1 align="center" class="bg-dark text-white">Contactos</h1><br/>
   <a href="#" th:href="@{/proyecto/home}" title="regreso">Home</a>
</div>

<div id="my_app">    
    <div class="table-responsive">
        <table class="table table-dark table-striped" style="font-family: Chakra Petch">
            <thead >
                <tr>
                    <th>Nombre</th>
                    <th>Teléfono</th>
                </tr>
            </thead>
            <tbody>
                <tr v-for="data in contactos">
                    <td> <p contenteditable="true">{{ data.nombre }} </p></td>
                    <td><p contenteditable="true">{{ data.telefono }}</p></td>
                    
                </tr>
            </tbody>
        </table></div>

</div>

<script>
var my_app = new Vue({
    el:'#my_app',
    data(){
        return {
            contactos:[]
        };
    },
    methods:{
        getContactos(){
            axios
            .get('http://localhost:8080/rest/contactosRest')
            .then((data) => {
                this.contactos = data.data
            });
        }
    },
    mounted(){
        this.getContactos()
    },
});
</script>
</body>
</html>

En el fragmento de código javascript podemos analizar lo siguiente

//Creamos un objeto tipo Vue y sus atributos, en este caso el id será "my_app"
   var my_app = new Vue({
    el:'#my_app',
    data(){
        return {
            contactos:[]
        };
    },   //Declaramos un método getContactos() que hace una invocación
// al método get(URL) de axios, en esa URL esta nuestro servicio rest
    methods:{
        getContactos(){
            axios
            .get('http://localhost:8080/rest/contactosRest')
            .then((data) => {
                this.contactos = data.data
            });
        }
    },
    mounted(){
        this.getContactos()
    },
});

Dentro del fragmento HTML se puede observar lo siguiente:

<div id="my_app">    
    <div class="table-responsive">
        <table class="table table-dark table-striped" style="font-family: Chakra Petch">
            <thead >
                <tr>
                    <th>Nombre</th>
                    <th>Teléfono</th>
                </tr>
            </thead>
            <tbody>
                <tr v-for="data in contactos">
                    <td> <p contenteditable="true">{{ data.nombre }} </p></td>
                    <td><p contenteditable="true">{{ data.telefono }}</p></td>
                    
                </tr>
            </tbody>
        </table></div>

</div>

En esta parte accedemos a los atributos nombre y telefono:

{{ data.nombre }}
{{ data.telefono }}

¡Feliz código!

Advertisements

Un vistazo a Grails Framework

cropped-hunger-413685_960_7201.jpg

¿Qué es Grails Framework?

  1. Es un framework para desarrollo de aplicaciones web.
  2. Permite usar Java y Groovy.
  3. Funciona bajo el paradigma Modelo-Vista-Controlador.
  4. Se considera la versión de Ruby on Rails de Java.

Si usas SDKMAN! puedes instalarlo así:

$ sdk install grails

Comprobamos la versión instalada:

$ grails -version

Para crear un proyecto tecleamos lo siguiente:

$ grails create-app my-app

Nos colocamos en la carpeta creada:

$ cd my-app

Creamos un controller:

$ grails create-controller com.codemonkey.controller.Hola

La clase creada (Hola.groovy) se encontrará en:

grails-app/controller/com/codemonkey/controller

Hola.groovy

package com.codemonkey.controller

class Hola{

def index(){

render "Hola, amigos !!"

}

}

Para ejecutar la aplicación:

$ grails run-app

Abrimos nuestro navegador en:

http://127.0.0.1:8080/my-app

Por el momento es todo. En posteriores post escribiremos una aplicación más compleja.

Links

http://codigoprogramacion.com/articulos/programacionweb/ique-es-grails-framework-de-desarrollo-web.html#.Wz1_4-ZG3Dc

https://grails.org/

 

 

JPA, ejemplo de anotaciones

Cuando programamos en Java muchas veces tenemos la necesidad de hacer uso de bases de datos. Anteriormente se usaba (aunque algunos lo siguen usando) JDBC. No obstante, el uso de JPA es lo más usual hoy en día.

Imaginemos que tenemos dos tablas Empleado y Departamento con sus respectivos campos. Para enlazar nuestra aplicación no solo es necesario contar con los drivers necesarios para establecer la conexión a las bases de datos (MySQL, Postgresql, Oracle, etc.), también es indispensable establecer la lógica de las entidades.

Empleado dependerá de un Departamento, por ejemplo, Sistemas para los programadores y Contabilidad para los contadores. La entidad Departamento puede tener más de un empleado, pero la entidad Empleado no puede pertenecer a más de un departamento.

¿Cómo podemos crear una relación entre éstas dos entidades?

Para ello tenemos las anotaciones JPA.
@OneToMany , para establecer una relación de uno a muchos. Ideal para Departamento.
@ManyToOne, para establecer una relación de muchos a uno. Para Empleado que sólo puede pertenecer a un departamento.
La anotación @JoinColumn nos servirá para definir la clave externa (la del departamento).

c2cd9-seleccic3b3n_008

Pasemos a la codificación de las entidades.

Tenemos a Empleado.

Empleado.java

package com.codemonkey.model;

import javax.persistence.*;

@Entity
@Table(name="empleado")
public class Empleado implements java.io.Serializable{
  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  @Column(name="idempleado")
  private int idempleado;

  @ManyToOne
  @JoinColumn(name="iddepartamento")
  private Departamento departamento;
  //constructores
  //métodos de acceso
}

@Id, indica la llave primaria

@GeneratedValue(strategy=GenerationType.AUTO), esto índica que la clave será auto incrementable.

@Column, nos sirve para especificar el nombre de la columna en nuestra tabla de información.

Ahora tenemos a Departamento.

Departamento.java

package com.codemonkey.model;

import javax.persistence.*;
import java.util.List;

@Entity
@Table(name="departamento")
public class Departamento implements java.io.Serializable{
  @Id
  @Column(name="iddepartamento")
  private int iddepartamento;

  @OneToMany(mappedBy="departamento")
  private List empleados;
  //constructores
  //métodos de acceso
}

Servicio REST Api con Spring Data

Creamos un Proyecto Nuevo en https://start.spring.io/

Elegiremos Maven para la creación del ejemplo.

Screenshot_1

En la sección SQL elegimos JPA y PostgreSQL.

Screenshot_2

En la sección WEB elegimos Web y Rest Repositories

Screenshot_3

Finalizamos y descargamos el ejemplo. Debe quedar así en nuestro directorio.

Screenshot_4

Abrimos una terminal en el directorio y tecleamos:

mvn clean install

Maven se encargará de descargar las librerías necesarias para el proyecto.

Agregamos plugin para Eclipse IDE

mvn eclipse:eclipse

Ahora abrimos Eclipse e importamos proyecto Maven existente

Screenshot_5

Elegimos nuestro proyecto

Screenshot_6

Revisamos dependencias necesarias en el pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.codemonkey</groupId>
    <artifactId>api-rest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>api-rest-ejemplo</name>
    <description>Uso de API Rest Spring Data</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <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-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope> </dependency> -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project><span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span>

Creamos una tabla alumno.
Screenshot_7

Insertamos valores.

INSERT INTO public.alumno(nombre, apellidos, direccion, telefono, email)
	VALUES ('Zuzanne', 'Waller', 'Tomahawk no. 100', '555-766', 'zuzanewll@gmail.com'),('Yohanan', 'Diaz', 'Toluca, Edo. Mex.', '555-111', 'genaro.amaro@latinmail.com');

Screenshot_8

Creamos clase Alumno.java

package com.codemonkey.entity;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Column;

@Entity
@Table(name="alumno")
public class Alumno implements Serializable{
	private static final long serialVersionUID = 1L;
	@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
	private int id;
	@Column(name = "nombre")
	private String nombre;
	@Column(name = "apellidos")
	private String apellidos;
	@Column(name = "direccion")
	private String direccion;
	@Column(name = "telefono")
	private String telefono;
	@Column(name = "email")
	private String email;

	public Alumno() {}

	public Alumno(int id, String nombre, String apellidos, String direccion, String telefono, String email) {
		super();
		this.id = id;
		this.nombre = nombre;
		this.apellidos = apellidos;
		this.direccion = direccion;
		this.telefono = telefono;
		this.email = email;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getApellidos() {
		return apellidos;
	}

	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}

	public String getDireccion() {
		return direccion;
	}

	public void setDireccion(String direccion) {
		this.direccion = direccion;
	}

	public String getTelefono() {
		return telefono;
	}

	public void setTelefono(String telefono) {
		this.telefono = telefono;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	@Override
	public String toString() {
		return "Alumno [id=" + id + ", nombre=" + nombre + ", apellidos=" + apellidos + ", direccion=" + direccion
				+ ", telefono=" + telefono + ", email=" + email + "]";
	}

}

Creamos un Repositorio de datos

package com.codemonkey.repository;

import org.springframework.data.repository.PagingAndSortingRepository;

import com.codemonkey.entity.Alumno;

public interface AlumnoRepository extends PagingAndSortingRepository<Alumno, Integer>{
}

Clases principales de la aplicación.
ApiRestEjemploApplication.java

package com.codemonkey;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ApiRestEjemploApplication {

	public static void main(String[] args) {
		SpringApplication.run(ApiRestEjemploApplication.class, args);
	}
}

SpringApplicationBuilder.java

package com.codemonkey;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
		return application.sources(ApiRestEjemploApplication.class);
	}

}

application.properties

spring.data.rest.basePath=/api

#MySQL
#spring.datasource.url=jdbc:mysql://localhost:3306/proyecto
#spring.datasource.username=root
#spring.datasource.password=root
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#POSTGRESQL
spring.jpa.generate-ddl=true
spring.jpa.show-sql=true
spring.datasource.driverClassName=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/proyecto
spring.datasource.username=postgres
spring.datasource.password=5432
#spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.hibernate.ddl-auto=update
#spring.jpa.hibernate.ddl-auto=create
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.ImprovedNamingStrategy

# JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect

Ejecutamos la aplicación y abrimos el navegador en la dirección

http://localhost:8080/api/alumnoes

Links:

https://geeks-mexico.com/2018/01/04/crea-un-api-rest-de-la-forma-mas-simple-con-java-y-spring-data-rest/

https://start.spring.io/