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.

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

spring resource file
# 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:

Spring Data JPA
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.
 

Comentarios

  1. Buenos dias consultando por Internet llegue a esta pagina la cual esta muy interesante y quiero saber como conectar mysql con JPA hibernate desde netbeans pero veo tu ejemplo y no veo la configuracin del archivo prueba.xml y el link de descarga del codigo fuente no sirve por favor te agradeceria mucho si lo enviaras a mi cuenta

    ResponderEliminar
    Respuestas
    1. Ya puedes descargar el archivo, he reparado el enlace, gracias por avisarme del error.

      Descargar: https://goo.gl/WH3NTF

      Eliminar
    2. hola, recién lo descargue pero sigue sin estar el xml o clase de configuración que te indicaba vianey vargas. Osea no hay aplicactionContext.xml o clase con las anotaciones haga su función.

      Eliminar
    3. Esta es una aplicación desarrollada con Spring Boot no requieres dicho archivo de configuración, para iniciar el contenedor Spring lo haces de la siguiente manera:

      ApplicationContext context = SpringApplication.run(Application.class);

      Eliminar

Publicar un comentario

Entradas populares de este blog

Conectar SQL Server con Java

Entrenar OpenCV en Detección de Objetos

Procesamiento de imágenes en OpenCV

Conociendo la clase cv::Mat de OpenCV

Acceso a la webcam con OpenCV