Hibernate creando objetos DAO para el sistema de facturación | Java

Una vez que tengamos todas las entidades es necesario crear nuestros objetos DAO (Data Access Object) para poder obtener conectar la base de datos y persistir los mismos, en este caso se ha creado una clase DAO por cada entidad, esto nos permite generar métodos propios para obtener o insertar datos en una determinada tabla.

Todas las clases DAO heredan de GenericDAO.java que se creo anteriormente, aquí vamos a listar todas la clases creadas pero no se pondrá el código de todas ya que son muy parecidas y sobretodo puede llegar a extender demasiado el post.

1. CustomerDAO.java
2. DatabaseLogDAO.java
3. DatabaseTableDAO.java
4. DetailDAO.java
5. EmployeeDAO.java
6. InvoiceDAO.java
7. ModuleDAO.java
8. PaymentMethodDAO.java
9. PermissionDAO.java
10. PersonDAO.java
11. ProductDAO.java
12. ProductCategoryDAO.java
13. ProviderDAO.java
14. RoleDAO.java
15. TaxDAO.java
16. UserDAO.java
17. UserRoleDAO.java

Todas esas clases anteriores se añadieron a un paquete llamado "dao" mientras que las entidades se añadieron a un paquete llamado "model", puedes ver la lista de entidades aquí.

import com.abigsite.facturationsystem.model.Customer;
import com.abigsite.facturationsystem.util.GenericDAO;

public class CustomerDAO extends GenericDAO<Customer> {

    public CustomerDAO() {
        super(Customer.class);
    }
}

Este es el ejemplo básico de una clase DAO que será la encargada de la tabla clientes, y no tiene nada más que un constructor básico.

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.abigsite.facturationsystem.model.User;
import com.abigsite.facturationsystem.util.GenericDAO;
import com.abigsite.facturationsystem.util.HibernateUtil;

public class UserDAO extends GenericDAO<User> {

    private CriteriaBuilder criteriaBuilder;
    private CriteriaQuery<User> criteriaQuery;
    private Root<User> root;

    private User user;

    public UserDAO() {
        super(User.class);
    }

    public boolean checkLoginData(String username, String password) {
        Transaction transaction = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            transaction = session.beginTransaction();
            criteriaBuilder = session.getCriteriaBuilder();
            criteriaQuery = criteriaBuilder.createQuery(User.class);
            root = criteriaQuery.from(User.class);
            criteriaQuery.select(root);
            criteriaQuery.where(criteriaBuilder.equal(root.get("username"), username));
            user = session.createQuery(criteriaQuery).uniqueResult();
            transaction.commit();
        } catch (HibernateException e) {
            if (transaction != null)
                transaction.rollback();
            e.printStackTrace();
        }
        if (user != null && user.isStatus() && user.getPassword().equals(password))
            return true;
        return false;
    }

    public boolean userExist(String username) {
        Transaction transaction = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            transaction = session.beginTransaction();
            criteriaBuilder = session.getCriteriaBuilder();
            criteriaQuery = criteriaBuilder.createQuery(User.class);
            root = criteriaQuery.from(User.class);
            criteriaQuery.select(root);
            criteriaQuery.where(criteriaBuilder.equal(root.get("username"), username));
            user = session.createQuery(criteriaQuery).uniqueResult();
        } catch (HibernateException e) {
            if (transaction != null)
                transaction.rollback();
            e.printStackTrace();
        }
        if (user != null)
            return true;
        return false;
    }
}

El ejemplo anterior es una clase DAO que no solamente hereda de la clase genérica si no también tenemos métodos que solo funcionarían en esta clase, por lo tanto lo que hacemos en las clases de acceso a datos es simplemente métodos que nos permiten interactuar directamente con la base de datos.

El primer método de la clase UserDAO.java verifica si el usuario y contraseña para acceder al sistema son correctos, mientras que el segundo método busca el nombre de usuario para ver si es que ya existe uno con el mismo nombre que ha intentado registrarse una nueva persona.

← Anterior

Siguiente →