Aplicación Spring Boot en Heroku. Instalación y Configuración II

#spring-boot

En el post anterior vimos como podemos tener nuestra API levantada en un servidor web gratuito. Para completarla necesitaremos una BBDD donde almacenar la información de nuestra API. Para la BBDD haremos uso también de la web de Heroku, ya que esta nos proporciona un servicio de base de datos a la que poder acceder de manera remota.

Primero de todo añadiremos la base de datos a nuestra API en Heroku. Esto es bastante sencillo ya que únicamente es necesario añadir un addon a nuestra aplicación en Heroku. Nos posicionaremos en la ruta de nuestra API en nuestra máquina y ejecutaremos el siguiente comando:

C:\\\\Users\\\\javier\\\\.. heroku addons:create heroku-postgresql:hobby-dev
Creating heroku-postgresql:hobby-dev on api... free
Database has been created and is available
   ! This database is empty. If upgrading, you can transfer
   ! data from another database with pg:copy
Created postgresql-defined-12345 as DATABASE_URL
Use heroku addons:docs heroku-postgresql to view documentation

El comando nos confirmará que se ha generado la base de datos para nuestra API y nos proporcionará el nombre de la base de datos generada postgresql-defined-12345. Podremos comprobar también que se ha añadido correctamente ejecutando el siguiente comando sobre la ruta de nuestro proyecto:

C:\\\\Users\\\\javier.. heroku addons
Add-on                                        Plan       Price  State
heroku-postgresql (postgresql-defined-12345)  hobby-dev  free   created                  as DATABASE

Una vez hayamos asociado a nuestra aplicación la base de datos Postgre, pasaremos a instalar en nuestra máquina la herramienta para poder acceder a la misma. En este caso utilizaremos OmniDB para lo que nos descargaremos de la siguiente URL el instalador (.exe).

El instalador nos solicitará la ruta donde se instalará y si queremos que se genere un acceso directo en el escritorio.

Cuando iniciemos la aplicación, se nos abrirá una ventana como la siguiente:

Para conectarnos a la base de datos, necesitaremos los datos de conexión para lo que deberemos acceder a nuestra cuenta en Heroku y acceder a la información de nuestra API donde encontraremos un enlace al addon de Postgre en la pestaña “Overview”. En la ventana que se nos abrirá podremos obtener dicha información en la sección Settings > Database Credentials:

Con los datos, desde la aplicación OmniDB accederemos al menú “Connections” de la barra superior de la ventana:

Pulsando el botón “New Connection” nos generará un nuevo registro en la tabla, en el que deberemos informar el campo “Connection String” con el valor “URI” de nuestras credenciales de Heroku. Pulsando el tick verde del campo “Actions”, nos conectaremos a la BBDD:

Automáticamente nos abrirá una ventana para poder lanzar queries contra la base de datos:

De momento para ver un ejemplo sencillo generaremos una tabla de usuarios:

CREATE TABLE TABLE_USER(
   OBJID SERIAL PRIMARY KEY,
   NAME VARCHAR(30),
   LAST_NAME VARCHAR(100),
   USER_NAME VARCHAR(50),
   PASSWORD VARCHAR(50),
   EMAIL VARCHAR(355),
   CREATE_DATE DATE,
   LAST_LOGIN_DT DATE
);

Una vez generada la tabla insertaremos un usuario de prueba:

INSERT INTO TABLE_USER(NAME, LAST_NAME, USER_NAME, PASSWORD, EMAIL, CREATE_DATE)
VALUES('Javier','Gonzalez','javibod','temporal01','temporal@gmail.com', current_date)

Y al consultar la tabla deberíamos obtener el usuario:

En este punto tendremos nuestra base de datos de Postgre con una tabla disponible a la que podremos acceder. El siguiente paso será configurar nuestra API para acceder a la base de datos, obtener dichos datos y devolverlos.

Para esto comprobaremos que en el fichero pom.xml de nuestro proyecto se encuentran las dependencias que gestionará Maven y que añadimos en la creación del mismo con Spring Initialzr de Postgre y JPA:

<dependency>
   <groupId>org.postgresql</groupId>
   <artifactId>postgresql</artifactId>
   <scope>runtime</scope>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
<dependency>

Con estas dos dependencias añadidas en nuestro proyecto podremos configurar la conexión desde nuestra API a la base de datos. Esto se realizará desde el fichero “application/properties” dentro de la ruta “/src/main/resources”:

spring.datasource.hikari.connectionTimeout=20000
spring.datasource.hikari.maximumPoolSize=5

spring.datasource.url=${DATABASE_URI}
spring.datasource.username=${DATABASE_USERNAME}
spring.datasource.password=${DATABASE_PASSWORD}

spring.jpa.show-sql=true

Donde los literales DATABASE_URI, DATABASE_USERNAME y DATABASE_PASSWORD corresponden a los valores 'jdbc:postgresql://HOST:PORT/DATABASE', USER y PASSWORD de nuestras credenciales en Heroku.

Para comprobar que la conexión se realiza correctamente podremos lanzar el proyecto y comprobar que no se produce ningún error.

Con la configuración pasaremos a generar la estructura de clases para recoger los datos de la base de datos generada en Heroku. El código de la misma se compondría de las siguientes clases:

UserController.java 

@Controller
@RequestMapping('/user')
public class UserController {

   @Autowired
   private IApplicationUserService userService;

   @GetMapping('')
   @ResponseBody
   public ResponseEntity<List<ApplicationUser>> getUsers() {
      return new ResponseEntity<>(userService.getAllUsers(),HttpStatus.OK);
   }

   @ModelAttribute
   public void setResponseHeader(HttpServletResponse response) {
      response.setHeader('Access-Control-Allow-Origin', '*');
   }

}

ApplicationUser.java

@Entity
@Table(name='table_user')
public class ApplicationUser{

   @Id
   @GeneratedValue(strategy=GenerationType.IDENTITY)
   private int objid;
   private String name;
   @Column(name = 'last_name', nullable = false)
   private String lastName;
   @Column(name = 'user_name', nullable = false)
   private String username;
   private String password;
   private String email;
   @Column(name = 'create_date', nullable = false)
   @JsonFormat(pattern='yyyy-MM-dd')
   private LocalDate createDate;
   @Column(name = 'last_login_dt', nullable = true)
   @JsonFormat(pattern='yyyy-MM-dd')
   private LocalDate lastLoginDt;

 ... getters and setters ... 

}

ApplicationUserRepository.java

public interface ApplicationUserRepository extends JpaRepository<ApplicationUser,Integer>{}

IApplicationUserService.java

public interface IApplicationUserService {

   public List<ApplicationUser> getAllUsers();

}

ApplicationUserServiceImpl.java

@Service
public class ApplicationUserServiceImpl implements IApplicationUserService{

   @Autowired
   private ApplicationUserRepository usersRepository;

   @Override
   public List getAllUsers() {
      return usersRepository.findAll();
   }

}

Con la estructura de clases de nuestra API, podremos lanzar el proyecto y acceder a la URL definida en el controlador desde el navegador. El resultado debería ser el siguiente:

Como podemos comprobar hemos obtenido en formato JSON el contenido de nuestra tabla de base de datos.

En el próximo post explicaré la estructura de clases que hemos generado para la API con Spring.

Etiquetas

#spring-boot