API REST 2. Conectarse a Base de Datos MySQL

Descripción

Para publicar y consumir algunos métodos del API REST vamos a crear y conectarnos a una Base de Datos MySQL.

Crear la Base de Datos

Con el siguiente script podemos crear la Base de Datos en MySQL.

-- MySQL dump 10.13  Distrib 5.7.19, for Linux (x86_64)
--
-- Host: localhost    Database: Pruebas
-- ------------------------------------------------------
-- Server version	5.7.19-0ubuntu0.16.04.1

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `Persona`
--

DROP TABLE IF EXISTS `persona`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `persona` (
  `idPersona` int(11) NOT NULL AUTO_INCREMENT,
  `nombre` varchar(200) NOT NULL,
  `edad` int(11) NOT NULL,
  `sexo` char(1) NOT NULL,
  PRIMARY KEY (`idPersona`),
  UNIQUE KEY `idPersona_UNIQUE` (`idPersona`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `Persona`
--
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

-- Dump completed on 2017-08-29 12:27:04

Agregar dependencias

Tomamos el proyecto http://arieloliva.com/api-rest-en-spring/.

En el archivo pom.xml agregamos las dependencias necesarias:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
   <scope>runtime</scope>
</dependency>

Crear archivo Application.properties

En la ruta src/main/resources del proyecto creamos el archivo application.properties. Agregamos los siguientes parámetros de la conexión a la Base de Datos.

spring.jpa.show-sql = true
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/Pruebas
spring.datasource.username=root
spring.datasource.password=root

Crear entity

Un entity es el modelado de una tabla. Nuestra tabla se llama Persona y tiene los campos:

Nombre Tipo Tamaño Null AutoIncrementar
idPersona int 11 no si
nombre varchar 200 no no
edad int 11 no no
sexo char 1 no no

Con estos datos podemos crear la Clase que modela la tabla.

  1. Crear Clase en el paquete hello con nombre Persona
  2. variables privadas idPersona, nombre, edad y sexo con sus respectivos set y get
  3. Anotación @Entity en la Clase para indicar que es un entity.
  4. Anotación @Id y @GeneratedValue(strategy=GenerationType.IDENTITY) en la variable idPersona. para indicar que es el identificador único y se auto genera.

El resultado final es:

package hello;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Persona implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int idPersona;

	private int edad;
	private String nombre;
	private String sexo;

	public Persona() {
	}
	public int getIdPersona() {
		return this.idPersona;
	}
	public void setIdPersona(int idPersona) {
		this.idPersona = idPersona;
	}
	public int getEdad() {
		return this.edad;
	}
	public void setEdad(int edad) {
		this.edad = edad;
	}
	public String getNombre() {
		return this.nombre;
	}
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	public String getSexo() {
		return this.sexo;
	}
	public void setSexo(String sexo) {
		this.sexo = sexo;
	}
}

Crear repositorio

Un repositorio es una interface con los métodos necesarios para acceso a la Base de Datos.

  1. Crear Interface en el paquete hello con nombre PersonaRepository
  2. Extendemos de CrudRepository<Persona, Long>. Crud (Create, Read, Update, Delete). Proporciona todos los métodos para Crear, Leer, Actualizar y Borrar los datos de la tabla.

El resultado final es:

package hello;

import org.springframework.data.repository.CrudRepository;

public interface PersonaRepository extends CrudRepository<Persona, Long>{
		
}

Crear controlador

  1. Crear Clase en el paquete hello con nombre PersonaController
  2. Anotaciones @RestController y @RequestMapping(path=»/persona») en la Clase. Para indicar que que es una API REST y la base del mapeo es /persona.
  3. Variable private PersonaRepository personaRepository con anotación @Autowired la cual obtiene el llamado a PersonaRepository.
  4. Método public Iterable<Persona> getPersona() con la anotación @RequestMapping(«/all») para obtener todos los datos de la tabla persona con el mapeo all.

El resultado final es:

package hello;

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

@RestController
@RequestMapping(path="/persona")
public class PersonaController {
	@Autowired
	private PersonaRepository personaRepository;
	
	@RequestMapping("/all")
	public Iterable<Persona> getPersona() {
        return personaRepository.findAll();
    }
}

Ejecutar aplicación

Después de ejecutar la aplicación el resultado obtenido es:

Otros

Descargar proyecto

Se puede descargar el proyecto completo de https://github.com/arielolivagh/gs-rest-service-complete/tree/v1.0

SpringBoot 6. Configurar JPA y la Base de Datos en Eclipse

Configurar JPA

En http://arieloliva.com/crearbasededatos/ creamos la Base de Datos Kanban. Vamos a conectar eclipse con está para habilitar JPA y crear los modelos.

Agregamos la dependencia JPA en el archivo pom.xml del proyecto.

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

Después habilitamos JPA.

Clic derecho sobre el proyecto -> Propiedades -> Project Facets

Clic en Convert to faceted form…

Habilitar JPA con la versión 2.1. Clic en ApplyOK.

Crear conexión a MySQL

Para crear la conexión a MySQL,

Clic derecho sobre el proyecto -> Propiedades -> JPA -> Connection -> Add connection…

Seleccionar MySQL, elegir un nombre para la conexión y clic en Next.

Clic en el icono New Driver Definition  Elegir el driver 5.1.

Pasarse a la pestaña JAR List, seleccionar el driver mysql-connector-java-5.1.0-bin.jar y clic en Remove JAR/Zip para eliminarlo.

Selección_158
Clic en Add JAR/Zip… Ir a la ruta …/developer/db y seleccionar el archivo mysql-connector-java-5.1.41.jar (Se puede descargar de http://mvnrepository.com/artifact/mysql/mysql-connector-java/5.1.41 ). Clic en OK.

Escribir los datos de la Base de Datos MySQL.

Database kanban
URL jdbc:mysql://localhost:3306/kanban
User name root
Password El seleccionado en la instalación

Clic en Test Connection para validar que la conexión es correcta. Clic en OK.

Selección_161
Clic en Next >,  en Finish y en OK.

Validar la conexión a MySQL

Sobre Eclipse en la pestaña Data Source Explorer se muestra la conexión recién creada. Clic con el botón derecho y Connect.

Introducir la contraseña y OK.


Podemos ver las tablas de la Base de Datos de MySQL.

 

 

SpringBoot 4. Crear Base de Datos

La Base de Datos la vamos a crear en MySQL. Si no tiene instalado MySQL se puede apoyar en la liga http://arieloliva.com/java-ee-3-instalar-base-de-datos-mysql . Aquí también se explica como instalar MySQL Workbench. Con MySQL Workbench podemos generar una Base de Datos mediante un modelo. Se puede utilizar cualquier otra herramienta para crear la Base de Datos en MySQL o solo ejecutar el script al final de esta entrada.

Crear modelo en MySQL Workbench

Abrimos MySQL Workbench y seleccionamos la instancia local.

Selección_153

Pedirá la contraseña de root.

Selección_154

Entramos a la pantalla principal. Clic en File -> New Model.

Selección_155

Con + crea un nuevo esquema y con lo eliminamos. Creamos el esquema kanban. Sólo escribimos el Name, los demás parámetros se dejan predeterminados. Doble Clic en Add Diagram.

Crear las tablas y sus relaciones

Aquí ya podemos agregar las tablas de la Base de Datos. Damos clic en Place a New Table. y con otro clic sobre el espacio de trabajo se creara la tabla.

Selección_175

Doble clic en la tabla y se mostraran su propiedades en la parte inferior. Seleccionamos el nombre Columns. (Lo mas recomendable es que el nombre de una tabla sea en singular, pero Column es una palabra reservada de la Base de Datos)

Y en la pestaña Columns agregamos los campos id y titulo.

Nombre Tipo de dato PK(Primary Key) NN (No Null) UQ (Unique Key) AI(Autoincrementar)
id INT Si Si Si Si
titulo VARCHAR(100) No Si No No

 

Ahora creamos la tabla Article  con los campos id, nombre, titulo y descripcion.

Nombre Tipo de dato PK NN UQ AI
id INT Si Si Si Si
nombre VARCHAR(100) No Si No No
titulo VARCHAR(100) No Si No No
descripcion VARCHAR(250) No No No No

Relacionamos la tablas de 1 a muchos. Damos clic en Place a New 1:n Non-Identifying.

Selección_167

Clic en la tabla Article y luego clic en la tabla Columns.

Generar Base de Datos

Ya tenemos nuestro modelo ahora vamos a crear la Base de Datos; Database -> Forward Engineer… Seleccionamos la instancia Local y la contraseña. Clic en Next.

Selección_169

Todo predeterminado y clic en Next.

Selección_170

Debe estar habilitado Export MySQL Table Object. Clic en Next.

Selección_171

Se muestra el script de creación. Clic en Next.

Clic en Close.

Selección_173

Desde la pestaña de la instancia actualizamos los esquemas, seleccionamos kanban  y ejecutamos los querys:

select * from Columns;
select * from Article;

En la parte inferior se debe mostrar que las consultas fueron exitosas, indicando que las tablas ya existen.

Introducir datos

Introducimos datos en las tablas. Doble clic en la celda -> Teclear datos-> Clic en Apply -> Confirmar consultas. El id es unico no se puede repetir.

Para el caso de la tabla Article. El campo Columns_id debe coincidir con un id de un Columns, si no es así se muestra un error de foreign key.

Script para crear la Base de Datos

Por si solo quieres ejecutar el script y ahorrarte toda las creación del modelo.

-- MySQL Workbench Forward Engineering

SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL,ALLOW_INVALID_DATES';

-- -----------------------------------------------------
-- Schema kanban
-- -----------------------------------------------------
CREATE SCHEMA IF NOT EXISTS `kanban` DEFAULT CHARACTER SET latin1 ;
USE `kanban` ;

-- -----------------------------------------------------
-- Table `kanban`.`Columns`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `kanban`.`Columns` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `titulo` VARCHAR(100) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `id_UNIQUE` (`id` ASC))
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;


-- -----------------------------------------------------
-- Table `kanban`.`Article`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `kanban`.`Article` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `nombre` VARCHAR(100) NOT NULL,
  `titulo` VARCHAR(100) NOT NULL,
  `descripcion` VARCHAR(250) NULL DEFAULT NULL,
  `ColumnId` INT(11) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `id_UNIQUE` (`id` ASC),
  INDEX `fk_Article_Column_idx` (`ColumnId` ASC),
  CONSTRAINT `fk_Article_Column`
    FOREIGN KEY (`ColumnId`)
    REFERENCES `kanban`.`Columns` (`id`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;


SET SQL_MODE=@OLD_SQL_MODE;
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;

 

Java EE 6. Conectar Eclipse con MySQL

Configurar JPA

Clic con el botón derecho sobre el proyecto y seleccionar Propiedades. Clic en Project Facets. Asegurarse que este habilitado JPA y tiene seleccionado la versión 2.1.

Selección_154

Conectar con MySQL

En la misma ventana de propiedades, seleccionar JPA y en la sección de Connection clic en Add connection..
Selección_153
Seleccionar MySQL, elegir un nombre para la conección y clic en Next >.

Selección_155
Clic en el icono New Driver Definition.

Selección_156Elegir el driver 5.1.

Selección_157

Pasarse a la pestaña JAR List, seleccionar el driver mysql-connector-java-5.1.0-bin.jar y clic en Remove JAR/Zip para eliminarlo.

Selección_158
Clic en Add JAR/Zip... Ir a la ruta …/developer/db y seleccionar el archivo mysql-connector-java-5.1.38.jar (Se descargo el jar en el articulo http://arieloliva.com/configurar_proyecto/ en la sección «Dependencia para MySQL»). Clic en OK.

Selección_159
Escribir los datos de la Base de Datos MySQL.

Database mydb
URL jdbc:mysql://localhost:3306/mydb
User name root
Password El seleccionado en la instalación

Selección_160

Clic en Test Connection para validar que la conección es correcta.

Selección_161
Clic en Next > y  en Finish.

Validar la conección a MySQL

Sobre Eclipse en la pestaña Data Source Explorer se muestra la conección recién creada. Clic con el botón derecho y Connect.

Selección_163

Introducir la contraseña y OK.

Selección_164
Podemos ver las tablas de la Base de Datos de MySQL.

Selección_165

Java EE 5. Crear Base de Datos MySQL

Vamos a crear una Base de Datos muy sencilla para continuar con el desarrollo JEE.

Crear modelo en MySQL Workbench

Abrimos MySQL Workbench y seleccionamos la instancia local.

Selección_153

Pedirá la contraseña que seleccionamos en la instalación pasada.

Selección_154

En la pantalla principal ir a File -> New Model.

Selección_155

Doble Clic en Add Diagram.

Selección_156

Crear las tablas y sus relaciones

Aquí ya podemos agregar las tablas de la Base de Datos. Damos clic en Place a New Table. y con otro clic sobre el espacio de trabajo se creara la tabla.

Selección_175

Doble clic en la tabla y se mostraran su propiedades en la parte inferior. Seleccionamos el nombre Usuarios.

Selección_159

Y en la pestaña Columns agregamos los campos id, user y password.

Nombre Tipo de dato Clave primaria No acepta null
id INT Si Si
user VARCHAR(10) No No
password VARCHAR(10) No No

Selección_164

Ahora creamos la tabla Logins_users.

Nombre Tipo de dato Clave primaria No acepta null
id INT Si Si
date DATETIME No No
status VARCHAR(5) No No

Selección_166

Relacionamos la tablas de 1 a muchos. Damos clic en Place a New 1:n Non-Identifying.

Selección_167

Clic en la tabla Logins_users y finalmente clic en la tabla Users.

Selección_168

Generar Base de Datos

Ya tenemos nuestro modelo ahora vamos a crear la Base de Datos; Database -> Forward Engineer… Seleccionamos la instancia Local y la contraseña. Clic en Next.

Selección_169

Todo predeterminado y clic en Next.

Selección_170

Debe estar habilitado Export MySQL Table Object. Clic en Next.

Selección_171

Se muestra el script de creación. Clic en Next.

Selección_172

Clic en Close.

Selección_173

Desde la pestaña de la instancia seleccionamos el esquema mydb  y ejecutamos los querys:

select * from Users;
select * from Logins_users;

En la parte inferior se debe mostrar que las consultas fueron exitosas, indicando que las tablas ya existen.

Selección_174

 

Java EE 3. Instalar Base de Datos MySQL

Antecedentes

Para el proyecto vamos a utilizar la base de datos MySQL y MySQL workbench, que es una herramienta visual para el diseño de Base de Datos de MySQL.

Instalación de MySQL

Ir al link http://dev.mysql.com/downloads/mysql/  y descargar la versión correspondiente al Sistema Operativo y la arquitectura del procesador.

Para la instalación en Ubuntu, que es mi caso, lo más convenientes es instalarlo por apt.

  1. Descargar mysql-apt-config_x.x.x-x_all.deb desde el link http://dev.mysql.com/downloads/repo/apt/
  2. Ejecutarlo mediante linea de comandos:
    sudo dpkg -i mysql-apt-config_0.6.0-1_all.deb

    apt

  3. Seleccionar MySQL Server (mysql-5.7) y clic en Adelante.apt3
  4. Seleccionar mysql-5.7 y clic en Adelante. Finalmente selecciona aplicar para que se instale.apt3
  5.  Desde la consola ejecute:
    sudo apt-get install mysql-server

    Capture S.

    apt4

  6. Seleccione la contraseña para el usuario root.apt5
  7. Confirme la contraseña para el usuario root..apt6
  8. Después de unos momentos se instala la Base de Datos.apt7
  9. Para probar que MySQL se esta ejecutando correctamente podemos ejecutar:
    sudo service mysql status

    apt8Otro comando útiles son:

    sudo service mysql stop
    
    sudo service mysql start

Instalación de MySQL Workbench

Ir al link http://dev.mysql.com/downloads/workbench/  y descargar la versión correspondiente al Sistema Operativo y la arquitectura del procesador.

  1. Para el caso de Ubuntu se descargar el archivo mysql-workbench-community-6.3.6-1ubu1404-amd64.deb. Clic en el archivo para ejecutarlo. Desde el Centro de software de Ubuntu clic en instalar.apt9
  2. Después de unos momentos se mostrara que la instalación fue correcta.apt10
  3. Al ejecutar la aplicación reciente instalada nos muestra la siguiente ventana. Aquí se ve la instancia del servidor MySQL que acabamos de instalar.apt11
  4. Al dar clic sobre la instancia nos pedirá la contraseña del root y entraremos a la pantalla principal de MySQL Workbench.apt12