Acceso a Base de Datos MySql con Spring JPA-Hibernate

Spring Framework provee varios métodos de acceso a datos, a diversos tipos de bases de datos y muchas maneras de administrarlos de una manera sencilla, veremos a continuación el acceso a datos mediante JPA a una base de datos MySQL utilizando Hibernate.

 

Primero requerimos crear el proyecto, lo hacemos como hemos aprendido en tutoriales anteriores, como siempre debemos modificar el archivo pom.xml para que contenga la dependencias y configuraciones requeridas por nuestro proyecto, agregando las dependencias para JPA y MySql nuestro pom.xml debe ser este:

 

<?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>tutor.programacion</groupId>
    <artifactId>DatosMySql</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.2.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

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

Configurar Origen de Datos MySql

Para indicarle a Spring Framework como accederemos a la base de datos necesitamos crear un archivo de configuración, el mismo debe tener el siguiente nombre: application.properties y debe estar ubicado en: src/main/resources

 

Para crearlo, si usas Netbeans 8.x puedes hacer lo siguiente, agregar un archivo de propiedades al proyecto con el nombre y la ruta indicadas.

Al finalizar debemos tener la siguiente estructura de proyecto, procedemos a editar el archivo que acabamos de crear.

# Configurar la coneccion a la base de datos
spring.datasource.url = jdbc:mysql://localhost:3306/datos
spring.datasource.username = usuario
spring.datasource.password = contrasenia
spring.datasource.driverClassName = com.mysql.jdbc.Driver

# Indicar el DBMS
spring.jpa.database: MYSQL

# Indica si debe mostrar el log de las consultas sql ejecutadas
# Bueno a la hora de depurar 
spring.jpa.show-sql: true

# Configurar Hibernate
spring.jpa.hibernate.ddl-auto: update
spring.jpa.hibernate.dialect: org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy

 

Como lo indica la url de conexión accederemos a una base de datos MySql llamada datos, la misma debe existir y el servidor debe estar ejecutándose y aceptando conexiones en el puerto 3306 para poder correr la aplicación, también debemos recordar cambiar el nombre de usuario y contraseña correspondiente. 

 

Crear una Entidad JPA

 

Una entidad (Usuario) es una clase que vamos a persistir en una base de datos, haciendo una relación con una base de datos relacional una entidad sería una tabla, usamos las correspondientes anotaciones para crear la entidad, no las explicare pues este no es un tutorial de JPA.

 

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

@Entity
public class Usuario implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String nombre;
    private String apellido;
    private Integer edad;
    //...

 

Lo siguiente que necesitamos es el acceso a la entidad queremos poder eliminar, crear, editar y buscar elementos en nuestro conjunto de datos, Spring provee mecanismos para crear repositorios de manera rápida y sencilla, usando la interface CrudRepository.

 

import java.util.List;
import org.springframework.data.repository.CrudRepository;

public interface UsuarioRepository extends CrudRepository<Usuario, Long> {

    List<Usuario> findByApellido(String apellido);

    List<Usuario> findByEdadLessThan(Integer edad);

}

 

Spring Data JPA nos da la facilidad de no tener que implementar la interface, en tiempo de ejecución se reconocen los métodos y se implementan, solo debemos indicar a la interface CrudRepository<Entidad, ID>, el tipo de la entidad que usaremos y el tipo del campo id, CrudRepository<Usuario, Long>, también podemos ver dos métodos findByApellido, findByEdadLessThan, Spring detecta los mismos y los convierte en consultas, puedes aprender mas en la documentación oficial Spring Data JPA.

 

Agregamos la clase principal con la que podremos crear, eliminar, editar y buscar usuarios en la base de datos MySql mediante la clase UsuarioRepository que acabamos de crear. 

 

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
public class Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(Application.class);
        UsuarioRepository repository = context.getBean(UsuarioRepository.class);

        // Guardar un conjunto de usuarios
        repository.save(new Usuario("Juan", "Perez", 25));
        repository.save(new Usuario("Maria", "Lozz", 15));
        repository.save(new Usuario("Lina", "Ruixs", 23));
        repository.save(new Usuario("Dania", "Mars", 20));

        // findAll heredado de la interface CrudRepository
        Iterable<Usuario> todos = repository.findAll();
        System.out.println("Listar todos los Usuarios:");
        for (Usuario usr : todos) {
            System.out.println("\t" + usr);
        }
        System.out.println();

        // findByEdadLessThan devuelve todos los usuarios con edades menores a la indicada
        Iterable<Usuario> edades = repository.findByEdadLessThan(21);
        System.out.println("Usuarios con edad menor a 21");
        for (Usuario usr : edades) {
            System.out.println("\t" + usr);
        }
        System.out.println();

        context.close();
    }
}

Al correr la aplicación veremos en la consola de salida lo siguiente:

He modificado el archivo de configuración application.properties para indicarle a Hibernate que en cada ejecución de la aplicación elimine la tabla de datos, esto mediante: spring.jpa.hibernate.ddl-auto: create-drop, si deseamos que los datos se guarden de forma permanente cambiamos create-drop por update, solo debemos tener en cuenta que para este ejemplo los datos se guardan cada vez que ejecuta la aplicación por lo que tendríamos los mismos datos varias veces.

 

• Descargar código: Descargar Proyecto Java
• Más tutoriales: Acceso a datos con Spring