Introducción a Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD (parte 3)

Buenas tardes. En este artículo me gustaría compartir mi primer encuentro con cosas como Maven, Spring, Hibernate, MySQL y Tomcat en el proceso de creación de una aplicación CRUD simple. Esta es la tercera parte de 4. El artículo está destinado principalmente a aquellos que ya han completado entre 30 y 40 niveles aquí, pero aún no se han aventurado más allá de Java puro y recién están comenzando (o están a punto de comenzar) a ingresar al mundo abierto con todas estas tecnologías, marcos y otras palabras desconocidas. Esta es la tercera parte del artículo "Introducción a Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD". Las partes anteriores se pueden ver siguiendo los enlaces:

• Introducción a Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD (parte 1)
• Introducción a Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD (parte 2)

Contenido:

• Crear y conectar una base de datos
• ORM y APP
• Entidad
• Propiedades de hibernación
• Configuración de hibernación
• Capa de acceso a datos

Crear y conectar una base de datos

Bueno, es hora de empezar a trabajar en la base de datos. Antes de conectar Hibernate y pensar en cómo debería funcionar todo allí, primero veamos la base de datos en sí, es decir. Creémoslo, conectémoslo, hagámoslo y completemos el cartel. Usaremos el DBMS (Sistema de gestión de bases de datos) MySQL (por supuesto, primero debes descargarlo e instalarlo). SQL (lenguaje de consulta estructurado) es un lenguaje de programación declarativo que se utiliza para crear, modificar y manipular datos en una base de datos relacional. En dichas bases de datos, los datos se almacenan en forma de tablas. ¿Cómo se comunica la aplicación con la base de datos (transmitiendo consultas SQL a la base de datos y devolviendo resultados)? Para esto, Java tiene algo como JDBC (Java DataBase Connectivity) , que, en pocas palabras, es un conjunto de interfaces y clases para trabajar con bases de datos. Para interactuar con la base de datos es necesario crear una conexión, para ello el paquete java.sqltiene una clase Connection. Hay varias formas de establecer una conexión, por ejemplo puedes utilizar el método getConnectionde clase DriverManager. Sin embargo, la interacción con la base de datos no se realiza directamente, porque existen muchas bases de datos y son diferentes. Así, para cada uno de ellos existe su propio controlador JDBC, mediante el cual se establece una conexión con la base de datos. Por tanto, antes que nada, para no distraernos con esto más adelante, instalemos el controlador MySQL . Agreguemos la pom.xmlsiguiente dependencia:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

Ahora creemos la base de datos. Ver -> Ventanas de herramientas -> Base de datos : se abrirá el panel de la base de datos. Nuevo (verde +) -> Fuente de datos -> MySQL : se abrirá una ventana en la que deberá especificar el nombre de usuario y la contraseña, los configuramos al instalar MySQL (por ejemplo, usé root y root). Puerto (predeterminado para MySQL 3306), nombre, etc. déjalo como está. Puede probar la conexión usando el botón " Probar conexión ". Haga clic en Aceptar y ahora estamos conectados al servidor MySQL. A continuación, creemos una base de datos. Para hacer esto, puedes escribir un script en la consola que se abre:

CREATE DATABASE test

Haga clic en Ejecutar y la base de datos está lista, ahora puede conectarla, para hacer esto regrese a Propiedades de la fuente de datos e ingrese el nombre de la base de datos (prueba) en el campo Base de datos, luego ingrese el nombre de usuario y contraseña nuevamente y haga clic en Aceptar. Ahora necesitamos hacer una mesa. Puedes usar herramientas gráficas, pero por primera vez, probablemente valga la pena escribir un script a mano para ver cómo se ve:

USE test;

CREATE TABLE films
(
  id int(10) PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(100) NOT NULL,
  year int(4),
  genre VARCHAR(20),
  watched BIT DEFAULT false  NOT NULL
)
COLLATE='utf8_general_ci';
CREATE UNIQUE INDEX films_title_uindex ON films (title);

INSERT INTO `films` (`title`,`year`,`genre`, watched)
VALUES
  ("Inception", 2010, "sci-fi", 1),
  ("The Lord of the Rings: The Fellowship of the Ring", 2001, "fantasy", 1),
  ("Tag", 2018, "comedy", 0),
  ("Gunfight at the O.K. Corral", 1957, "western", 0),
  ("Die Hard", 1988, "action", 1);

Se crea una tabla con el nombre filmscon columnas id, titleetc. Para cada columna, se indica el tipo (tamaño máximo de salida entre paréntesis).

• PRIMARY KEY- esta es la clave principal, utilizada para identificar de forma única un registro en la tabla (lo que implica unicidad)
• AUTO_INCREMENT— el valor se generará automáticamente (por supuesto, será distinto de cero, por lo que no es necesario especificarlo)
• NOT NULL- aquí también todo es obvio, no puede estar vacío
• DEFAULT— establecer el valor predeterminado
• COLLATE- codificación
• CREATE UNIQUE INDEX— hacer que el campo sea único
• INSERT INTO— agregar un registro a la tabla

El resultado es una señal como esta: Quizás valga la pena intentar conectarse a él, sólo por ahora, por separado de nuestra aplicación web. ¿Qué pasa si surgen algunos problemas con esto? Lo solucionaremos de inmediato. De lo contrario, luego conectaremos Hibernate , haremos algo, configuraremos, retocaremos y, si nos equivocamos en alguna parte, al menos sabremos que el problema no está aquí. Bueno, para verificar la conexión, creemos un método main, temporalmente. En principio, puedes ponerlo en cualquier lugar, incluso en la clase de controlador, incluso en el modelo o configuración, no importa, solo necesitas usarlo para asegurarte de que todo está bien con la conexión y puedes eliminarlo. Pero para ser más cuidadosos, creemos una clase separada para ello Main:

package testgroup.filmography;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "root";
        System.out.println("Connecting...");

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            System.out.println("Connection successful!");
        } catch (SQLException e) {
            System.out.println("Connection failed!");
            e.printStackTrace();
        }
    }
}

Aquí todo es simple, configuramos los parámetros de conexión a nuestra base de datos e intentamos crear una conexión. Lancemos este mainy echemos un vistazo. Entonces, obtuve una excepción, algunos problemas de zona horaria y alguna otra advertencia sobre SSL. Después de navegar por Internet, puede descubrir que este es un problema bastante común y que, cuando se utilizan diferentes versiones del controlador (mysql-connector-java), puede ser diferente. Por ejemplo, descubrí experimentalmente que cuando uso la versión 5.1.47 no hay excepciones debido a la zona horaria, la conexión se crea normalmente, pero aún aparece la advertencia SSL. Con algunas otras versiones parecía que había una excepción con respecto a SSL, y no sólo una advertencia. Vale, ese no es el punto. Puede intentar solucionar este problema por separado, pero no lo abordaremos ahora. La solución a esto es bastante simple, es necesario especificar parámetros adicionales en la URL , es decir serverTimezone, si el problema es con la zona horaria y useSSLsi el problema es con SSL:

String url = "jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false";

Ahora hemos configurado la zona horaria y desactivado SSL. Lo lanzamos nuevamente mainy listo - ¡Conexión exitosa! Bueno, genial, descubrimos cómo crear una conexión. La clase Mainbásicamente ha completado su tarea, puedes eliminarla.

ORM y APP

En el buen sentido, para una mejor comprensión, es mejor empezar a familiarizarse con las bases de datos en orden, desde el principio, sin hibernaciones ni otras cosas. Por lo tanto, sería una buena idea buscar algunas guías y primero intentar trabajar con clases JDBC, escribir consultas SQL manualmente, etc. Bueno, pasemos ahora mismo al modelo ORM . ¿Qué quiere decir esto? Por supuesto, es recomendable leer sobre esto por separado, pero intentaré describirlo brevemente. ORM (Mapeo relacional de objetos o mapeo relacional de objetos) es una tecnología para mapear objetos en estructuras de bases de datos relacionales, es decir. para representar nuestro objeto Java como una fila de la tabla. Gracias a ORM, no tiene que preocuparse por escribir scripts SQL y concentrarse en trabajar con objetos. Cómo usarlo. Java tiene otra gran cosa, JPA (Java Persistence API), que implementa el concepto ORM. JPA es una especificación de este tipo; describe los requisitos para los objetos, define varias interfaces y anotaciones para trabajar con la base de datos. JPA es esencialmente una descripción, un estándar. Por lo tanto, existen muchas implementaciones específicas, una de las cuales (y una de las más populares) es Hibernate, que es la esencia de este marco. Hibernate es una implementación de la especificación JPA diseñada para resolver problemas de mapeo relacional de objetos (ORM). Necesitamos conectar todo esto con nuestro proyecto. Además, para que nuestro Spring no se quede al margen y también participe en todo este movimiento con las bases de datos, necesitamos conectar un par de módulos más, porque Todo lo que obtuvimos de la dependencia spring-webmvc ya no es suficiente para esto. También necesitaremos spring-jdbc para trabajar con la base de datos, spring-tx para admitir transacciones y spring-orm para trabajar con Hibernate. Agreguemos dependencias a pom.xml:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.1.1.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.3.7.Final</version>
</dependency>

Estas dos dependencias son suficientes. javax.persistence-apiLlegará junto con hibernate-core y spring-jdbc y spring-tx junto con spring-orm .

Entidad

Por eso queremos que los objetos de clase se Filmpuedan almacenar en la base de datos. Para ello, la clase debe cumplir una serie de condiciones. En JPA existe una Entidad para esto . Una clase de entidad es una clase POJO ordinaria , con campos privados y captadores y definidores para ellos. Debe tener un constructor no privado sin parámetros (o un constructor predeterminado) y debe tener una clave primaria, es decir. algo que identificará de forma única cada registro de esta clase en la base de datos. También puede leer sobre todos los requisitos para dicha clase por separado. Hagamos de nuestra clase Filmuna entidad usando anotaciones JPA:

package testgroup.filmography.model;

import javax.persistence.*;

@Entity
@Table(name = "films")
public class Film {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "title")
    private String title;

    @Column(name = "year")
    private int year;

    @Column(name = "genre")
    private String genre;

    @Column(name = "watched")
    private boolean watched;

    // + getters and setters
}

• @Entity- indica que esta clase es una entidad.
• @Table- apunta a una tabla específica para mostrar esta entidad.
• @Id— indica que este campo es una clave primaria, es decir esta propiedad se utilizará para identificar cada entrada única.
• @Column— conecta un campo a una columna de la tabla. Si los nombres de los campos y las columnas de la tabla son iguales, puede omitirlos.
• @GeneratedValue— la propiedad se generará automáticamente; puede especificar cómo entre paréntesis. Ahora no entenderemos cómo funcionan exactamente las diferentes estrategias. Basta saber que en este caso cada nuevo valor aumentará en 1 respecto al anterior.

Para cada propiedad, puede especificar además muchas otras cosas, por ejemplo, qué debe ser distinto de cero o único, especificar el valor predeterminado, el tamaño máximo, etc. Esto será útil si necesita generar una tabla basada en esta clase; Hibernate tiene esta opción. Pero ya hemos creado la tabla nosotros mismos y configurado todas las propiedades, por lo que podemos prescindir de ella. Una pequeña nota.La documentación de Hibernate recomienda utilizar anotaciones no en los campos, sino en los captadores. Sin embargo, la diferencia entre estos enfoques es bastante sutil y en nuestra aplicación simple esto no tendrá ningún efecto. Además, la mayoría de la gente pone anotaciones encima de los campos de todos modos. Por tanto, dejémoslo así, se ve más prolijo.

Propiedades de hibernación

Bueno, comencemos a configurar nuestro Hibernate. Y antes que nada, coloquemos cierta información, como nombre de usuario y contraseña, URL y algo más en un archivo separado. Por supuesto, puede especificarlos como una línea normal directamente en la clase, como hicimos cuando verificamos la conexión ( String username = "root";y luego la pasamos al método para crear la conexión). Pero aún es más correcto almacenar dichos datos estáticos en algún propertyarchivo. Y si, por ejemplo, necesita cambiar la base de datos, entonces no tendrá que revisar todas las clases y buscar dónde se usa, bastará con cambiar el valor en este archivo una vez. Creemos un archivo db.properties en el directorio de recursos :

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false
jdbc.username=root
jdbc.password=root

hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
hibernate.show_sql=true

Bueno, desde arriba todo está claro, parámetros para conectarse a la base de datos, es decir. nombre de clase del conductor, URL, nombre de usuario y contraseña. hibernate.dialect- esta propiedad es necesaria para indicar a Hibernate qué versión particular del lenguaje SQL se utiliza. El caso es que en todo DBMS, para ampliar capacidades, agregar alguna funcionalidad u optimizar algo, suelen modernizar ligeramente el lenguaje. Como resultado, resulta que cada DBMS tiene su propio dialecto SQL. Es como con el inglés, parece que el idioma es el mismo, pero en Australia, Estados Unidos o Gran Bretaña será ligeramente diferente y algunas palabras pueden tener significados diferentes. Y para evitar problemas de comprensión, debe decirle directamente a Hibernate con qué tiene que lidiar exactamente. hibernate.show_sql— gracias a esta propiedad, las consultas a la base de datos se mostrarán en la consola. Esto no es necesario, pero con esto al menos puedes ver lo que está sucediendo, de lo contrario puede parecer que Hibernate está haciendo algún tipo de magia. Bueno, por supuesto, no será del todo claro mostrarlo; es mejor usar algún tipo de registrador para esto, pero eso es algo para otro momento, por ahora servirá.

Configuración de hibernación

Pasemos a configurar la configuración. configCreemos una clase en el paquete HibernateConfig:

package testgroup.filmography.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@ComponentScan(basePackages = " testgroup.filmography")
@EnableTransactionManagement
@PropertySource(value = "classpath:db.properties")
public class HibernateConfig {
    private Environment environment;

    @Autowired
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    private Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", environment.getRequiredProperty("hibernate.dialect"));
        properties.put("hibernate.show_sql", environment.getRequiredProperty("hibernate.show_sql"));
        return properties;
    }

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
        dataSource.setUrl(environment.getRequiredProperty("jdbc.url"));
        dataSource.setUsername(environment.getRequiredProperty("jdbc.username"));
        dataSource.setPassword(environment.getRequiredProperty("jdbc.password"));
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("testgroup.filmography.model");
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }

    @Bean
    public HibernateTransactionManager transactionManager() {
        HibernateTransactionManager transactionManager = new HibernateTransactionManager();
        transactionManager.setSessionFactory(sessionFactory().getObject());
        return transactionManager;
    }
}

Hay muchas cosas nuevas aquí, por lo que es mejor buscar información sobre cada elemento en diferentes fuentes. Repasémoslo brevemente aquí.

• @ConfigurationYa nos @ComponentScandimos cuenta cuando hicimos la clase WebConfig.
• @EnableTransactionManagement— le permite utilizarlo TransactionManagerpara gestionar transacciones. Hibernate trabaja con la base de datos mediante transacciones; son necesarias para que un determinado conjunto de operaciones se realice como un todo, es decir. si el método tiene problemas con alguna operación, entonces todas las demás no se ejecutarán, por lo que no sucede como en el ejemplo clásico de la transferencia de dinero, cuando se completó la operación de retirar dinero de una cuenta, pero la La operación de escribir a otra persona no funcionó, como resultado el dinero desapareció.
• @PropertySource— conectando el archivo de propiedades que creamos recientemente.
• Environment- para obtener propiedades de propertyun archivo.
• hibernateProperties- este método es necesario para representar las propiedades de Hibernate como un objeto Propiedades
• DataSource— Se utiliza para crear una conexión a la base de datos. Esta es una alternativa a DriverManager , que usamos anteriormente cuando creamos el archivo main. La documentación dice cuál DataSourcees preferible usar. Eso es lo que haremos, por supuesto, sin olvidarnos de leer en Internet cuáles son las diferencias y ventajas. Un beneficio en particular es la capacidad de crear un grupo de conexiones de bases de datos (DBCP).
• sessionFactory— crear sesiones con ayuda de las cuales se realizan operaciones con objetos de entidad. Aquí configuramos la fuente de datos, las propiedades de Hibernate y en qué paquete debemos buscar clases de entidad.
• transactionManager— para configurar el administrador de transacciones.

Una pequeña nota sobre DataSource. La documentación dice que no se recomienda utilizar la implementación estándar, es decir DriverManagerDataSource, porque es solo un reemplazo para la agrupación de conexiones normal y generalmente solo es adecuado para pruebas y demás. Para una aplicación normal, es preferible utilizar algún tipo de biblioteca DBCP. Bueno, para nuestra aplicación, por supuesto, lo que tenemos es suficiente, pero para completar el panorama, tal vez usemos otra implementación como se recomienda. Agreguemos la pom.xmlsiguiente dependencia:

<dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-dbcp</artifactId>
            <version>9.0.10</version>
</dependency>

Y en el método dataSourcede clase HibernateConfiglo reemplazamos DriverManagerDataSourcepor BasicDataSourceuno del paquete org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Bueno, parece que todo está listo, la configuración está lista, solo queda agregarla a nuestro AppInitializer :

protected Class<?>[] getRootConfigClasses() {
        return new Class[]{HibernateConfig.class};
    }

Capa de acceso a datos

Es hora de finalmente comenzar con nuestro DAO. Vamos a la clase FilmDAOImply primero borramos de allí la lista de pruebas, ya no la necesitamos. Agreguemos una fábrica de sesiones y trabajemos en ella.

private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

Primero, creemos un método para mostrar una página con una lista de películas, en ella recibiremos una sesión y haremos una solicitud a la base de datos (saque todos los registros y cree una lista):

public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

Hay 2 puntos aquí. Primero, se mostró una advertencia. Esto se debe a que queremos recibir un parámetro parametrizado List<Film>, pero el método regresa simplemente Listporque en el momento de la compilación no se sabe qué tipo devolverá la solicitud. Entonces la idea nos advierte que estamos realizando una conversión insegura, lo que puede resultar en problemas. Hay varias formas más correctas de hacer esto para que no surja esa pregunta. Puede buscar información en Internet. Pero no nos preocupemos por esto ahora. El hecho es que sabemos exactamente qué tipo se devolverá, por lo que no surgirán problemas aquí, simplemente puede ignorar la advertencia. Pero, para que tus ojos no sean una monstruosidad, puedes colgar una anotación encima del método @SupressWarning("unchecked"). Al hacer esto, le decimos al compilador: gracias amigo por tu preocupación, pero sé lo que estoy haciendo y tengo todo bajo control, así que puedes relajarte y no preocuparte por este método. En segundo lugar, la idea está subrayada en rojo " from Film". Es solo una consulta HQL (Hibernate Query Language) y la idea no entiende si todo está correcto o hay un error. Puede ir a la configuración de ideas y ajustar todo manualmente (busque en Internet si está interesado). O simplemente puede agregar soporte para el marco de Hibernate; para hacer esto, haga clic derecho en el proyecto, seleccione Agregar soporte de marco , marque la casilla de Hibernate y haga clic en Aceptar. Después de esto, lo más probable es que en la clase de entidad ( Film) muchas cosas también estén subrayadas en rojo, por ejemplo, donde la anotación @Table(name = "films")emitirá la advertencia No se puede resolver la tabla 'películas' . Nuevamente, no hay nada malo aquí, esto no es un error de diseño, todo se compilará y funcionará. La idea se enfatiza porque no sabe nada sobre nuestra base. Para solucionar este problema, integremos la idea con la base de datos. Ver -> Ventanas de herramientas -> Persistente (se abrirá una pestaña) -> botón derecho del mouse, seleccione Asignar fuentes de datos -> en Fuente de datos, especifique la conexión a la base de datos y haga clic en Aceptar . Cuando todo esto se arregló, aún quedaba algo. Vayamos a un nivel superior, al servicio. En la clase, FilmServiceImplmarcamos el allFilmsmétodo Spring con una anotación @Transactional, que indicará que el método debe ejecutarse en una transacción (sin esto, Hibernate se negará a funcionar):

@Transactional
public List<Film> allFilms() {
    return filmDAO.allFilms();
}

Entonces, todo está listo aquí, no necesitas tocar nada en el controlador. Pues parece que ha llegado la hora de la verdad, dale a Ejecutar y mira qué pasa. Y aquí está, nuestro signo, y esta vez no lo hemos obtenido de una lista que nosotros mismos hicimos en clase, sino de una base de datos. Genial, todo parece estar funcionando. Ahora hacemos todas las demás operaciones CRUD de la misma manera usando métodos de sesión. La clase resultante se ve así:

package testgroup.filmography.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import testgroup.filmography.model.Film;

import java.util.List;

@Repository
public class FilmDAOImpl implements FilmDAO {
    private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

    @Override
    public void add(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.persist(film);
    }

    @Override
    public void delete(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.delete(film);
    }

    @Override
    public void edit(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.update(film);
    }

    @Override
    public Film getById(int id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(Film.class, id);
    }
}

Ahora solo queda no olvidarse de ir al servicio y agregar una anotación a los métodos @Transactional. Eso es todo, listo. Ahora puedes ejecutar y comprobar. Haga clic en enlaces y botones, intente agregar/eliminar/editar entradas. Si todo se hace correctamente debería funcionar. Esta es una aplicación CRUD completa que utiliza Hibernate, Spring, MySQL. Continuará... Presentamos Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD (parte 1) Presentamos Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD (parte 2) Presentamos Maven, Spring, MySQL, Hibernate y primera aplicación CRUD (parte 3) Introducción a Maven, Spring, MySQL, Hibernate y la primera aplicación CRUD (parte 4)