Conexión a la base de datos

3.1 Vinculación de Hibernate y bases de datos

Aprendimos cómo conectar Hibernate a nuestra aplicación usando Maven y cómo asignar tablas a clases usando anotaciones. Y ahora surge la siguiente pregunta: ¿cómo leemos objetos de la base de datos o los guardamos allí?

No tan rapido. En primer lugar, debe lidiar con tres cosas más:

• Configuración de una conexión de base de datos
• Configurando Hibernate
• Trabajando con EntityManager

Hibernate oculta completamente el trabajo con la base de datos de su aplicación, pero para evitar excesos, debe configurarse correctamente. No puede omitir esta etapa; de lo contrario, ¿cómo sabrá Hibernate en qué base de datos guardar los objetos?

Hibernate puede configurarse y recibir información de la base de datos de tres maneras

• Usar archivo de propiedades
• Utilice el archivo hibernate.cfg.xml
• Usar métodos del bean de configuración

Y aunque me gusta más el último, definitivamente encontrarás los tres, así que analizaremos los tres aquí.

3.2 Autorización en la base de datos

Comencemos con lo más importante: las conexiones de la base de datos. Para hacer esto, deberá proporcionar datos para que Hibernate pueda iniciar sesión en la base de datos deseada.

hibernate.dialect= org.hibernate.dialect.Oracle9Dialect
hibernate.connection.driver_class= oracle.jdbc.driver.OracleDriver
hibernate.connection.url= jdbc:oracle:thin:@localhost:1521:supershop
hibernate.connection.username=root
hibernate.connection.password=secret
hibernate.show_sql=true
hibernate.hbm2ddl=update

La misma configuración se puede establecer en forma de un archivo xml:

<hibernate-configuration>
	<session-factory>

    	<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
    	<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
    	<property name="connection.url">jdbc:oracle:thin:@localhost:1521:supershop</property>
    	<property name="connection.username">root</property>
    	<property name="connection.password">secret</property>
    	<property name="hibernate.show_sql ">true</property>
    	<property name="hbm2ddl.auto">update</property>

	</session-factory>
</hibernate-configuration>

En ambos ejemplos, vemos la misma configuración con los mismos valores. Es solo que el primer ejemplo los representa como un archivo de propiedades y el segundo como un archivo xml .

Estos ajustes se dividen en tres grupos:

1. Especificar el tipo de DBMS
• Especifique el dialecto (tipo DBMS), por ejemplo, Oracle 9.0
• Especifique el nombre del controlador JDBC para trabajar con este DBMS
2. Especificar datos para la autorización en la base de datos.
• URL de la base de datos
• nombre de usuario
• contraseña
3. Configuración del motor de hibernación
• hibernate.show_sql- Hibernate duplicará en la consola todas las solicitudes que ejecute
• hbm2ddl.auto- Hibernate cambiará la estructura de la base de datos si es necesario

Hay una tercera forma de establecer la configuración: a través de contenedores. Por lo general, se usa junto con Spring, por lo que lo veremos cuando aprendamos SpringFramework.

3.3 Obtener SessionFactory

El siguiente paso es obtener el objeto SessionFactory. Hay varias formas de hacer esto:

La primera forma es usar el archivo hibernate.properties .

Para hacer esto, solo necesitas escribir el siguiente código:

SessionFactory sessionFactory = new Configuration().buildSessionFactory();

Si el archivo hibernate.properties no se encuentra en el directorio del proyecto actual, se generará una excepción.

La segunda forma es la configuración usando hibernate.cfg.xml .

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

Si escribe dicho código, entonces el hibernate.cfg.xml. Si no se encuentra dicho archivo, el método buildSessionFactory()generará una excepción.

La tercera forma es establecer el archivo de configuración manualmente .

A veces, durante el proceso de desarrollo, es necesario cambiar a una base de prueba o cambiar algunas otras configuraciones para trabajar con la base, para esto puede configurar el archivo de configuración manualmente:

SessionFactory sessionFactory = new Configuration().configure("hibernate-dev.cfg.xml").buildSessionFactory();

Método cuatro: usamos un archivo hibernate.properties personalizado:

ClassLoader classLoader = Thread.currentThread().getClassLoader();

Properties properties = new Properties();
properties.load(classLoader.getResourceAsStream("hibernate-dev.properties"));

SessionFactory sessionFactory = new Configuration()
            .addProperties(properties)
            .buildSessionFactory();

Y finalmente, puede simplemente coser todos los parámetros necesarios directamente en el código:

Properties properties = new Properties();
properties.put(Environment.DRIVER, "com.mysql.jdbc.Driver");
properties.put(Environment.URL, "jdbc:mysql://localhost:3306/supershop");
properties.put(Environment.USER, "root");
properties.put(Environment.PASS, "password");

SessionFactory sessionFactory = new Configuration()
            .setProperties(properties)
            .buildSessionFactory();

3.4 Especificar dónde buscar clases de entidad

Pero eso no es todo. Cuando configuramos un objeto SessionFactory en Hibernate, este SessionFactory verifica que todas las tablas requeridas con los tipos de columna requeridos existan en la base de datos.

Y para que SessionFactory pueda hacer esto, se le debe pasar una lista de clases de entidad que necesita asignar a la base de datos.

Hay tres formas de pasar una lista de clases de entidad:

Método uno. En hibernate.cfg.xmlagregar una línea como:

<mapping class="class-qualified-name" />

Ejemplo:

<mapping class="com.codegym.data.User" />
<mapping class="com.codegym.data.Employee" />
<mapping class="com.codegym.data.Task" />

Método dos. Llame al método en el objeto de configuraciónaddAnnotatedClass() . Ejemplo:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addAnnotatedClass(com.codegym.data.User.class)
   	.buildSessionFactory();

Si hay muchas clases, puede agregarlas en paquetes completos:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addPackage("com.codegym.data")
   	.buildSessionFactory();

3.5 Último ejemplo

Ahora que hemos aprendido a configurar el objeto SessionFactory, escribamos el código que lo usará.

Constará de tres métodos:

1. Configurar Hibernación
2. Método que obtiene todos los empleados de la base de datos.
3. Método que guarda un nuevo empleado en la base de datos

Esta plantilla de código se vería así:

class EmployeeManager {
    private SessionFactory sessionFactory;

    public void class init() {
    	this.sessionFactory = new Configuration()
        	.configure()
        	.buildSessionFactory();
   }

   public List<Employee> getAllEmployes() {
         try (Session session = sessionFactory.openSession()) {
  	          Query<Employee> query = session.createQuery("from Employee", Employee.class);
    	        return query.list();
         }
   }

   public void addEmployee(Employee employee ) {
     	try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
       	    session.save(employee);
            transaction.commit();
     	}
   }
}

Antes de ejecutar una consulta a la base de datos, debe crear una sesión separada. Si las solicitudes están relacionadas, se pueden ejecutar en la misma sesión. Si las solicitudes no están relacionadas (y pueden pasar varios minutos entre ellas), entonces deben crear sus propias sesiones.

Si desea leer datos de la base de datos o ejecutar una consulta compleja, primero debe crear un objeto Query y usarlo para ejecutar su consulta.

Además, cada consulta a la base de datos se ejecuta en su propia transacción. Debe abrirlo, realizar las operaciones necesarias y luego cerrar (confirmar).

En las siguientes conferencias, analizaremos con más detalle cómo funciona todo esto.