Hibernate - Many-to-Many Mapping

// Java Program to Illustrate GeekEmployeeData Class

// Importing required classes
import java.util.Set;

// Class
public class GeekEmployeeData {

    // Attributes are mapping to geekEmployeeData

    // geekEmployeeData.id
    private int id;
  
    // geekEmployeeData.firstName
    private String firstName;
  
    // geekEmployeeData.lastName
    private String lastName;
  
    // geekEmployeeData.salary
    private int salary;

    // Collection of skillsets in Set variable
    private Set skillSets;

    // Method
    public Set getSkillSets() { return skillSets; }

    public void setSkillSets(Set skillSets)
    {

        // This keyword refers to current instance itself
        this.skillSets = skillSets;
    }

    // Constructor 1
    public GeekEmployeeData() {}

    // Constructor 2
    public GeekEmployeeData(String firstName,
                            String lastName, int salary)
    {

        // This keyword refers to current instance itself
        this.firstName = firstName;
        this.lastName = lastName;
        this.salary = salary;
    }

    // Getter  and Setters

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getFirstName() { return firstName; }
    public void setFirstName(String firstName)
    {
        this.firstName = firstName;
    }
    public String getLastName() { return lastName; }
    public void setLastName(String lastName)
    {
        this.lastName = lastName;
    }
    public int getSalary() { return salary; }
    public void setSalary(int salary)
    {
        this.salary = salary;
    }
}

public class SkillsetData {
    private int id;
    private String skillName;

    public SkillsetData() {}

    public SkillsetData(String skillName)
    {
        this.skillName = skillName;
    }

    public int getId() { return id; }

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

    public String getSkillName() { return skillName; }

    public void setSkillName(String skillName)
    {
        this.skillName = skillName;
    }

    public boolean equals(Object obj)
    { 
      
        // This method is definitely required in order to
        // check whether any two elements/objects are equal
        if (obj == null)
            return false;
        if (!this.getClass().equals(obj.getClass()))
            return false;

        SkillsetData obj2 = (SkillsetData)obj;
        if ((this.id == obj2.getId())
            && (this.skillName.equals(
                obj2.getSkillName()))) {
            return true;
        }
        return false;
    }
    // collections calculate the hash value for a given key
    // using the hashCode() method.
    public int hashCode()
    { 
      
        // This method is definitely required in order to
        // check whether any two elements/objects are equal
        int tmp = 0;
        tmp = (id + skillName).hashCode();
        return tmp;
    }
}

// Java Program to Illustrate GeekEmployeeManytoManyExample
// Class

// Importing required classes
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.LogicalExpression;
import org.hibernate.criterion.Restrictions;

// Class
public class GeekEmployeeManytoManyExample {

    // Class data member
    private static SessionFactory factory;

    // Main driver method
    public static void main(String[] args)
    {

        // Try block to check for exceptions
        try {

            factory = new Configuration()
                          .configure()
                          .buildSessionFactory();
        }

        // Catch block to handle exceptions
        catch (Throwable ex) {

            // Display command when exception occurred
            System.err.println(
                "Failed to create sessionFactory object."
                + ex);
            throw new ExceptionInInitializerError(ex);
        }

        GeekEmployeeManytoManyExample geekEmployeeObject
            = new GeekEmployeeManytoManyExample();

        // Let us have a set of skills for few employees
        HashSet skillSets = new HashSet();

        skillSets.add(new SkillsetData("Java"));
        skillSets.add(new SkillsetData("Python"));
        skillSets.add(new SkillsetData("R Programming"));

        HashSet databaseSkillSets = new HashSet();

        databaseSkillSets.add(new SkillsetData("MySQL"));
        databaseSkillSets.add(
            new SkillsetData("SQL Server"));
        databaseSkillSets.add(new SkillsetData("MongoDB"));

        HashSet generalSkillset = new HashSet();
        generalSkillset.add(skillSets);
        generalSkillset.add(databaseSkillSets);

        // Add few employee records in database
        Integer empID1 = geekEmployeeObject.addEmployee(
            "GeekA", "GeekA", 100000, skillSets);
        Integer empID2 = geekEmployeeObject.addEmployee(
            "GeekB", "GeekB", 50000, databaseSkillSets);
        Integer empID3 = geekEmployeeObject.addEmployee(
            "GeekC", "GeekC", 50000, skillSets);
    }

    /* Method to CREATE an employee in the database. Inserts
data in
geekEmployeeData, SkillsetData and geekEmployeeSkill table
*/
    public Integer addEmployee(String fname, String lname,
                               int salary, Set skillSets)
    {
        Session session = factory.openSession();
        Transaction tx = null;
        Integer employeeID = null;

        try {
            tx = session.beginTransaction();
            GeekEmployeeData employee
                = new GeekEmployeeData(fname, lname,
                                       salary);
            employee.setSkillSets(skillSets);
            employeeID = (Integer)session.save(employee);
            tx.commit();
        }
        catch (HibernateException e) {
            if (tx != null)
                tx.rollback();
            e.printStackTrace();
        }

        // finally block
        finally {

            // Closing the sessions
            // using close() method
            session.close();
        }

        return employeeID;
    }
}

// Java Program to List the Records by
// Using Hibernate Criteria Query

// Method
public void listGeekEmployeeData()
{

    Session session = factory.openSession();
    Transaction tx = null;

    // Try block to check for exceptions
    try {
        tx = session.beginTransaction();

        Criteria geekEmployeeCriteria
            = session.createCriteria(
                GeekEmployeeData.class);
        List geekEmployeeList = geekEmployeeCriteria.list();

        for (Iterator iterator
             = geekEmployeeList.iterator();
             iterator.hasNext();) {

            GeekEmployeeData employeeData
                = (GeekEmployeeData)iterator.next();
            System.out.print("First Name: "
                             + employeeData.getFirstName());
            System.out.print("  Last Name: "
                             + employeeData.getLastName());
            System.out.println("  Salary: "
                               + employeeData.getSalary());

            // As we have used Set to store data, during
            // display
            // also we need to use the set

            // Iterate and get the skills one by one.
            // An employee may have more than 1 skill
            Set skillSets = employeeData.getSkillSets();

            for (Iterator it = skillSets.iterator();
                 it.hasNext();) {
                SkillsetData skillName
                    = (SkillsetData)it.next();
                System.out.println(
                    "SkillName: "
                    + skillName.getSkillName());
            }
        }

        tx.commit();
    }

    // Catch block to handle exceptions
    catch (HibernateException e) {

        if (tx != null)
            tx.rollback();
        e.printStackTrace();
    }

    // finally block which will execute for sure
    finally {

        // Closing all sessions
        // using close() method
        session.close();
    }
}

/* List down all the employees by using Hibernate criteria */
geekEmployeeObject.listGeekEmployeeData();

// Java Program to illustrate Listing Employee Data

// Method
// Listing gfgEmployee Data
// Whose firstname like certain name
// and salary > certain value

// We can combine expressions using 'And','Or'
public void listGeekEmployeesByNameAndSalaryCriteria()
{
    Session session = factory.openSession();
    Transaction tx = null;

    // Try block to check for exceptions
    try {
        tx = session.beginTransaction();

        // This will simply return every object that
        // corresponds to the GeekEmployee class.

        Criteria geekEmployeeCriteria
            = session.createCriteria(
                GeekEmployeeData.class);

        // Here 2 expectations are there one with salary and
        // second one is name.
        // Both are expected to be present. Let us see how
        // to do that
        Criterion salaryExpectation
            = Restrictions.gt("salary", 50000);

        Criterion nameExpectation
            = Restrictions.ilike("firstName", "Geek%");

        LogicalExpression logicalAndExpression
            = Restrictions.and(salaryExpectation,
                               nameExpectation);
        geekEmployeeCriteria.add(logicalAndExpression);

        // As a list we can collect them and can iterate
        List geekEmployeeList = geekEmployeeCriteria.list();

        for (Iterator iterator
             = geekEmployeeList.iterator();
             iterator.hasNext();) {
            GeekEmployeeData employeeData
                = (GeekEmployeeData)iterator.next();

            // Print statements
            System.out.print("First Name: "
                             + employeeData.getFirstName());
            System.out.print("  Last Name: "
                             + employeeData.getLastName());
            System.out.println("  Salary: "
                               + employeeData.getSalary());

            Set skillSets = employeeData.getSkillSets();

            for (Iterator it = skillSets.iterator();
                 it.hasNext();) {
                SkillsetData skillName
                    = (SkillsetData)it.next();

                // Print statement
                System.out.println(
                    "SkillName: "
                    + skillName.getSkillName());
            }
        }
        tx.commit();
    }

    // Catch block to handle exceptions
    catch (HibernateException e) {
        if (tx != null)
            tx.rollback();

        // Display exception along with line number
        // using printStacktrace() method
        e.printStackTrace();
    }

    // finally block which will execute for sure
    finally {

        // Closing the connections
        // to avoid memory leakage
        session.close();
    }
}

// Let us add filter data by using Restrictions
geekEmployeeObject.listGeekEmployeesByNameAndSalaryCriteria();