> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud8-persistencia-en-bases-de-datos/aplicacions-e-bases-de-datos.md).

# Aplicacións e bases de datos

As **bases de datos en Java** son fundamentais para almacenar, xestionar e recuperar grandes cantidades de datos de maneira estruturada. Java proporciona diversas ferramentas e bibliotecas que facilitan a conexión e manipulación de bases de datos de diversas tipoloxías, que van desde as relacionais tradicionais (Oracle, MySQL, SQL Server,...) ata enfoques NoSQL (MongoDB, Cassandra, Redis, HBase,...)

Entre os diferentes enfoques que se poden adoptar para traballar en Java contra unha base de datos imos a destacar dous:

## JDBC (Java Database Connectivity)

**JDBC** é un estándar de Java para interactuar con bases de datos. Esta composto por unha serie de interfaces que permiten realizar as seguintes operacións:

* Iniciar e finalziar unha conexión con servidor de base de datos
* Executar consultas de SQL integradas en Java
* Procesar o resultado da execución das consultas de SQL
* Xestionar transaccións

JDBC define un conxunto de interfaces. Cada fabricante de bases de datos, define un **controlador** que implementa de maneira concreta e de acordo as súas especificacións do sistema xestor de base de datos.

```java
String sql = "SELECT * FROM ALUMNOS";
try (Connection conn = DriverManager.getConnection(url, user, pass);
     Statement pstmt = conn.createStatement(sql)) {
     ResultSet rs = stmt.executeQuery(sql);
     while (rs.next()) {
        int id = rs.getInt("id");
        String nome = rs.getString("nombre");
        
        // Aquí o alumno vería como os datos saen da DB ao mundo Java
        System.out.println("Alumno: " + id + " - Nome: " + nome);
    }
} catch (SQLException e) {
    e.printStackTrace();
}
```

## ORM (Object Relational Mapping)

Un ORM é unha técnica de programación - na que se traballa con un framework - utilizada para xestionar a persistencia de obxectos en bases de datos relacionais. En vez de traballar directamente con táboas, columnas e consultas SQL, un ORM permite mapear as **entidades de obxectos** en código (normalmente clases Java ou en outros idiomas) ás **táboas de bases de datos**.

A idea principal é simplificar a persistencia de datos ao transformar as táboas, filas e columnas da base de datos en clases, obxectos e atributos da linguaxe de programación, e viceversa, para o que se van a empregar unga serie de anotacións que nos van a permitir establecer a equivalencia.

```java
CREATE TABLE USUARIOS (
    id int unsigned primary_key,
    nombre varchar(50)
);
```

```java
@Entity
public class Usuario {
    @Id
    private int id;
    //Atributos, getter y setters....
}
```

```java
// 1. Creamos o obxecto Java (Entidade)
Usuario novoUsuario = new Usuario();
novoUsuario.setInd(1); 
novoUsuario.setNombre("Brais");

// 2. Xestionamos a persistencia co EntityManager
EntityTransaction transaction = em.getTransaction();
try {
    transaction.begin();       
    em.persist(novoUsuario);   // A chamada de persist xenera por debaixo un INSERT
    transaction.commit();      
    System.out.println("Usuario gardado correctamente!");
} catch (Exception e) {
    if (transaction.isActive()) {
        transaction.rollback();
    }
    e.printStackTrace();
}
```

### JPA

**JPA** (**Java Persistence API**) é unha API estándar de Java para xestionar bases de datos mediante obxectos, sen necesidade de escribir consultas SQL manualmente.

* **Permite traballar con bases de datos de forma máis sinxela e eficiente.**
* **Evita o uso directo de JDBC**, facendo o código máis limpo e mantible.
* **Usa “ORM”** (**Object-Relational Mapping**) para transformar táboas en obxectos de Java.

**JPA é unha especificación**, non unha implantación. Para usala, necesitamos unha implementación real, como **Hibernate**. **JPA** define as regras e métodos para traballar con bases de datos; e **Hibernate** é unha implantación popular de JPA que realmente executa as operacións.

### Hibernate

**Hibernate** é un *framework* de Java que serve para traballar cunha base de datos dun xeito máis sinxelo. En lugar de escribir sentenzas SQL a man, Hibernate permite traballar con **obxectos de Java** e el encárgase de gardalos, actualizalos e recuperalos da base de datos.

Hibernate é unha das implementacións mais populares de JPA, que ademais ofrece pois unha serie de caracteristicas propias:

* Implementa JPA
* Xeración automática de esquemas de bases de datos
* Compatitibilidade con consultas nativas SQL e HQL (Hibernate Query Language)
* Soporte avanzado para caché e optimización do rendemento


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://educacion.gitbook.io/programacion/ud8-persistencia-en-bases-de-datos/aplicacions-e-bases-de-datos.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.