# Jakarta Data en Quarkus: Repositorios Simplificados

## **Introducción**

Jakarta Data es una nueva especificación que simplifica el acceso a datos mediante repositorios declarativos. Quarkus soporta completamente Jakarta Data y además incluye ejemplos de Panache Next, la nueva versión experimental de Panache.

## **¿Qué es Jakarta Data?**

Jakarta Data permite crear repositorios simplemente definiendo interfaces con métodos. Las implementaciones se generan automáticamente en tiempo de compilación usando el procesador de anotaciones de Hibernate.

## **Repositorios Jakarta Data**

### **Repositorio Básico**

```go
@Repository(dataStore = "DCHeroes")
public interface HeroRepository {
    @Find
    Optional<Hero> findById(Long id);
    
    @Find
    List<Hero> findByName(@Pattern String name);
    
    @Find
    List<Hero> findAll();
    
    @Insert
    void save(Hero hero);
    
    @Delete
    void deleteById(Long id);
}
```

### **Anotaciones Jakarta Data**

* `@Find`: Buscar entidades
    
* `@Insert`: Insertar entidades
    
* `@Delete`: Eliminar entidades
    
* `@Pattern`: Búsqueda parcial (LIKE)
    
* `@Repository`: Marca la interfaz como repositorio
    

## **Panache Next (Experimental)**

Panache Next es una nueva versión experimental que combina Panache con Jakarta Data:

### **Entidad con Repositorio Anidado**

```go
@Entity
public class HeroPanacheEntity extends PanacheEntity {
    public String name;
    public Integer powerLevel;
    
    public interface Repo extends PanacheRepository<HeroPanacheEntity> {
        default List<HeroPanacheEntity> findActive() {
            return find("isActive = true order by name").list();
        }
        
        default List<HeroPanacheEntity> findPowerful(int minLevel) {
            return find("powerLevel >= ?1 order by powerLevel desc", minLevel).list();
        }
    }
}
```

### **Active Record Pattern**

```go
@Transactional
public void createHero() {
    HeroPanacheEntity hero = new HeroPanacheEntity();
    hero.name = "Superman";
    hero.powerLevel = 95;
    
    // Persistir directamente
    hero.persist();
    
    // Modificar (se persiste automáticamente en managed entities)
    hero.name = "Superman Updated";
    
    // Eliminar directamente
    hero.delete();
}
```

### **Usar el Repositorio Anidado**

```go
@Inject
HeroPanacheEntity.Repo heroRepo;

public void useRepository() {
    List<HeroPanacheEntity> powerful = heroRepo.findPowerful(80);
    List<HeroPanacheEntity> active = heroRepo.findActive();
}
```

## **Características de Panache Next**

1. **Repositorios Anidados**: Mantiene operaciones cerca de la entidad
    
2. **Active Record**: Permite operaciones directas en instancias
    
3. **Flexibilidad**: Puedes usar Active Record o Repository según necesites
    
4. **Type-safe Queries**: Con @HQL (cuando esté disponible)
    

## **Comparación: Jakarta Data vs Panache Next**

| **Característica** | **Jakarta Data Puro** | **Panache Next** |
| --- | --- | --- |
| Entidades | JPA estándar | PanacheEntity |
| Repositorios | Interfaces separadas | Anidados en entidades |
| Active Record | No | Sí |
| Queries type-safe | @Find con métodos derivados | @HQL (experimental) |
| Queries tradicionales | No | Sí (métodos de Panache) |

## **Ejemplo Completo**

Nuestro demo muestra:

* Repositorios Jakarta Data con @Find, @Insert, @Delete
    
* Panache Next con entidades y repositorios anidados
    
* Active Record Pattern
    
* Queries con métodos de Panache
    
* Estructura preparada para @HQL cuando esté disponible
    

## **Ventajas en Quarkus**

1. **Generación Automática**: Implementaciones generadas en tiempo de compilación
    
2. **Type-Safe**: Validación en tiempo de compilación
    
3. **Menos Código**: No necesitas escribir implementaciones
    
4. **Flexibilidad**: Panache Next combina lo mejor de ambos mundos
    

## **Nota sobre Panache Next**

Panache Next es experimental y puede cambiar:

* Los nombres pueden cambiar
    
* La API puede cambiar
    
* @HQL aún no está disponible en Jakarta Data 1.0.1
    

Los ejemplos muestran la estructura que tendría con @HQL cuando esté disponible.

## **Conclusión**

Jakarta Data simplifica enormemente el acceso a datos, y Panache Next promete combinar lo mejor de Panache y Jakarta Data. La generación automática de implementaciones hace que el código sea más limpio y mantenible.

## **Recursos**

* [Demo completo](file:///Users/josediaz/Projects/JoeDayz/jakartaee-2026/quarkus-demos/jakarta-data/)
    
* [Jakarta Data Specification](https://jakarta.ee/specifications/data/)
    
* [Quarkus Hibernate ORM Guide](https://quarkus.io/guides/hibernate-orm)