JDBC ResultSet – Mapping Types

Mapping Types

ResultSet mapping refers to the process of converting data from a ResultSet into a Java object. This is commonly used when working with databases in Java, as it allows you to work with the data in a more convenient and object-oriented manner.

There are several ways to perform ResultSet mapping in Java, including manual mapping and using object-relational mapping (ORM) tools such as Hibernate, JPA, and iBatis.

Here’s an example of manual ResultSet mapping in Java:

Java

public class ResultSetMappingExample {
  public static void main(String[] args) {
    try {
      // Load the JDBC driver
      Class.forName("com.mysql.jdbc.Driver");
      // Establish a connection to the database
      Connection connection = DriverManager.getConnection(
          "jdbc:mysql://localhost:3306/mydb", "root", "password");
      // Create a statement
      Statement statement = connection.createStatement();
      // Execute a query and retrieve the ResultSet
      ResultSet resultSet = statement.executeQuery("SELECT * FROM employees");
      // Create a list to store the results
      List<Employee> employees = new ArrayList<Employee>();
      // Loop through the ResultSet
      while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String department = resultSet.getString("department");
        // Create an Employee object and add it to the list
        employees.add(new Employee(id, name, department));
      }
      // Close the ResultSet and Statement
      resultSet.close();
      statement.close();
      // Close the connection
      connection.close();
      // Print the results
      for (Employee employee : employees) {
        System.out.println(employee);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Explanation

Set class to store the results of the query. We then loop through the ResultSet and for each row, we retrieve the values for the id, name, and department columns and use them to create an Employee object. Finally, we add each Employee object to a list, which can be used to perform further processing or to display the results to the user.

It’s important to note that manual ResultSet mapping, as shown in this example, can become repetitive and time-consuming as the number of tables in your database grows. In such cases, using an ORM tool like Hibernate, JPA, or iBatis can be more efficient as it eliminates the need for manual mapping and provides a higher-level API for working with databases.

In conclusion, ResultSet mapping is a key aspect of working with databases in Java and is used to convert data from a ResultSet into a more convenient form for further processing. Whether you choose to perform manual mapping or use an ORM tool, it is important to have a solid understanding of ResultSet mapping in order to effectively work with databases in Java.

Automatic Mapping

Automatic mapping with Hibernate involves using the Hibernate ORM framework to map database tables to Java classes, and the data in the tables to the attributes of the Java classes. This makes it easier to work with databases in Java as it eliminates the need for manual mapping and provides a higher-level API for working with databases.

Here’s an example of automatic mapping with Hibernate:

Java

@Entity
public class Employee {
  @Id
  private int id;
  private String name;
  private String department;

  // Getters and setters

  @Override
  public String toString() {
    return "Employee [id=" + id + ", name=" + name + ", department=" + department + "]";
  }
}


import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateExample {
  public static void main(String[] args) {
    // Create a SessionFactory
    SessionFactory sessionFactory = new Configuration()
        .configure().buildSessionFactory();
    // Get a Session from the SessionFactory
    Session session = sessionFactory.openSession();
    // Start a transaction
    session.beginTransaction();
    // Execute a query and retrieve the results as a list of Employee objects
    List<Employee> employees = session.createQuery("FROM Employee").list();
    // Commit the transaction
    session.getTransaction().commit();
    // Close the Session
    session.close();
    // Print the results
    for (Employee employee : employees) {
      System.out.println(employee);
    }
  }
}

Explanation

In this example, we define an Employee class and annotate it with @Entity to indicate that it should be mapped to a database table. We also annotate the id attribute with @Id to indicate that it is the primary key of the table.

Next, we create a SessionFactory using the Configuration class, which is used to configure Hibernate. We then use the SessionFactory to create a Session, which represents a single unit of work with the database. We start a transaction, execute a query using the createQuery method, and retrieve the results as a list of Employee objects. Finally, we commit the transaction, close the Session, and print the results.

With automatic mapping, Hibernate automatically maps the data in the employees table to the Employee class and its attributes, making it easy to work with databases in Java. This significantly reduces the amount of code needed to work with databases and makes it easier to maintain and change the database schema over time.

Mapping Types

Explanation

Automatic Mapping

Explanation

Related Articles

Kommentar verfassen Kommentieren abbrechen