El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Hibernate

Següent ►
►

Hibernate és un framework de persistència d'objectes per a Java que facilita la implementació de l'accés a bases de dades relacionals utilitzant el paradigma de la programació orientada a objectes. Hibernate permet als desenvolupadors treballar amb dades en forma d'objectes Java, sense haver de preocupar-se per les complexitats de la gestió de bases de dades relacionals.

Continguts

  1. Introducció a Hibernate
  2. Configuració de Hibernate
  3. Mapeig d'Entitats
  4. Operacions CRUD
  5. Consultes amb HQL
  6. Relacions entre Entitats
  7. Gestió de Transaccions
  8. Exercicis Pràctics

Introducció a Hibernate

Hibernate és un framework de codi obert que simplifica la interacció entre aplicacions Java i bases de dades relacionals. Proporciona una capa d'abstracció que permet als desenvolupadors treballar amb objectes Java en lloc de taules de bases de dades.

Característiques Clau de Hibernate

  • Mapeig Objecte-Relacional (ORM): Hibernate converteix les dades entre els sistemes de tipus de Java i les bases de dades relacionals.
  • HQL (Hibernate Query Language): Un llenguatge de consultes orientat a objectes similar a SQL.
  • Gestió de Transaccions: Hibernate gestiona les transaccions de manera eficient.
  • Caché: Hibernate proporciona mecanismes de caché per millorar el rendiment.

Configuració de Hibernate

Per començar a utilitzar Hibernate, cal configurar-lo adequadament. A continuació es mostra un exemple de configuració bàsica utilitzant un fitxer hibernate.cfg.xml.

Fitxer hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- Configuració de la connexió a la base de dades -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/nom_de_la_base_de_dades</property>
        <property name="hibernate.connection.username">usuari</property>
        <property name="hibernate.connection.password">contrasenya</property>

        <!-- Dialecte de la base de dades -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Configuració de la sessió -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- Classes mapejades -->
        <mapping class="com.exemple.Entitat"/>
    </session-factory>
</hibernate-configuration>

Configuració de Maven

Afegiu les següents dependències al fitxer pom.xml del vostre projecte Maven:

<dependencies>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.4.30.Final</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>
</dependencies>

Mapeig d'Entitats

El mapeig d'entitats és el procés de definir com les classes Java es corresponen amb les taules de la base de dades. Hibernate utilitza anotacions per simplificar aquest procés.

Exemple de Classe Entitat

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;

@Entity
public class Usuari {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nom;
    private String email;

    // Getters i Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Operacions CRUD

Hibernate facilita la implementació de les operacions CRUD (Crear, Llegir, Actualitzar, Esborrar) sobre les entitats.

Crear una Entitat

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class CrearUsuari {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            Usuari nouUsuari = new Usuari();
            nouUsuari.setNom("Joan");
            nouUsuari.setEmail("[email protected]");

            session.beginTransaction();
            session.save(nouUsuari);
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Llegir una Entitat

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class LlegirUsuari {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            Usuari usuari = session.get(Usuari.class, 1L);
            session.getTransaction().commit();

            System.out.println("Usuari: " + usuari.getNom() + ", Email: " + usuari.getEmail());
        } finally {
            factory.close();
        }
    }
}

Actualitzar una Entitat

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class ActualitzarUsuari {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            Usuari usuari = session.get(Usuari.class, 1L);
            usuari.setEmail("[email protected]");
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Esborrar una Entitat

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class EsborrarUsuari {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            Usuari usuari = session.get(Usuari.class, 1L);
            session.delete(usuari);
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Consultes amb HQL

Hibernate Query Language (HQL) és un llenguatge de consultes orientat a objectes similar a SQL, però treballa amb entitats en lloc de taules.

Exemple de Consulta HQL

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import java.util.List;

public class ConsultesHQL {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            Query<Usuari> query = session.createQuery("from Usuari", Usuari.class);
            List<Usuari> usuaris = query.getResultList();
            session.getTransaction().commit();

            for (Usuari usuari : usuaris) {
                System.out.println("Usuari: " + usuari.getNom() + ", Email: " + usuari.getEmail());
            }
        } finally {
            factory.close();
        }
    }
}

Relacions entre Entitats

Hibernate permet definir relacions entre entitats utilitzant anotacions com @OneToOne, @OneToMany, @ManyToOne i @ManyToMany.

Exemple de Relació One-to-Many

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Curs {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nom;

    @OneToMany(mappedBy = "curs", cascade = CascadeType.ALL)
    private List<Usuari> usuaris = new ArrayList<>();

    // Getters i Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public List<Usuari> getUsuaris() {
        return usuaris;
    }

    public void setUsuaris(List<Usuari> usuaris) {
        this.usuaris = usuaris;
    }
}

@Entity
public class Usuari {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nom;
    private String email;

    @ManyToOne
    @JoinColumn(name = "curs_id")
    private Curs curs;

    // Getters i Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Curs getCurs() {
        return curs;
    }

    public void setCurs(Curs curs) {
        this.curs = curs;
    }
}

Gestió de Transaccions

Hibernate gestiona les transaccions de manera eficient, permetent als desenvolupadors definir blocs de codi que es tracten com a transaccions.

Exemple de Gestió de Transaccions

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class GestioTransaccions {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            Usuari usuari = new Usuari();
            usuari.setNom("Anna");
            usuari.setEmail("[email protected]");
            session.save(usuari);
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Exercicis Pràctics

Exercici 1: Crear i Llegir Entitats

  1. Crea una nova entitat anomenada Producte amb els camps id, nom i preu.
  2. Escriu un programa per crear i guardar un nou Producte a la base de dades.
  3. Escriu un programa per llegir i mostrar tots els Productes de la base de dades.

Exercici 2: Relacions entre Entitats

  1. Defineix una relació One-to-Many entre Curs i Usuari.
  2. Escriu un programa per crear un nou Curs amb diversos Usuaris associats.
  3. Escriu un programa per llegir i mostrar tots els Cursos i els seus Usuaris associats.

Solucions

Solució Exercici 1

@Entity
public class Producte {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nom;
    private Double preu;

    // Getters i Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public Double getPreu() {
        return preu;
    }

    public void setPreu(Double preu) {
        this.preu = preu;
    }
}
public class CrearProducte {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Producte.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            Producte producte = new Producte();
            producte.setNom("Ordinador");
            producte.setPreu(1200.00);

            session.beginTransaction();
            session.save(producte);
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}
public class LlegirProductes {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Producte.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            List<Producte> productes = session.createQuery("from Producte", Producte.class).getResultList();
            session.getTransaction().commit();

            for (Producte producte : productes) {
                System.out.println("Producte: " + producte.getNom() + ", Preu: " + producte.getPreu());
            }
        } finally {
            factory.close();
        }
    }
}

Solució Exercici 2

public class CrearCursAmbUsuaris {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Curs.class).addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            Curs curs = new Curs();
            curs.setNom("Programació en Java");

            Usuari usuari1 = new Usuari();
            usuari1.setNom("Maria");
            usuari1.setEmail("[email protected]");
            usuari1.setCurs(curs);

            Usuari usuari2 = new Usuari();
            usuari2.setNom("Pere");
            usuari2.setEmail("[email protected]");
            usuari2.setCurs(curs);

            curs.getUsuaris().add(usuari1);
            curs.getUsuaris().add(usuari2);

            session.beginTransaction();
            session.save(curs);
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}
public class LlegirCursosAmbUsuaris {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Curs.class).addAnnotatedClass(Usuari.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();
            List<Curs> cursos = session.createQuery("from Curs", Curs.class).getResultList();
            session.getTransaction().commit();

            for (Curs curs : cursos) {
                System.out.println("Curs: " + curs.getNom());
                for (Usuari usuari : curs.getUsuaris()) {
                    System.out.println("  Usuari: " + usuari.getNom() + ", Email: " + usuari.getEmail());
                }
            }
        } finally {
            factory.close();
        }
    }
}

Conclusió

Hibernate és una eina poderosa per a la persistència d'objectes en aplicacions Java. Amb la seva capacitat de mapeig objecte-relacional, gestió de transaccions i suport per a consultes HQL, Hibernate simplifica significativament la interacció amb bases de dades relacionals. Els exercicis pràctics proporcionats ajuden a consolidar els conceptes apresos i a aplicar-los en situacions reals.

◄ Anterior
◄
Següent ►
►

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats