How can a class be linked to a database in Java?

In Java, connecting a class to a database is usually done using Object-Relational Mapping (ORM) technologies or JDBC.

JDBC (Java Database Connectivity)

JDBC is an API that provides a standard way to access relational databases. It allows executing SQL queries from Java code.

Steps:

1. Load the database driver.
2. Establish a connection (Connection).
3. Create a Statement or PreparedStatement object.
4. Execute the SQL query.
5. Process the results (ResultSet).
6. Close resources (Connection, Statement, ResultSet).

Example of retrieving data:

// Example of retrieving data from the "users" table
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Load driver (depends on the DB)
    Class.forName("org.postgresql.Driver"); // Example for PostgreSQL

    // Establish connection
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // Create Statement
    statement = connection.createStatement();

    // Execute query
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Process results
    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String email = resultSet.getString("email");
        System.out.println("User ID: " + id + ", Name: " + name + ", Email: " + email);
    }
} catch (SQLException | ClassNotFoundException e) {
    e.printStackTrace();
} finally {
    // Close resources
    try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

ORM (Object-Relational Mapping)

ORM frameworks (e.g., Hibernate, JPA based on Hibernate) automate the process of mapping Java objects to database tables and vice versa. They allow working with data as Java objects, abstracting SQL.

Main concepts:

• Entity: A regular POJO class annotated with special annotations, corresponding to a table in the database.
• Annotations: Used to describe relationships between the class and the table, fields and columns, entity relationships (one-to-one, one-to-many, etc.).
• EntityManager (JPA) / Session (Hibernate): Interfaces for performing operations with entities (save, update, delete, find).

Example entity:

// Example of User entity
import javax.persistence.*;

@Entity // Indicates this is an entity
@Table(name = "users") // Specifies the corresponding table name
public class User {

    @Id // Indicates primary key
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID generation strategy
    private Long id;

    @Column(name = "name") // Corresponding column name
    private String name;

    @Column(name = "email", unique = true)
    private String email;

    // Getters, setters, constructors
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

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

Example of saving an entity using JPA:

// Example of saving a User entity
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // from persistence.xml
EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();

try {
    transaction.begin();

    User newUser = new User();
    newUser.setName("John Doe");
    newUser.setEmail("john.doe@example.com");

    em.persist(newUser); // Save entity

    transaction.commit();
} catch (Exception e) {
    if (transaction != null && transaction.isActive()) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    em.close();
    emf.close();
}

Choosing between JDBC and ORM:

Characteristic	JDBC	ORM (JPA/Hibernate)
Complexity	Low-level abstraction, more code.	High-level abstraction, less code.
Flexibility	Full control over SQL.	Limited flexibility to work directly with SQL.
Performance	Potentially higher with manual optimization.	May be lower due to ORM overhead.
Development time	More time spent on manual data handling.	Less time, automation of many tasks.
Relationship support	Requires manual implementation.	Automated (one-to-one, one-to-many).

In modern Java applications, ORM frameworks are commonly used for database interactions due to their efficiency in development and maintenance. JDBC is used when full control over SQL is required or ORM is unsuitable for some reasons (e.g., very specific optimizations).